Circulaire (ou cyclique) importations en Python

Il y avait vraiment une bonne discussion sur ce fil à comp.lang.python l'année dernière. Il répond à votre question très soigneusement.

Les importations sont assez simple, vraiment. Juste rappeler les points suivants:

"importer" et "de xxx importation yyy" sont des instructions exécutables. Ils exécutent
lors de l'exécution du programme atteint cette ligne.

Si un module n'est pas dans sys.des modules, puis une importation crée le nouveau module
l'entrée dans le sys.les modules puis exécute le code dans le module. Il n'a pas
redonner le contrôle à l'appelant le module jusqu'à ce que l'exécution est terminée.

Si un module n'existe pas dans sys.les modules puis une importation retourne simplement que
module de si oui ou non il a terminé de s'exécuter. C'est la raison pourquoi
cyclique des importations peut retourner les modules qui semblent être en partie vide.

Enfin, l'exécution du script s'exécute dans un module nommé __principaux__, de l'importation
le script sous son propre nom, permettra de créer un nouveau module sans rapport avec
__principaux__.

Prendre que beaucoup de choses ensemble et vous ne devriez pas faire des surprises lors de l'importation
les modules.

Cyclique des importations de mettre fin, mais vous devez être prudent de ne pas utiliser les variations conjoncturelles modules importés au cours de l'initialisation du module.

Envisager les fichiers suivants:

un.py:

print "a in"
import sys
print "b imported: %s" % ("b" in sys.modules, )
import b
print "a out"

b.py:

print "b in"
import a
print "b out"
x = 3

Si vous exécutez une.py, vous aurez la suivante:

$ python a.py
a in
b imported: False
b in
a in
b imported: True
a out
b out
a out

Sur la deuxième importation de b.py (dans la deuxième a in), l'interpréteur Python ne pas importer b de nouveau, car il existe déjà dans le module dict.

Si vous essayez d'accéder à b.x de a lors de l'initialisation du module, vous obtiendrez un AttributeError.

Ajouter la ligne suivante à a.py:

print b.x

Ensuite, la sortie est:

$ python a.py
a in                    
b imported: False
b in
a in
b imported: True
a out
Traceback (most recent call last):
  File "a.py", line 4, in <module>
    import b
  File "/home/shlomme/tmp/x/b.py", line 2, in <module>
    import a
 File "/home/shlomme/tmp/x/a.py", line 7, in <module>
    print b.x
AttributeError: 'module' object has no attribute 'x'

C'est parce que les modules sont exécutés sur l'importation et à l'époque b.x est accessible, la ligne x = 3 a pas exécuté, ce qui ne sera possible après b out.

J'ai un exemple ici qui m'a frappé!

foo.py

import bar

class gX(object):
    g = 10

bar.py

from foo import gX

o = gX()

main.py

import foo
import bar

print "all done"

À la ligne de commande: $ python main.py

Traceback (most recent call last):
  File "m.py", line 1, in <module>
    import foo
  File "/home/xolve/foo.py", line 1, in <module>
    import bar
  File "/home/xolve/bar.py", line 1, in <module>
    from foo import gX
ImportError: cannot import name gX

Module un.py :

import b
print("This is from module a")

Module b.py

import a
print("This is from module b")

L'exécution du Module "a" sera de sortie:

>>> 
'This is from module a'
'This is from module b'
'This is from module a'
>>> 

La sortie de ce 3 lignes alors qu'il était censé sortie infinitival en raison de la circulaire de l'importation.
Ce qui se passe, ligne par ligne lors de l'exécution de"Module" est répertorié ici:

1. La première ligne est import b. donc, il va visiter le module b
2. La première ligne au module b est import a. donc, il va visiter un module
3. La première ligne à un module est import b mais noter que cette ligne ne sera pas exécutée de nouveau plus, car tous les fichiers python exécuter une ligne d'importation pour une fois, il n'importe pas où ou quand il est exécuté. donc, il va passer à la ligne suivante et imprimer "This is from module a".
4. Après avoir fini la visite de tout le module d'un module de b, nous en sommes encore au module b. donc, la prochaine ligne d'impression "This is from module b"
5. Module b lignes sont exécutées complètement. nous allons donc revenir à un module où nous avons commencé le module b.
6. importer ligne b ont été exécutées déjà et ne pourra pas être exécutée de nouveau. la ligne suivante sera d'impression "This is from module a" et le programme sera terminé.

J'ai résolu le problème de la manière suivante, et il fonctionne bien sans aucune erreur.
Considérons deux fichiers a.py et b.py.

J'ai ajouté ceci à a.py et cela a fonctionné.

if __name__ == "__main__":
        main ()

un.py:

import b
y = 2
def main():
    print ("a out")
    print (b.x)

if __name__ == "__main__":
    main ()

b.py:

import a
print ("b out")
x = 3 + a.y

La sortie que je vous est

>>> b out 
>>> a out 
>>> 5

Ok, je pense que j'ai une super solution.
Disons que vous avez un fichier a et fichier b.
Vous avez un def ou un class dans le fichier b que vous souhaitez utiliser dans le module a, mais vous avez quelque chose d'autre, soit un def, class ou d'une variable à partir d'un fichier a que vous avez besoin dans votre définition ou de la classe dans le fichier b.
Ce que vous pouvez faire est, au fond de fichier a, après l'appel de la fonction ou de la classe dans le fichier a qui est nécessaire dans le fichier b, mais avant l'appel de la fonction ou de la classe à partir d'un fichier b que vous avez besoin pour fichier a, dire import b
Alors, et voici la partie de la clé, dans toutes les définitions ou les classes dans le fichier b qui ont besoin de def ou class à partir d'un fichier a (appelons CLASS), vous dites from a import CLASS

Cela fonctionne parce que vous pouvez importer un fichier b sans Python de l'exécution de l'une quelconque des déclarations d'importation en fichier b, et donc vous échapper d'une circulaire importations.

Par exemple:

Un fichier:

class A(object):

     def __init__(self, name):

         self.name = name

CLASS = A("me")

import b

go = B(6)

go.dostuff

Fichier b:

class B(object):

     def __init__(self, number):

         self.number = number

     def dostuff(self):

         from a import CLASS

         print "Hello " + CLASS.name + ", " + str(number) + " is an interesting number."

Le tour est joué.