J'ai quatre fichiers différents nommés: principal, vecteur, entité et physique. Je ne publierai pas tout le code, juste les importations, car je pense que c'est là que se trouve l'erreur. (Si vous voulez, je peux poster plus)

Principale:

import time
from entity import Ent
from vector import Vect
#the rest just creates an entity and prints the result of movement

Entité:

from vector import Vect
from physics import Physics
class Ent:
    #holds vector information and id
def tick(self, dt):
    #this is where physics changes the velocity and position vectors

Vecteur:

from math import *
class Vect:
    #holds i, j, k, and does vector math

La physique:

from entity import Ent
class Physics:
    #physics class gets an entity and does physics calculations on it.

Je lance ensuite depuis main.py et j'obtiens l'erreur suivante:

Traceback (most recent call last):
File "main.py", line 2, in <module>
    from entity import Ent
File ".../entity.py", line 5, in <module>
    from physics import Physics
File ".../physics.py", line 2, in <module>
    from entity import Ent
ImportError: cannot import name Ent

Je suis très nouveau sur Python, mais je travaille avec C ++ depuis longtemps. Je suppose que l'erreur est due à l'importation de l'entité deux fois, une fois en principal et plus tard en physique, mais je ne connais pas de solution. Quelqu'un peut-il aider?

Vous avez des importations dépendantes circulaires. physics.pyest importé entityavant que la classe ne Entsoit définie et physicsessaie d'importer entityqui est déjà en cours d'initialisation. Supprimez la dépendance physicsdu entitymodule.

Alors que vous devez absolument éviter les dépendances circulaires, vous pouvez différer les importations en python.

par exemple:

import SomeModule

def someFunction(arg):
    from some.dependency import DependentClass

cela (au moins dans certains cas) contournera l'erreur.

Il s'agit d'une dépendance circulaire. Il peut être résolu sans aucune modification structurelle du code. Le problème se produit parce que vectorvous exigez qu'il entitysoit rendu disponible immédiatement, et vice versa. La raison de ce problème est que vous demandez d'accéder au contenu du module avant qu'il ne soit prêt - en utilisant from x import y. C'est essentiellement le même que

import x
y = x.y
del x

