¿Importación circular de Python?

Entonces recibo este error

Traceback (most recent call last):
  File "/Users/alex/dev/runswift/utils/sim2014/simulator.py", line 3, in <module>
    from world import World
  File "/Users/alex/dev/runswift/utils/sim2014/world.py", line 2, in <module>
    from entities.field import Field
  File "/Users/alex/dev/runswift/utils/sim2014/entities/field.py", line 2, in <module>
    from entities.goal import Goal
  File "/Users/alex/dev/runswift/utils/sim2014/entities/goal.py", line 2, in <module>
    from entities.post import Post
  File "/Users/alex/dev/runswift/utils/sim2014/entities/post.py", line 4, in <module>
    from physics import PostBody
  File "/Users/alex/dev/runswift/utils/sim2014/physics.py", line 21, in <module>
    from entities.post import Post
ImportError: cannot import name Post

y puede ver que utilizo la misma declaración de importación más arriba y funciona? ¿Existe alguna regla no escrita sobre la importación circular? ¿Cómo uso la misma clase más abajo en la pila de llamadas?

Creo que la respuesta de jpmc26, aunque de ninguna manera es incorrecta , se reduce demasiado a las importaciones circulares. Pueden funcionar bien, si los configura correctamente.

La forma más sencilla de hacerlo es utilizar import my_modulesintaxis, en lugar de from my_module import some_object. El primero casi siempre funcionará, incluso si my_moduleincluido nos importa de nuevo. Este último solo funciona si my_objectya está definido en my_module, lo que en una importación circular puede no ser el caso.

Para ser específico para su caso: intente cambiar entities/post.pyde hacer import physicsy luego consulte en physics.PostBodylugar de hacerlo PostBodydirectamente. De manera similar, cambie physics.pypara hacer import entities.posty luego use en entities.post.Postlugar de solo Post.

Cuando importa un módulo (o un miembro de él) por primera vez, el código dentro del módulo se ejecuta secuencialmente como cualquier otro código; por ejemplo, no se trata de forma diferente al cuerpo de una función. Una importes simplemente un comando como cualquier otra (asignación, una llamada de función, def, class). Suponiendo que sus importaciones se produzcan en la parte superior del script, esto es lo que está sucediendo:

• Cuando intenta importar Worlddesde world, worldse ejecuta el script.
• El worldscript se importa Field, lo que hace entities.fieldque se ejecute.
• Este proceso continúa hasta que llega al entities.postscript porque intentó importarPost
• El entities.postscript hace physicsque se ejecute el módulo porque intenta importarPostBody
• Finalmente, physicsintenta importar Postdesdeentities.post
• No estoy seguro de si el entities.postmódulo existe todavía en la memoria, pero realmente no importa. O el módulo no está en la memoria o el módulo aún no tiene un Postmiembro porque no ha terminado de ejecutarse para definirPost
• De cualquier manera, se produce un error porque Postno está allí para ser importado.

Entonces no, no está "trabajando más arriba en la pila de llamadas". Este es un seguimiento de la pila de dónde ocurrió el error, lo que significa que se produjo un error al intentar importar Posten esa clase. No debería utilizar importaciones circulares. En el mejor de los casos, tiene un beneficio insignificante (normalmente, ningún beneficio) y causa problemas como este. Carga a cualquier revelador manteniéndola, obligándolos a caminar sobre cáscaras de huevo para no romperla. Refactorice la organización de su módulo.

Para comprender las dependencias circulares, debe recordar que Python es esencialmente un lenguaje de secuencias de comandos. La ejecución de declaraciones fuera de los métodos se produce en tiempo de compilación. Las instrucciones de importación se ejecutan como llamadas a métodos, y para comprenderlas, debe pensar en ellas como llamadas a métodos.

Cuando realiza una importación, lo que sucede depende de si el archivo que está importando ya existe en la tabla del módulo. Si es así, Python usa lo que esté actualmente en la tabla de símbolos. Si no es así, Python comienza a leer el archivo del módulo, compilando / ejecutando / importando lo que encuentre allí. Los símbolos a los que se hace referencia en el momento de la compilación se encuentran o no, dependiendo de si se han visto o el compilador aún no los ha visto.

Imagina que tienes dos archivos fuente:

Archivo X.py

def X1:
    return "x1"

from Y import Y2

def X2:
    return "x2"

Archivo Y.py

