Briser les importations circulaires de Python

Question

Comment casser cette importation circulaire particulière. J'ai ajouté un exemple trivial ajouté en haut pour mettre en évidence le problème.

module_tit.py

import tat 
class Tit 
    def tit(x): 
     return tat.inst.tat(x) 

inst = Tit() 

if __name__=='__main__: 
    print "tit 12 %s" % inst.tit(12) 

module_tat.py

import tit 
class Tat: 
    def tat(x): 
     if x>0: return tit.inst.tit(x-1) 
     else: return 'bottom' 

inst = Tat() 

if __name__=='__main__: 
    print "tat 5 %s" % inst.tat(5) 

• La conception de mon code exige fermement que tit et tat soient dans leurs propres modules.
• Il est important que le tit ou tat puisse être le premier module chargé.
• Est-ce possible en python de quelque façon que ce soit ???

question === === originale ci-dessous

J'ai un base_module avec plusieurs dizaines de constantes, etc., il est importé par beaucoup, et il importe rien. J'y ai une classe clé dans le module de base, et il dépend d'un joli module d'imprimante pour faire l'impression de chose:

to_str = None 
class Thing_Version1(object): 
    def __repr__(): 
     to_str(self) 

Dans le joli module imprimante je:

def to_str(x): 
    ... 
import base_module 
base_module.to_str = to_str 

Lorsque le joli module d'imprimante qu'il définit "base_module.to_str" pour que tout fonctionne correctement. cela fonctionne 99% du temps, mais dans le débogueur, il n'est pas assez intelligent pour charger la jolie imprimante (même si dans l'interpréteur normal, mon processus de chargement force la charge éventuelle du module pprint. importer dynamiquement:

class Thing_Version1(object): 
    def __repr__(): 
     import pprint 
     pprint.to_str(self) 

Mais cela échoue aussi parfois ne peut pas trouver la fonction « to_str » dans le module pprint (je suppose en raison de référence circulaire)

Mon but ultime est de forcer le chargement de pprint. à chaque fois que load_module est chargé, et que permet à pprint de dépendre des dizaines de constantes dans le module_base

Est-ce impossible?

Answer 1

Malheureusement, je ne peux pas reproduire votre problème. Python a une résolution dynamique des références si circulaires sont rarement un problème:

fred.py

import wilma 
count = 4 
def main(): 
    wilma.pr('Hello') 

wilma.py

import fred 
def pr(str): 
    print(str*fred.count) 

Python REPL

>>> import fred 
>>> fred.main() 
HelloHelloHelloHello 

Essayez-vous trop pour éviter un problème qui se produit rarement en Python? Pouvez-vous fournir un exemple minimal du problème que vous rencontrez?