Python est capable de détecter les dépendances circulaires et d'empêcher la boucle infinie des importations. Essentiellement, tout ce qui se passe est qu'un espace réservé vide est créé pour le module (c'est-à-dire qu'il n'a pas de contenu). Une fois les modules circulairement dépendants compilés, il met à jour le module importé. Cela fonctionne quelque chose comme ça.

a = module() # import a

# rest of module

a.update_contents(real_a)

Pour que python puisse fonctionner avec des dépendances circulaires, vous devez utiliser import xuniquement le style.

import x
class cls:
    def __init__(self):
        self.y = x.y

Puisque vous ne faites plus référence au contenu du module au niveau supérieur, python peut compiler le module sans avoir à accéder au contenu de la dépendance circulaire. Par niveau supérieur, j'entends les lignes qui seront exécutées pendant la compilation, par opposition au contenu des fonctions (par exemple. y = x.y). Les variables statiques ou de classe accédant au contenu du module causeront également des problèmes.

Il est très important de clarifier la logique. Ce problème apparaît, car la référence devient une boucle morte.

Si vous ne voulez pas changer la logique, vous pouvez placer l'instruction some import qui a causé ImportError à l'autre position du fichier, par exemple la fin.

a.py

from test.b import b2

def a1():
    print('a1')
    b2()

b.py

from test.a import a1

def b1():
    print('b1')
    a1()

def b2():
    print('b2')

if __name__ == '__main__':
    b1()

Vous obtiendrez une erreur d'importation: ImportError: cannot import name 'a1'

Mais si nous changeons la position de from test.b import b2 in A comme ci-dessous:

a.py

def a1():
    print('a1')
    b2()

from test.b import b2

Et nous pouvons obtenir ce que nous voulons:

b1
a1
b2

Il s'agit d'une dépendance circulaire. nous pouvons résoudre ce problème en utilisant le module ou la classe d' importation ou la fonction là où nous en avions besoin. si nous utilisons cette approche, nous pouvons corriger la dépendance circulaire

A.py

from B import b2
def a1():
    print('a1')
    b2()

B.py

def b1():
   from A import a1
   print('b1')
   a1()

def b2():
   print('b2')
if __name__ == '__main__':
   b1() 

Je viens de recevoir cette erreur aussi, pour une raison différente ...

from my_sub_module import my_function

Le script principal avait des fins de ligne Windows. my_sub_moduleavait des fins de ligne UNIX. Les changer pour être les mêmes a résolu le problème. Ils doivent également avoir le même codage de caractères.

Comme déjà mentionné, cela est dû à une dépendance circulaire . Ce qui n'a pas été mentionné, c'est que lorsque vous utilisez un module de typage Python et que vous importez une classe uniquement pour être utilisée pour annoter des types , vous pouvez utiliser des références Forward :

Lorsqu'un indice de type contient des noms qui n'ont pas encore été définis, cette définition peut être exprimée sous la forme d'un littéral de chaîne, à résoudre ultérieurement.

et supprimer la dépendance (l' importation ), par exemple au lieu de

from my_module import Tree

def func(arg: Tree):
    # code

faire:

def func(arg: 'Tree'):
    # code

(notez la importdéclaration supprimée )

Ne nommez pas votre script python actuel avec le nom d'un autre module que vous importez

Lösung: renommez votre manuscrit de python fonctionnant

Exemple:

1. vous travaillez dans medicaltorch.py
2. dans ce script, vous avez: from medicaltorch import datasets as mt_datasetsoù medicaltorchest censé être un module installé

Cela échouera avec le ImportError. Renommez simplement votre script python de travail en 1.

Ne voyez pas encore celui-ci ici - c'est incroyablement stupide, mais assurez-vous d'importer la bonne variable / fonction.

Je recevais cette erreur

ImportError: impossible d'importer le nom IMPLICIT_WAIT

parce que ma variable était en fait IMPLICIT_TIMEOUT.

lorsque j'ai changé mon importation pour utiliser le nom correct, je n'ai plus d'erreur 🤦‍♂️

Si vous importez à file1.pypartir file2.pyet utilisé ceci:

if __name__ == '__main__':
    # etc

Les variables ci - dessous que file1.py ne peuvent pas être importés à file2.pycause __name__ ne est pas égal __main__ !

Si vous souhaitez importer quelque chose de file1.pyà file2.py, vous devez l'utiliser dans file1.py:

if __name__ == 'file1':
    # etc

En cas de doute, faites une assertdéclaration pour déterminer si__name__=='__main__'

Une façon de suivre l'erreur d'importation consiste à essayer pas à pas d'exécuter python sur chacun des fichiers importés pour en rechercher le mauvais.

1. vous obtenez quelque chose comme:

   python ./main.py

   ImportError: impossible d'importer le nom A

2. puis vous lancez:

   python ./modules/a.py

   ImportError: impossible d'importer le nom B

3. puis vous lancez:

   python ./modules/b.py

   ImportError: impossible d'importer le nom C (certains modules NON existants ou une autre erreur)

Également pas directement pertinent pour l'OP, mais le fait de ne pas redémarrer une console PyCharm Python, après avoir ajouté un nouvel objet à un module, est également un excellent moyen d'obtenir un très déroutantImportError: Cannot import name ...

La partie déroutante est que PyCharm terminera automatiquement l'importation dans la console, mais l'importation échoue ensuite.

Le problème est clair: dépendance circulaire entre les noms entityet les physicsmodules.

Indépendamment de l'importation de l'ensemble du module ou d'une classe, les noms doivent être chargés.

Regardez cet exemple:

# a.py
import b
def foo():
  pass
b.bar()

# b.py
import a
def bar():
  pass
a.foo()

Cela sera compilé en:

# a.py
# import b
# b.py
# import a # ignored, already importing
def bar():
  pass
a.foo()
# name a.foo is not defined!!!
# import b done!
def foo():
  pass
b.bar()
# done!

Avec un léger changement, nous pouvons résoudre ce problème:

# a.py
def foo():
  pass
import b
b.bar()

# b.py
def bar():
  pass
import a
a.foo()

Cela sera compilé en:

# a.py
def foo():
  pass
# import b
# b.py
def bar():
  pass
# import a # ignored, already importing
a.foo()
# import b done!
b.bar()
# done!

Dans mon cas, je travaillais dans un cahier Jupyter et cela se produisait en raison de l'importation déjà mise en cache depuis que j'avais défini la classe / fonction dans mon fichier de travail.

J'ai redémarré mon noyau Jupyter et l'erreur a disparu.

Pas spécifiquement pour ce demandeur, mais cette même erreur s'affichera si le nom de classe dans votre importation ne correspond pas à la définition dans le fichier à partir duquel vous importez.