Zirkuläre Abhängigkeit in Python

Ich habe zwei Dateien, node.pyund path.py, die zwei Klassen zu definieren, Nodeund Pathsind.

Bis heute hat die Definition für Pathdas NodeObjekt referenziert , und deshalb hatte ich getan

from node.py import *

in der path.pyDatei.

Ab heute habe ich jedoch eine neue Methode erstellt Node, die auf das PathObjekt verweist .

Ich hatte Probleme beim Importieren path.py: Ich habe es versucht, und als das Programm ausgeführt und die verwendete PathMethode aufgerufen wurde , Nodetrat eine Ausnahme auf Node, weil es nicht definiert wurde.

Was mache ich?

Das Importieren von Python-Modulen ist ein großartiger Artikel, in dem zirkuläre Importe in Python erläutert werden.

Der einfachste Weg, dies zu beheben, besteht darin, den Pfadimport an das Ende des Knotenmoduls zu verschieben.

Ein anderer Ansatz besteht darin, eines der beiden Module nur in der Funktion zu importieren, in der Sie es in dem anderen benötigen. Sicher, dies funktioniert am besten, wenn Sie es nur in einer oder wenigen Funktionen benötigen:

# in node.py 
from path import Path
class Node 
    ...

# in path.py
class Path
  def method_needs_node(): 
    from node import Node
    n = Node()
    ...

Ich ziehe es vor, eine zirkuläre Abhängigkeit zu brechen, indem ich eine der Abhängigkeiten im Konstruktor der anderen abhängigen Klasse deklariere. Meiner Ansicht nach hält dies den Code übersichtlicher und ermöglicht einen einfachen Zugriff auf alle Methoden, die die Abhängigkeit erfordern.

In meinem Fall habe ich also einen CustomerService und einen UserService, die voneinander abhängig sind. Ich unterbreche die zirkuläre Abhängigkeit wie folgt:

class UserService:

    def __init__(self):
        # Declared in constructor to avoid circular dependency
        from server.portal.services.admin.customer_service import CustomerService
        self.customer_service = CustomerService()

    def create_user(self, customer_id: int) -> User:
        # Now easy to access the dependency from any method
        customer = self.customer_service.get_by_id(customer_id)

Sie können nicht importieren müssen Pathin node.pyfür in Ordnung Pathund Nodezu nutzen voneinander.

# in __init__.py  (The order of imports should not matter.)
from .node import Node
from .path import Path

# in path.py 
from . import Node
class Path
  ...

  def return_something_pathy(self): 
    ...

# in node.py
class Node
  def __init__(self, path): 
    self.path = path
    ...

  def a_node_method():
    print(self.path.return_something_pathy())

Fügen Sie Typhinweise hinzu, um zu verdeutlichen, Nodedass davon Gebrauch gemacht Pathwird. Ab Python 3.7 ist eine Funktion verfügbar, die Vorwärtsreferenzen in Typanmerkungen unterstützt, wie in PEP 563 beschrieben .

# in node.py  (Now with type hinting.)
from __future__ import annotations

class Node
  def __init__(self, path: Path): 
    self.path = path
    ...

  def a_node_method():
    print(self.path.return_something_pathy())

Ich bin auf eine weitere Lösung gestoßen, um Sie aus einem kreisförmigen Importloch in Python herauszuholen, ist ein großartiger Blog-Beitrag, der mir dies beigebracht hat.