Je pense que cette question a déjà été posée mais bon.
J'ai une variable i dans mon fichier python ( qui va être lancer a la
main ). J'appelle ensuite une fonction d'un module qui elle même appelle
une fonction d'un 3ème module dans lequel je veux récupérer i sans le
passer en variable aux fonctions.
main.py :
=========
from module1 import *
i=5
affiche1()
module1.py :
============
from module2 import *
def affiche1():
affiche2()
module2.py :
============
def affiche2():
print i
J'ai bien essayé de mettre des 'global i' un peu partout mais ça marche
pas :o(
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
F. Petitjean
Bonjour,
Je pense que cette question a déjà été posée mais bon.
J'ai une variable i dans mon fichier python ( qui va être lancer a la main ). Cela veut dire quoi être lancé à la main ? Vous le metez sur une
disquette que vous balancez par la fenêtre ? :-)
J'appelle ensuite une fonction d'un module qui elle même appelle une fonction d'un 3ème module dans lequel je veux récupérer i sans le passer en variable aux fonctions. Et pourquoi donc ne pas passer en variable/paramètre de fonction ?
main.py : ======== > from module1 import * C'est dangereux import *, et import affiche1 n'est pas très long à
taper avec les éditeurs actuels
i=5 affiche1()
module1.py : =========== > from module2 import * import module2 # pour changer
def affiche1(): affiche2() module2.affiche2()
module2.py : =========== import main # accéder à i def affiche2(): print i print main.i
J'ai bien essayé de mettre des 'global i' un peu partout mais ça marche pas :o( Une règle simple : ne pas mettre de global et passer pylint. Si vraiment
vous avez besoin de global revoir la conception.
Merci pour conseils 1. Ne pas mettre des variables dont le nom ne veut rien dire
2. Réfléchir un peu avant de mettre des modules partout, faire des regroupements judicieux pour ne pas avoir de circuit (circular import)
Faudrait nous donner un peu plus d'informatiosn sur ce que vous voulez faire.
Cordialement
Rémi
Bonjour,
Je pense que cette question a déjà été posée mais bon.
J'ai une variable i dans mon fichier python ( qui va être lancer a la
main ).
Cela veut dire quoi être lancé à la main ? Vous le metez sur une
disquette que vous balancez par la fenêtre ? :-)
J'appelle ensuite une fonction d'un module qui elle même appelle
une fonction d'un 3ème module dans lequel je veux récupérer i sans le
passer en variable aux fonctions.
Et pourquoi donc ne pas passer en variable/paramètre de fonction ?
main.py :
======== > from module1 import *
C'est dangereux import *, et import affiche1 n'est pas très long à
taper avec les éditeurs actuels
i=5
affiche1()
module1.py :
=========== > from module2 import *
import module2 # pour changer
def affiche1():
affiche2()
module2.affiche2()
module2.py :
=========== import main # accéder à i
def affiche2():
print i
print main.i
J'ai bien essayé de mettre des 'global i' un peu partout mais ça marche
pas :o(
Une règle simple : ne pas mettre de global et passer pylint. Si vraiment
vous avez besoin de global revoir la conception.
Merci pour conseils
1. Ne pas mettre des variables dont le nom ne veut rien dire
2. Réfléchir un peu avant de mettre des modules partout, faire des
regroupements judicieux pour ne pas avoir de circuit (circular import)
Faudrait nous donner un peu plus d'informatiosn sur ce que vous voulez
faire.
Je pense que cette question a déjà été posée mais bon.
J'ai une variable i dans mon fichier python ( qui va être lancer a la main ). Cela veut dire quoi être lancé à la main ? Vous le metez sur une
disquette que vous balancez par la fenêtre ? :-)
J'appelle ensuite une fonction d'un module qui elle même appelle une fonction d'un 3ème module dans lequel je veux récupérer i sans le passer en variable aux fonctions. Et pourquoi donc ne pas passer en variable/paramètre de fonction ?
main.py : ======== > from module1 import * C'est dangereux import *, et import affiche1 n'est pas très long à
taper avec les éditeurs actuels
i=5 affiche1()
module1.py : =========== > from module2 import * import module2 # pour changer
def affiche1(): affiche2() module2.affiche2()
module2.py : =========== import main # accéder à i def affiche2(): print i print main.i
J'ai bien essayé de mettre des 'global i' un peu partout mais ça marche pas :o( Une règle simple : ne pas mettre de global et passer pylint. Si vraiment
vous avez besoin de global revoir la conception.
Merci pour conseils 1. Ne pas mettre des variables dont le nom ne veut rien dire
2. Réfléchir un peu avant de mettre des modules partout, faire des regroupements judicieux pour ne pas avoir de circuit (circular import)
Faudrait nous donner un peu plus d'informatiosn sur ce que vous voulez faire.
Cordialement
Rémi
Do Re Mi chel La Si Do
Bonjour !
C'est normal, les variables ne "passent" pas entre modules.
Solution :
Utilise un module pour les échanges inter-modules. Par exemple, tu crées interm.py, avec une seule ligne : j3 # j'ai volontairement utilisé un autre nom de variable.
Ensuite, tu modifies ton main, comme suit : import interm from module1 import *
interm.i=5 affiche1()
Et modifies le module2 : import interm
def affiche2(): print interm.i
Le problème, dans tes scripts, c'est que module2 est exécuté avant main.py (via l'importation du module1). On ne peut donc pas y importer une définition de main.
Autre chose : les "from ... import *" ramènent un ensemble de noms d'objets, avec une difficulté pour voir lequels sont définis. Le risque de conflit de nom est alors grand. A réserver, de préférence, à des modules que l'on connaît bien.
@-salutations -- Michel Claveau
Bonjour !
C'est normal, les variables ne "passent" pas entre modules.
Solution :
Utilise un module pour les échanges inter-modules. Par exemple, tu crées
interm.py, avec une seule ligne :
j3 # j'ai volontairement utilisé un autre nom de variable.
Ensuite, tu modifies ton main, comme suit :
import interm
from module1 import *
interm.i=5
affiche1()
Et modifies le module2 :
import interm
def affiche2():
print interm.i
Le problème, dans tes scripts, c'est que module2 est exécuté avant main.py
(via l'importation du module1). On ne peut donc pas y importer une
définition de main.
Autre chose : les "from ... import *" ramènent un ensemble de noms
d'objets, avec une difficulté pour voir lequels sont définis. Le risque de
conflit de nom est alors grand.
A réserver, de préférence, à des modules que l'on connaît bien.
C'est normal, les variables ne "passent" pas entre modules.
Solution :
Utilise un module pour les échanges inter-modules. Par exemple, tu crées interm.py, avec une seule ligne : j3 # j'ai volontairement utilisé un autre nom de variable.
Ensuite, tu modifies ton main, comme suit : import interm from module1 import *
interm.i=5 affiche1()
Et modifies le module2 : import interm
def affiche2(): print interm.i
Le problème, dans tes scripts, c'est que module2 est exécuté avant main.py (via l'importation du module1). On ne peut donc pas y importer une définition de main.
Autre chose : les "from ... import *" ramènent un ensemble de noms d'objets, avec une difficulté pour voir lequels sont définis. Le risque de conflit de nom est alors grand. A réserver, de préférence, à des modules que l'on connaît bien.
@-salutations -- Michel Claveau
ReM
Je demandais pas un cours sur la programmation j'essayais de donner un exemple simple :p
en fait j'ai plusieurs modules : un module personne ou j'ai des fonctions de création et de modifications de personnes un module rendezvous qui j'ai la creation et la modification de rendez-vous. Et dans se module j'apelle une fonction de création (ou de modifactions ) de personnes.
Ensuite j'utilise un cgi qui me gère tout ça !
Le but est de savoir qui fait quoi et quand. Donc à chaque fois que je modifie une personne, je veux connaitre qui l'a fait. Or avant j'utilisais un htaccess donc je pouvais récupérer l'utilisateur avec un os.environ['REMOTE_USER'] mais maintenant je passe par un login dans une page HTML que je conserve en variable de session.
Donc quand j'exécute mon CGI, je passe un numéro de session et je retrouve mon utilisateur mais ensuite j'appelle ( par exemple ) une fonction de création de rdv avec création de la personne, donc je vais dans le module rendezvous et ensuite dans le module personne. Mais je ne voulais pas remodifier l'ensemble des mes fonctions en passant l'utilisateur !
Voila un peu plus d'explications sur ce que je veux faire mais je pense que mon exemple avec ma variable i est très compréhensible :)
Rémi
Bonjour,
Je pense que cette question a déjà été posée mais bon.
J'ai une variable i dans mon fichier python ( qui va être lancer a la main ).
Cela veut dire quoi être lancé à la main ? Vous le metez sur une disquette que vous balancez par la fenêtre ? :-)
J'appelle ensuite une fonction d'un module qui elle même appelle une fonction d'un 3ème module dans lequel je veux récupérer i sans le passer en variable aux fonctions.
Et pourquoi donc ne pas passer en variable/paramètre de fonction ?
main.py : ======== >>from module1 import *
C'est dangereux import *, et import affiche1 n'est pas très long à taper avec les éditeurs actuels
i=5 affiche1()
module1.py : =========== >>from module2 import *
import module2 # pour changer
def affiche1(): affiche2()
module2.affiche2()
module2.py : =========== > import main # accéder à i
def affiche2(): print i
print main.i
J'ai bien essayé de mettre des 'global i' un peu partout mais ça marche pas :o(
Une règle simple : ne pas mettre de global et passer pylint. Si vraiment vous avez besoin de global revoir la conception.
Merci pour conseils
1. Ne pas mettre des variables dont le nom ne veut rien dire 2. Réfléchir un peu avant de mettre des modules partout, faire des regroupements judicieux pour ne pas avoir de circuit (circular import)
Faudrait nous donner un peu plus d'informatiosn sur ce que vous voulez faire.
Cordialement
Rémi
Je demandais pas un cours sur la programmation j'essayais de donner un
exemple simple :p
en fait j'ai plusieurs modules :
un module personne ou j'ai des fonctions de création et de modifications
de personnes
un module rendezvous qui j'ai la creation et la modification de
rendez-vous. Et dans se module j'apelle une fonction de création (ou de
modifactions ) de personnes.
Ensuite j'utilise un cgi qui me gère tout ça !
Le but est de savoir qui fait quoi et quand. Donc à chaque fois que je
modifie une personne, je veux connaitre qui l'a fait. Or avant
j'utilisais un htaccess donc je pouvais récupérer l'utilisateur avec un
os.environ['REMOTE_USER'] mais maintenant je passe par un login dans une
page HTML que je conserve en variable de session.
Donc quand j'exécute mon CGI, je passe un numéro de session et je
retrouve mon utilisateur mais ensuite j'appelle ( par exemple ) une
fonction de création de rdv avec création de la personne, donc je vais
dans le module rendezvous et ensuite dans le module personne. Mais je ne
voulais pas remodifier l'ensemble des mes fonctions en passant
l'utilisateur !
Voila un peu plus d'explications sur ce que je veux faire mais je pense
que mon exemple avec ma variable i est très compréhensible :)
Rémi
Bonjour,
Je pense que cette question a déjà été posée mais bon.
J'ai une variable i dans mon fichier python ( qui va être lancer a la
main ).
Cela veut dire quoi être lancé à la main ? Vous le metez sur une
disquette que vous balancez par la fenêtre ? :-)
J'appelle ensuite une fonction d'un module qui elle même appelle
une fonction d'un 3ème module dans lequel je veux récupérer i sans le
passer en variable aux fonctions.
Et pourquoi donc ne pas passer en variable/paramètre de fonction ?
main.py :
======== >>from module1 import *
C'est dangereux import *, et import affiche1 n'est pas très long à
taper avec les éditeurs actuels
i=5
affiche1()
module1.py :
=========== >>from module2 import *
import module2 # pour changer
def affiche1():
affiche2()
module2.affiche2()
module2.py :
=========== >
import main # accéder à i
def affiche2():
print i
print main.i
J'ai bien essayé de mettre des 'global i' un peu partout mais ça marche
pas :o(
Une règle simple : ne pas mettre de global et passer pylint. Si vraiment
vous avez besoin de global revoir la conception.
Merci pour conseils
1. Ne pas mettre des variables dont le nom ne veut rien dire
2. Réfléchir un peu avant de mettre des modules partout, faire des
regroupements judicieux pour ne pas avoir de circuit (circular import)
Faudrait nous donner un peu plus d'informatiosn sur ce que vous voulez
faire.
Je demandais pas un cours sur la programmation j'essayais de donner un exemple simple :p
en fait j'ai plusieurs modules : un module personne ou j'ai des fonctions de création et de modifications de personnes un module rendezvous qui j'ai la creation et la modification de rendez-vous. Et dans se module j'apelle une fonction de création (ou de modifactions ) de personnes.
Ensuite j'utilise un cgi qui me gère tout ça !
Le but est de savoir qui fait quoi et quand. Donc à chaque fois que je modifie une personne, je veux connaitre qui l'a fait. Or avant j'utilisais un htaccess donc je pouvais récupérer l'utilisateur avec un os.environ['REMOTE_USER'] mais maintenant je passe par un login dans une page HTML que je conserve en variable de session.
Donc quand j'exécute mon CGI, je passe un numéro de session et je retrouve mon utilisateur mais ensuite j'appelle ( par exemple ) une fonction de création de rdv avec création de la personne, donc je vais dans le module rendezvous et ensuite dans le module personne. Mais je ne voulais pas remodifier l'ensemble des mes fonctions en passant l'utilisateur !
Voila un peu plus d'explications sur ce que je veux faire mais je pense que mon exemple avec ma variable i est très compréhensible :)
Rémi
Bonjour,
Je pense que cette question a déjà été posée mais bon.
J'ai une variable i dans mon fichier python ( qui va être lancer a la main ).
Cela veut dire quoi être lancé à la main ? Vous le metez sur une disquette que vous balancez par la fenêtre ? :-)
J'appelle ensuite une fonction d'un module qui elle même appelle une fonction d'un 3ème module dans lequel je veux récupérer i sans le passer en variable aux fonctions.
Et pourquoi donc ne pas passer en variable/paramètre de fonction ?
main.py : ======== >>from module1 import *
C'est dangereux import *, et import affiche1 n'est pas très long à taper avec les éditeurs actuels
i=5 affiche1()
module1.py : =========== >>from module2 import *
import module2 # pour changer
def affiche1(): affiche2()
module2.affiche2()
module2.py : =========== > import main # accéder à i
def affiche2(): print i
print main.i
J'ai bien essayé de mettre des 'global i' un peu partout mais ça marche pas :o(
Une règle simple : ne pas mettre de global et passer pylint. Si vraiment vous avez besoin de global revoir la conception.
Merci pour conseils
1. Ne pas mettre des variables dont le nom ne veut rien dire 2. Réfléchir un peu avant de mettre des modules partout, faire des regroupements judicieux pour ne pas avoir de circuit (circular import)
Faudrait nous donner un peu plus d'informatiosn sur ce que vous voulez faire.