def Y1:
    return "y1"

from X import X1

def Y2:
    return "y2"

Ahora suponga que compila el archivo X.py. El compilador comienza definiendo el método X1 y luego ingresa a la declaración de importación en X.py. Esto hace que el compilador pause la compilación de X.py y comience a compilar Y.py. Poco después, el compilador accede a la declaración de importación en Y.py. Dado que X.py ya está en la tabla de módulos, Python usa la tabla de símbolos X.py incompleta existente para satisfacer las referencias solicitadas. Todos los símbolos que aparecen antes de la declaración de importación en X.py están ahora en la tabla de símbolos, pero los símbolos posteriores no. Dado que X1 ahora aparece antes de la declaración de importación, se importa correctamente. Python luego reanuda la compilación de Y.py. Al hacerlo, define Y2 y termina de compilar Y.py. Luego reanuda la compilación de X.py y encuentra Y2 en la tabla de símbolos Y.py. La compilación finalmente se completa sin errores.

Algo muy diferente sucede si intenta compilar Y.py desde la línea de comandos. Mientras compila Y.py, el compilador llega a la declaración de importación antes de definir Y2. Luego comienza a compilar X.py. Pronto llega a la declaración de importación en X.py que requiere Y2. Pero Y2 no está definido, por lo que la compilación falla.

Tenga en cuenta que si modifica X.py para importar Y1, la compilación siempre se realizará correctamente, independientemente del archivo que compile. Sin embargo, si modifica el archivo Y.py para importar el símbolo X2, ninguno de los archivos se compilará.

En cualquier momento en que el módulo X, o cualquier módulo importado por X pueda importar el módulo actual, NO utilice:

from X import Y

Siempre que crea que puede haber una importación circular, también debe evitar compilar referencias de tiempo a variables en otros módulos. Considere el código de apariencia inocente:

import X
z = X.Y

Suponga que el módulo X importa este módulo antes de que este módulo importe X. Además, suponga que Y se define en X después de la declaración de importación. Entonces, Y no se definirá cuando se importe este módulo y obtendrá un error de compilación. Si este módulo importa Y primero, puede salirse con la suya. Pero cuando uno de sus compañeros de trabajo cambia inocentemente el orden de las definiciones en un tercer módulo, el código se romperá.

En algunos casos, puede resolver dependencias circulares moviendo una declaración de importación hacia abajo debajo de las definiciones de símbolos que necesitan otros módulos. En los ejemplos anteriores, las definiciones antes de la declaración de importación nunca fallan. Las definiciones posteriores a la declaración de importación a veces fallan, según el orden de compilación. Incluso puede colocar declaraciones de importación al final de un archivo, siempre que no se necesite ninguno de los símbolos importados en el momento de la compilación.

Tenga en cuenta que mover las declaraciones de importación hacia abajo en un módulo oscurece lo que está haciendo. Compensa esto con un comentario en la parte superior de tu módulo, algo como lo siguiente:

#import X   (actual import moved down to avoid circular dependency)

En general, esta es una mala práctica, pero a veces es difícil de evitar.

Para aquellos de ustedes que, como yo, ven este problema desde Django, deben saber que los documentos brindan una solución: https://docs.djangoproject.com/en/1.10/ref/models/fields/#foreignkey

"... Para hacer referencia a los modelos definidos en otra aplicación, puede especificar explícitamente un modelo con la etiqueta de la aplicación completa. Por ejemplo, si el modelo de fabricante anterior se define en otra aplicación llamada producción, deberá utilizar:

class Car(models.Model):
    manufacturer = models.ForeignKey(
        'production.Manufacturer',
        on_delete=models.CASCADE,
)

Este tipo de referencia puede resultar útil para resolver dependencias de importación circulares entre dos aplicaciones. ... "

Pude importar el módulo dentro de la función (solo) que requeriría los objetos de este módulo:

def my_func():
    import Foo
    foo_instance = Foo()

Si se encuentra con este problema en una aplicación bastante compleja, puede resultar engorroso refactorizar todas sus importaciones. PyCharm ofrece una solución rápida para esto que también cambiará automáticamente todo el uso de los símbolos importados.

Estaba usando lo siguiente:

from module import Foo

foo_instance = Foo()

pero para deshacerme de circular referencehice lo siguiente y funcionó:

import module.foo

foo_instance = foo.Foo()