Passer des variables en python lors de l'utilisation d'une importation *

Comment puis-je faire de cette impression de "baz" quand je lance b.py?

a.py

    def foo():
        global bar
        print bar

b.py

    from a import *
    bar = "baz"
    foo()

OriginalL'auteur Null | 2010-04-30

6

Dans un exemple aussi simple que cela, la vraie réponse dans la plupart des cas est d'utiliser des arguments de la fonction (comme cela a été mentionné). Mais si le point était de tester Python règles de portée, alors je pense que je peux préciser...

Si vous êtes en train de penser à partir d'un C/C++ contexte, alors vous pourrait facilement être confondu par la façon Python importations de travail. Module importations ne fonctionnent pas comme les directives #include. En C/C++, le compilateur va utiliser la directive #include comme marqueurs pour l'insertion de code source à partir d'une autre source/fichiers d'en-tête dans le fichier source (c'est une copie locale de la source fourni). Le résultat est que, lorsqu'il est compilé, globals seront passées en revue pour que l'unité de compilation qui inclut tous les #inclus source. Vous pouvez faire des trucs sales avec l'ordre du #comprend à faire certains vraiment difficile à comprendre le code. 😛

Un Python import ne pas proposer une instance de module qui partage le module d'importation de la portée. Au lieu de cela, il fournit une référence à un singleton module objet qui est partagé dans le courant de l'exécution de l'interprète. Le module objet est instancié la première fois qu'il est importé. Les importations ultérieures, si dans le même module ou de plusieurs modules, simplement obtenir une référence à ce même objet module. Un "global" est global à l'intérieur de son module. D'autres modules, il ne sera accessible qu'au moyen d'un renvoi à ce module. Par exemple, dans un.py, vous devez importer b pour accéder à la valeur de "bar".

Dans votre exemple, vous ne devriez pas le faire car vous aurez cyclique des importations. Si vous avez vraiment besoin pour définir la portée module de l'état, vous pouvez définir un module global de la b module: a.bar = bar (la séquence de la dépendance de l'enfer).

Ne change pas une.py,
```
def foo():
    print bar
```
mais le changement b.py:
```
import a
a.bar = "baz"
a.foo()
```
Une meilleure encapsulé par exemple, serait un.py fournir une fonction pour définir son état global de sorte que b.py pourriez exécuter simplement a.set_module_state( "baz" ).

OriginalL'auteur Jeremy Brown
2

Vous ne pouvez pas. Le reste de la a module ne sont pas affectés par la b module, même si la b module de copies à ses propres globals.

from a import * dans b.py fait tout simplement foo dans b être une référence à la même fonction de l'objet que foo dans a est une référence. Il ne copie pas la fonction. La fonction n'a pas soudainement utiliser b'globals lorsqu'il accède à un nom global.

Passer en argument à la place:
```
import a
bar = "baz"
a.foo(bar)
```
Ou, si vous souhaitez simplement modifier a.bar, vous pouvez attribuer à une. Qui affecte tous appels à foo(), bien que, non seulement l'un de b.

Je proposerais que les débutants oublier que Python a même un global mot-clé. (Je voudrais aussi suggérer qu'il soit sorti de la langue, mais je suppose que quelqu'un a trouvé une bonne utilisation pour cela quelque part)
Qui a parlé de la global mot-clé? C'est un no-op dans le cas des OP question.
C'est pourquoi sa présence est source de confusion pour les débutants à partir d'autres langues avec différents concepts de portée.

OriginalL'auteur Thomas Wouters
1

C'est terriblement pas dans l'esprit de python, mais...
```
a.py
 def foo():
    print bar

b.py
 from a import *
 a.bar = "baz"
 foo()
```
J'ai tendance à éviter from <module> import * plus. Votre programmation est peu probable d'être limité par votre vitesse de frappe, et l'ajout du nom du module ne doit pas être trop difficile à supporter. La définition de variables dans un autre module est quelque chose que je n'ai pas particulièrement soin de soit. Donc oui, la meilleure formation serait:
```
a.py
 def foo(bar):
    print bar

b.py
 import a
 bar = "baz"
 a.foo(bar)
```
Et de regarder, c'est même moins de frappe!

a.bar = "baz" ne fonctionne pas si vous n'avez from a import *. from a import * de ne pas introduire le nom a, seul le nom foo (puisque c'est tout ce qui est en a'globals.)

OriginalL'auteur dash-tom-bang
0

Sinon, et c'est mauvais Python, si votre projet vraiment exigences des variables globales, et il n'est pas nécessaire pour vos modules, pour être vraiment "modulaire" (c'est à dire ré-utilisables dans d'autres projets sans modification), vous pouvez toujours introduire une troisième module globals.py:
```
a.py

    import globals
    def foo():
        #global bar
        print globals.bar

b.py

    import globals
    from a import *
    globals.bar = "baz"
    foo()

globals.py

    #This module contains global variables
    bar = ""
```
Cela fonctionne parce que, comme Jeremy l'a souligné, un module objet n'est créé la première fois qu'il est importé - toute la poursuite des importations, même à partir d'autres modules, il suffit de produire une référence à ce même objet.

OriginalL'auteur R160K

Vous devez vous connecter pour publier un commentaire.