Importação circular do Python?

Então, estou recebendo este erro

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

e você pode ver que eu uso a mesma instrução de importação mais acima e funciona? Existe alguma regra não escrita sobre a importação circular? Como faço para usar a mesma classe mais abaixo na pilha de chamadas?

Acho que a resposta do jpmc26, embora de forma alguma errada , depende muito das importações circulares. Eles podem funcionar muito bem, se você configurá-los corretamente.

A maneira mais fácil de fazer isso é usar import my_modulesintaxe, em vez de from my_module import some_object. O primeiro quase sempre funcionará, mesmo se my_moduleincluído nos importa de volta. Este último só funciona se my_objectjá estiver definido em my_module, o que em uma importação circular pode não ser o caso.

Para ser específico para o seu caso: tente mudar entities/post.pypara fazer import physicse, em seguida, consulte em physics.PostBodyvez de apenas PostBodydiretamente. Da mesma forma, mude physics.pypara fazer import entities.poste use em entities.post.Postvez de apenas Post.

Quando você importa um módulo (ou um membro dele) pela primeira vez, o código dentro do módulo é executado sequencialmente como qualquer outro código; por exemplo, não é tratado de forma diferente que o corpo de uma função. Um importé apenas um comando como qualquer outro (atribuição, uma chamada de função, def, class). Supondo que suas importações ocorram no início do script, eis o que está acontecendo:

• Quando você tenta importar Worldde world, o worldscript é executado.
• O worldscript é importado Field, o que faz com que o entities.fieldscript seja executado.
• Este processo continua até chegar ao entities.postscript porque tentou importarPost
• O entities.postscript faz com que o physicsmódulo seja executado porque ele tenta importarPostBody
• Finalmente, physicstenta importar Postdeentities.post
• Não tenho certeza se o entities.postmódulo existe na memória ainda, mas realmente não importa. Ou o módulo não está na memória, ou o módulo ainda não tem um Postmembro porque não terminou de executar para definirPost
• De qualquer forma, ocorre um erro porque Postnão existe para ser importado

Portanto, não, não está "avançando na pilha de chamadas". Este é um rastreamento de pilha de onde ocorreu o erro, o que significa que houve um erro ao tentar importar Postnessa classe. Você não deve usar importações circulares. Na melhor das hipóteses, ele tem um benefício insignificante (normalmente, nenhum benefício) e causa problemas como esse. Ele onera qualquer desenvolvedor que o mantenha, forçando-o a pisar na casca do ovo para evitar quebrá-lo. Refatore sua organização de módulo.

Para entender as dependências circulares, você precisa se lembrar de que Python é essencialmente uma linguagem de script. A execução de instruções fora dos métodos ocorre em tempo de compilação. As instruções de importação são executadas como chamadas de método e, para compreendê-las, você deve pensar nelas como chamadas de método.

Quando você faz uma importação, o que acontece depende se o arquivo que você está importando já existe na tabela do módulo. Em caso afirmativo, Python usa tudo o que está atualmente na tabela de símbolos. Caso contrário, o Python começa a ler o arquivo do módulo, compilando / executando / importando tudo o que encontrar lá. Os símbolos referenciados em tempo de compilação são encontrados ou não, dependendo se eles foram vistos ou ainda não foram vistos pelo compilador.

Imagine que você tenha dois arquivos de origem:

Arquivo X.py

def X1:
    return "x1"

from Y import Y2

def X2:
    return "x2"

Arquivo Y.py

def Y1:
    return "y1"

from X import X1

def Y2:
    return "y2"

Agora, suponha que você compile o arquivo X.py. O compilador começa definindo o método X1 e, em seguida, acessa a instrução import em X.py. Isso faz com que o compilador pause a compilação de X.py e comece a compilar Y.py. Pouco depois, o compilador acessa a instrução import em Y.py. Como o X.py já está na tabela do módulo, o Python usa a tabela de símbolos X.py incompleta existente para satisfazer todas as referências solicitadas. Todos os símbolos que aparecem antes da instrução de importação em X.py agora estão na tabela de símbolos, mas os símbolos posteriores não estão. Como X1 agora aparece antes da instrução de importação, ele foi importado com sucesso. O Python então retoma a compilação de Y.py. Ao fazer isso, ele define Y2 e termina de compilar Y.py. Em seguida, ele retoma a compilação de X.py e encontra Y2 na tabela de símbolos Y.py. A compilação eventualmente termina sem erro.

Algo muito diferente acontece se você tentar compilar Y.py a partir da linha de comando. Ao compilar Y.py, o compilador acessa a instrução import antes de definir Y2. Em seguida, ele começa a compilar o X.py. Logo ele atinge a instrução import em X.py que requer Y2. Mas Y2 é indefinido, então a compilação falha.

Observe que se você modificar o X.py para importar Y1, a compilação sempre será bem-sucedida, independentemente do arquivo que você compilar. No entanto, se você modificar o arquivo Y.py para importar o símbolo X2, nenhum arquivo será compilado.

Sempre que o módulo X ou qualquer módulo importado pelo X puder importar o módulo atual, NÃO use:

from X import Y

Sempre que você achar que pode haver uma importação circular, você também deve evitar referências em tempo de compilação a variáveis ​​em outros módulos. Considere o código de aparência inocente:

import X
z = X.Y

Suponha que o módulo X importe este módulo antes que este módulo importe X. Além disso, suponha que Y seja definido em X após a instrução de importação. Então, Y não será definido quando este módulo for importado e você obterá um erro de compilação. Se este módulo importar Y primeiro, você pode se safar. Mas quando um de seus colegas de trabalho muda inocentemente a ordem das definições em um terceiro módulo, o código falha.

Em alguns casos, você pode resolver dependências circulares movendo uma instrução de importação para baixo, abaixo das definições de símbolo necessárias para outros módulos. Nos exemplos acima, as definições antes da instrução import nunca falham. As definições após a instrução de importação às vezes falham, dependendo da ordem de compilação. Você pode até colocar instruções de importação no final de um arquivo, desde que nenhum dos símbolos importados seja necessário no momento da compilação.

Observe que mover as instruções de importação para baixo em um módulo obscurece o que você está fazendo. Compense isso com um comentário no topo do seu módulo, algo como o seguinte:

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

Em geral, essa é uma prática ruim, mas às vezes é difícil de evitar.

Para aqueles de vocês que, como eu, chegaram a este problema do Django, devem saber que os documentos fornecem uma solução: https://docs.djangoproject.com/en/1.10/ref/models/fields/#foreignkey

"... Para referir-se a modelos definidos em outro aplicativo, você pode especificar explicitamente um modelo com o rótulo completo do aplicativo. Por exemplo, se o modelo do fabricante acima for definido em outro aplicativo chamado produção, você precisará usar:

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

Esse tipo de referência pode ser útil ao resolver dependências de importação circular entre dois aplicativos. ... "

Consegui importar o módulo dentro da função (apenas) que exigiria os objetos deste módulo:

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

Se você encontrar esse problema em um aplicativo bastante complexo, pode ser complicado refatorar todas as suas importações. O PyCharm oferece uma correção rápida para isso, que também altera automaticamente todo o uso dos símbolos importados.

Eu estava usando o seguinte:

from module import Foo

foo_instance = Foo()

mas para me livrar circular referencefiz o seguinte e funcionou:

import module.foo

foo_instance = foo.Foo()