Désolé pour le titre peu explicite, mais je n'ai pas trouvé mieux à
cette heure tardive ;-)
Voilà je dispose d'une bibliothèque de fonctions très optimisées en C et
son équivalent en Python (beaucoup plus lent) et je souhaiterais
fabriquer une bibliothèque surcouche qui sélectionne la plus appropriée
suivant la disponibilité de la bibliothèque en C (qui nécessite une
compilation donc qui n'est pas portable !).
Par exemple je dispose tout le temps de toto.py mais pas tout le temps
de toto.so (ou toto.sl, ou toto.dll...).
Comment puis-je faire cela de manière pythonesque ?
Est-ce que tenter l'importation de toto.so, intercepter l'exception ou
l'échec et ensuite importer toto.py est une bonne solution ? (je ne sais
même pas faire cela d'ailleurs, mais je suppose que c'est possible...)
Quelque chose dans le genre
try:
import toto_so
except:
import toto
mode_lent = 1
Puis plus loin dans le code :
if mode_lent == 1:
...code...
Je ne suis pas sûr que de mettre une variable globale soit la bonne
méthode non plus, mais je ne vois pas l'équivalent en python des #define
en C.
Si quelqu'un d'expérimenté pouvait me donner son avis...
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Do Re Mi chel La Si Do
Bonjour !
En alternative aux variables globales, tu peux faire une classe (singleton ?), et les mettre comme propriété de la classe. Cela permet un meilleur contrôle.
Autre possibilité, créer un module spécialisé. Avec l'avantage de pouvoir partager les "variables globales" entre plusieurs modules.
Autres idées : passer par les variables d'environnement ; passer par le registre ; utiliser mmap ; avec un fichier de config modifiable ; via un serveur COM (windows seulement). Certaines de ces méthodes permettant d'avoir des variables globales à plusieurs applications.
@-salutations -- Michel Claveau
Bonjour !
En alternative aux variables globales, tu peux faire une classe (singleton
?), et les mettre comme propriété de la classe. Cela permet un meilleur
contrôle.
Autre possibilité, créer un module spécialisé. Avec l'avantage de pouvoir
partager les "variables globales" entre plusieurs modules.
Autres idées : passer par les variables d'environnement ; passer par le
registre ; utiliser mmap ; avec un fichier de config modifiable ; via un
serveur COM (windows seulement). Certaines de ces méthodes permettant
d'avoir des variables globales à plusieurs applications.
En alternative aux variables globales, tu peux faire une classe (singleton ?), et les mettre comme propriété de la classe. Cela permet un meilleur contrôle.
Autre possibilité, créer un module spécialisé. Avec l'avantage de pouvoir partager les "variables globales" entre plusieurs modules.
Autres idées : passer par les variables d'environnement ; passer par le registre ; utiliser mmap ; avec un fichier de config modifiable ; via un serveur COM (windows seulement). Certaines de ces méthodes permettant d'avoir des variables globales à plusieurs applications.
@-salutations -- Michel Claveau
Yermat
Christophe wrote:
Bonjour,
Désolé pour le titre peu explicite, mais je n'ai pas trouvé mieux à cette heure tardive ;-)
Voilà je dispose d'une bibliothèque de fonctions très optimisées en C et son équivalent en Python (beaucoup plus lent) et je souhaiterais fabriquer une bibliothèque surcouche qui sélectionne la plus appropriée suivant la disponibilité de la bibliothèque en C (qui nécessite une compilation donc qui n'est pas portable !).
Par exemple je dispose tout le temps de toto.py mais pas tout le temps de toto.so (ou toto.sl, ou toto.dll...).
Comment puis-je faire cela de manière pythonesque ? Est-ce que tenter l'importation de toto.so, intercepter l'exception ou l'échec et ensuite importer toto.py est une bonne solution ? (je ne sais même pas faire cela d'ailleurs, mais je suppose que c'est possible...)
Quelque chose dans le genre
try: import toto_so except: import toto mode_lent = 1
Puis plus loin dans le code :
if mode_lent == 1: ...code...
Je ne suis pas sûr que de mettre une variable globale soit la bonne méthode non plus, mais je ne vois pas l'équivalent en python des #define en C.
Si quelqu'un d'expérimenté pouvait me donner son avis...
Merci d'avance !
Perso je ferais plutôt :
try: import toto_so as toto except ImportError: import toto
if toto.mode_lent: ...
Et bien entendu dans le module toto.py et toto.so j'ai une variable mode_lent à vrai ou faux...
-- Yermat
Christophe wrote:
Bonjour,
Désolé pour le titre peu explicite, mais je n'ai pas trouvé mieux à
cette heure tardive ;-)
Voilà je dispose d'une bibliothèque de fonctions très optimisées en C et
son équivalent en Python (beaucoup plus lent) et je souhaiterais
fabriquer une bibliothèque surcouche qui sélectionne la plus appropriée
suivant la disponibilité de la bibliothèque en C (qui nécessite une
compilation donc qui n'est pas portable !).
Par exemple je dispose tout le temps de toto.py mais pas tout le temps
de toto.so (ou toto.sl, ou toto.dll...).
Comment puis-je faire cela de manière pythonesque ?
Est-ce que tenter l'importation de toto.so, intercepter l'exception ou
l'échec et ensuite importer toto.py est une bonne solution ? (je ne sais
même pas faire cela d'ailleurs, mais je suppose que c'est possible...)
Quelque chose dans le genre
try:
import toto_so
except:
import toto
mode_lent = 1
Puis plus loin dans le code :
if mode_lent == 1:
...code...
Je ne suis pas sûr que de mettre une variable globale soit la bonne
méthode non plus, mais je ne vois pas l'équivalent en python des #define
en C.
Si quelqu'un d'expérimenté pouvait me donner son avis...
Merci d'avance !
Perso je ferais plutôt :
try:
import toto_so as toto
except ImportError:
import toto
if toto.mode_lent:
...
Et bien entendu dans le module toto.py et toto.so j'ai une variable
mode_lent à vrai ou faux...
Désolé pour le titre peu explicite, mais je n'ai pas trouvé mieux à cette heure tardive ;-)
Voilà je dispose d'une bibliothèque de fonctions très optimisées en C et son équivalent en Python (beaucoup plus lent) et je souhaiterais fabriquer une bibliothèque surcouche qui sélectionne la plus appropriée suivant la disponibilité de la bibliothèque en C (qui nécessite une compilation donc qui n'est pas portable !).
Par exemple je dispose tout le temps de toto.py mais pas tout le temps de toto.so (ou toto.sl, ou toto.dll...).
Comment puis-je faire cela de manière pythonesque ? Est-ce que tenter l'importation de toto.so, intercepter l'exception ou l'échec et ensuite importer toto.py est une bonne solution ? (je ne sais même pas faire cela d'ailleurs, mais je suppose que c'est possible...)
Quelque chose dans le genre
try: import toto_so except: import toto mode_lent = 1
Puis plus loin dans le code :
if mode_lent == 1: ...code...
Je ne suis pas sûr que de mettre une variable globale soit la bonne méthode non plus, mais je ne vois pas l'équivalent en python des #define en C.
Si quelqu'un d'expérimenté pouvait me donner son avis...
Merci d'avance !
Perso je ferais plutôt :
try: import toto_so as toto except ImportError: import toto
if toto.mode_lent: ...
Et bien entendu dans le module toto.py et toto.so j'ai une variable mode_lent à vrai ou faux...
-- Yermat
Christophe Cavalaria
Christophe wrote:
Bonjour,
Désolé pour le titre peu explicite, mais je n'ai pas trouvé mieux à cette heure tardive ;-)
Voilà je dispose d'une bibliothèque de fonctions très optimisées en C et son équivalent en Python (beaucoup plus lent) et je souhaiterais fabriquer une bibliothèque surcouche qui sélectionne la plus appropriée suivant la disponibilité de la bibliothèque en C (qui nécessite une compilation donc qui n'est pas portable !).
Par exemple je dispose tout le temps de toto.py mais pas tout le temps de toto.so (ou toto.sl, ou toto.dll...).
Comment puis-je faire cela de manière pythonesque ? Est-ce que tenter l'importation de toto.so, intercepter l'exception ou l'échec et ensuite importer toto.py est une bonne solution ? (je ne sais même pas faire cela d'ailleurs, mais je suppose que c'est possible...)
Quelque chose dans le genre
try: import toto_so except: import toto mode_lent = 1
Puis plus loin dans le code :
if mode_lent == 1: ...code...
Je ne suis pas sûr que de mettre une variable globale soit la bonne méthode non plus, mais je ne vois pas l'équivalent en python des #define en C.
Si quelqu'un d'expérimenté pouvait me donner son avis...
Merci d'avance !
Moi je ferais plustot un truc du genre :
module toto_py.py version lente module toto_so.py version optimisee
module toto.py generique qui fait :
try: import toto_so except from toto_py import * else: from toto_so import *
Je ne sais pas si ça passe, mais sinon il suffit de faire une recopie explicite de tout les objets dans toto_py ou toto_so
Christophe wrote:
Bonjour,
Désolé pour le titre peu explicite, mais je n'ai pas trouvé mieux à
cette heure tardive ;-)
Voilà je dispose d'une bibliothèque de fonctions très optimisées en C et
son équivalent en Python (beaucoup plus lent) et je souhaiterais
fabriquer une bibliothèque surcouche qui sélectionne la plus appropriée
suivant la disponibilité de la bibliothèque en C (qui nécessite une
compilation donc qui n'est pas portable !).
Par exemple je dispose tout le temps de toto.py mais pas tout le temps
de toto.so (ou toto.sl, ou toto.dll...).
Comment puis-je faire cela de manière pythonesque ?
Est-ce que tenter l'importation de toto.so, intercepter l'exception ou
l'échec et ensuite importer toto.py est une bonne solution ? (je ne sais
même pas faire cela d'ailleurs, mais je suppose que c'est possible...)
Quelque chose dans le genre
try:
import toto_so
except:
import toto
mode_lent = 1
Puis plus loin dans le code :
if mode_lent == 1:
...code...
Je ne suis pas sûr que de mettre une variable globale soit la bonne
méthode non plus, mais je ne vois pas l'équivalent en python des #define
en C.
Si quelqu'un d'expérimenté pouvait me donner son avis...
Merci d'avance !
Moi je ferais plustot un truc du genre :
module toto_py.py version lente
module toto_so.py version optimisee
module toto.py generique qui fait :
try:
import toto_so
except
from toto_py import *
else:
from toto_so import *
Je ne sais pas si ça passe, mais sinon il suffit de faire une recopie
explicite de tout les objets dans toto_py ou toto_so
Désolé pour le titre peu explicite, mais je n'ai pas trouvé mieux à cette heure tardive ;-)
Voilà je dispose d'une bibliothèque de fonctions très optimisées en C et son équivalent en Python (beaucoup plus lent) et je souhaiterais fabriquer une bibliothèque surcouche qui sélectionne la plus appropriée suivant la disponibilité de la bibliothèque en C (qui nécessite une compilation donc qui n'est pas portable !).
Par exemple je dispose tout le temps de toto.py mais pas tout le temps de toto.so (ou toto.sl, ou toto.dll...).
Comment puis-je faire cela de manière pythonesque ? Est-ce que tenter l'importation de toto.so, intercepter l'exception ou l'échec et ensuite importer toto.py est une bonne solution ? (je ne sais même pas faire cela d'ailleurs, mais je suppose que c'est possible...)
Quelque chose dans le genre
try: import toto_so except: import toto mode_lent = 1
Puis plus loin dans le code :
if mode_lent == 1: ...code...
Je ne suis pas sûr que de mettre une variable globale soit la bonne méthode non plus, mais je ne vois pas l'équivalent en python des #define en C.
Si quelqu'un d'expérimenté pouvait me donner son avis...
Merci d'avance !
Moi je ferais plustot un truc du genre :
module toto_py.py version lente module toto_so.py version optimisee
module toto.py generique qui fait :
try: import toto_so except from toto_py import * else: from toto_so import *
Je ne sais pas si ça passe, mais sinon il suffit de faire une recopie explicite de tout les objets dans toto_py ou toto_so
Christophe
Bonjour !
Merci à Christophe et à Yermat pour leur réponse ! Et merci à vous pour ces 'trucs' pour remplacer les variables globales.
Par contre je n'ai pas bien compris les méthodes 'module spécialisé', 'registre' et 'mmap'. Pouvez-vous détailler ou bien m'orienter vers un site expliquant les méthodes ?
Merci cela m'aidera à coder 'proprement' ! ;-)
*********** REPLY SEPARATOR ***********
On Fri, 29 Apr 2005 08:10:13 +0200, "Do Re Mi chel La Si Do"
Bonjour !
En alternative aux variables globales, tu peux faire une classe (singleton ?), et les mettre comme propriété de la classe. Cela permet un meilleur contrôle.
Autre possibilité, créer un module spécialisé. Avec l'avantage de pouvoir partager les "variables globales" entre plusieurs modules.
Autres idées : passer par les variables d'environnement ; passer par le registre ; utiliser mmap ; avec un fichier de config modifiable ; via un serveur COM (windows seulement). Certaines de ces méthodes permettant d'avoir des variables globales à plusieurs applications.
@-salutations
Bonjour !
Merci à Christophe et à Yermat pour leur réponse !
Et merci à vous pour ces 'trucs' pour remplacer les variables globales.
Par contre je n'ai pas bien compris les méthodes 'module spécialisé',
'registre' et 'mmap'. Pouvez-vous détailler ou bien m'orienter vers un
site expliquant les méthodes ?
Merci cela m'aidera à coder 'proprement' ! ;-)
*********** REPLY SEPARATOR ***********
On Fri, 29 Apr 2005 08:10:13 +0200, "Do Re Mi chel La Si Do"
Bonjour !
En alternative aux variables globales, tu peux faire une classe
(singleton ?), et les mettre comme propriété de la classe. Cela permet
un meilleur contrôle.
Autre possibilité, créer un module spécialisé. Avec l'avantage de
pouvoir partager les "variables globales" entre plusieurs modules.
Autres idées : passer par les variables d'environnement ; passer par
le registre ; utiliser mmap ; avec un fichier de config modifiable ;
via un serveur COM (windows seulement). Certaines de ces méthodes
permettant d'avoir des variables globales à plusieurs applications.
Merci à Christophe et à Yermat pour leur réponse ! Et merci à vous pour ces 'trucs' pour remplacer les variables globales.
Par contre je n'ai pas bien compris les méthodes 'module spécialisé', 'registre' et 'mmap'. Pouvez-vous détailler ou bien m'orienter vers un site expliquant les méthodes ?
Merci cela m'aidera à coder 'proprement' ! ;-)
*********** REPLY SEPARATOR ***********
On Fri, 29 Apr 2005 08:10:13 +0200, "Do Re Mi chel La Si Do"
Bonjour !
En alternative aux variables globales, tu peux faire une classe (singleton ?), et les mettre comme propriété de la classe. Cela permet un meilleur contrôle.
Autre possibilité, créer un module spécialisé. Avec l'avantage de pouvoir partager les "variables globales" entre plusieurs modules.
Autres idées : passer par les variables d'environnement ; passer par le registre ; utiliser mmap ; avec un fichier de config modifiable ; via un serveur COM (windows seulement). Certaines de ces méthodes permettant d'avoir des variables globales à plusieurs applications.
