Python-Typ ohne zyklische Importe

Ich versuche meine große Klasse in zwei Teile zu teilen. Nun, im Grunde in die "Haupt" -Klasse und ein Mixin mit zusätzlichen Funktionen, wie so:

main.py Datei:

import mymixin.py

class Main(object, MyMixin):
    def func1(self, xxx):
        ...

mymixin.py Datei:

class MyMixin(object):
    def func2(self: Main, xxx):  # <--- note the type hint
        ...

Nun, obwohl dies gut funktioniert, kann der Typhinweis MyMixin.func2natürlich nicht funktionieren. Ich kann nicht importieren main.py, da ich einen zyklischen Import erhalten würde und mein Editor (PyCharm) ohne den Hinweis nicht sagen kann, was selfist.

Ich verwende Python 3.4 und bin bereit, auf 3.5 umzusteigen, wenn dort eine Lösung verfügbar ist.

Gibt es eine Möglichkeit, meine Klasse in zwei Dateien aufzuteilen und alle "Verbindungen" beizubehalten, sodass meine IDE mir weiterhin die automatische Vervollständigung und alle anderen Extras bietet, die daraus entstehen, wenn ich die Typen kenne?

Ich fürchte, es gibt keine äußerst elegante Möglichkeit, Importzyklen im Allgemeinen zu handhaben. Sie können entweder Ihren Code neu gestalten, um die zyklische Abhängigkeit zu entfernen, oder, wenn dies nicht möglich ist, Folgendes tun:

# some_file.py

from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from main import Main

class MyObject(object):
    def func2(self, some_param: 'Main'):
        ...

Die TYPE_CHECKINGKonstante ist immer Falsezur Laufzeit, daher wird der Import nicht ausgewertet, aber mypy (und andere Tools zur Typprüfung) werten den Inhalt dieses Blocks aus.

Wir müssen auch das machen Main Typanmerkung auch in eine Zeichenfolge umwandeln und sie effektiv weiterleiten, da das MainSymbol zur Laufzeit nicht verfügbar ist.

Wenn Sie Python 3.7+ verwenden, können wir zumindest die Bereitstellung einer expliziten Zeichenfolgenanmerkung überspringen, indem wir PEP 563 nutzen :

# some_file.py

from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from main import Main

class MyObject(object):
    # Hooray, cleaner annotations!
    def func2(self, some_param: Main):
        ...

Das from __future__ import annotations Import werden alle Typhinweise zu Zeichenfolgen und überspringen die Auswertung. Dies kann dazu beitragen, unseren Code hier etwas ergonomischer zu gestalten.

Alles in allem erfordert die Verwendung von Mixins mit mypy wahrscheinlich etwas mehr Struktur als derzeit. Mypy empfiehlt einen Ansatz , der im Grunde genommen decezebeschreibt - ein ABC zu erstellen, das sowohl Sie Mainals auch Ihre MyMixinKlassen erben. Es würde mich nicht wundern, wenn Sie etwas Ähnliches tun müssten, um Pycharms Kontrolleur glücklich zu machen.

Für Personen, die mit zyklischen Importen zu kämpfen haben, wenn sie eine Klasse nur zur Typprüfung importieren: Sie möchten wahrscheinlich eine Weiterleitungsreferenz verwenden (PEP 484 - Typhinweise):

Wenn ein Typhinweis Namen enthält, die noch nicht definiert wurden, kann diese Definition als Zeichenfolgenliteral ausgedrückt werden, um später aufgelöst zu werden.

Also statt:

class Tree:
    def __init__(self, left: Tree, right: Tree):
        self.left = left
        self.right = right

Sie machen:

class Tree:
    def __init__(self, left: 'Tree', right: 'Tree'):
        self.left = left
        self.right = right

Das größere Problem ist, dass Ihre Typen zunächst nicht gesund sind. MyMixinmacht eine fest codierte Annahme, dass es eingemischt wirdMain in eine beliebige Anzahl anderer Klassen eingemischt wird, in welchem ​​Fall es wahrscheinlich brechen würde. Wenn Ihr Mixin fest codiert ist, um in eine bestimmte Klasse gemischt zu werden, können Sie die Methoden auch direkt in diese Klasse schreiben, anstatt sie zu trennen.

Um dies mit vernünftiger Typisierung richtig zu tun, MyMixinsollte es gegen eine Schnittstelle oder eine abstrakte Klasse im Python-Sprachgebrauch codiert werden :

import abc


class MixinDependencyInterface(abc.ABC):
    @abc.abstractmethod
    def foo(self):
        pass


class MyMixin:
    def func2(self: MixinDependencyInterface, xxx):
        self.foo()  # ← mixin only depends on the interface


class Main(MixinDependencyInterface, MyMixin):
    def foo(self):
        print('bar')

Es stellte sich heraus, dass mein ursprünglicher Versuch auch der Lösung ziemlich nahe kam. Folgendes verwende ich derzeit:

# main.py
import mymixin.py

class Main(object, MyMixin):
    def func1(self, xxx):
        ...


# mymixin.py
if False:
    from main import Main

class MyMixin(object):
    def func2(self: 'Main', xxx):  # <--- note the type hint
        ...

Beachten Sie den Import innerhalb der if FalseAnweisung, der nie importiert wird (aber IDE weiß es trotzdem), und verwenden Sie die MainKlasse als Zeichenfolge, da sie zur Laufzeit nicht bekannt ist.

Ich denke, der perfekte Weg sollte sein, alle Klassen und Abhängigkeiten in eine Datei (wie __init__.py) und dann from __init__ import *in alle anderen Dateien zu importieren.

In diesem Fall bist du

1. Vermeiden mehrfacher Verweise auf diese Dateien und Klassen und
2. müssen auch nur eine Zeile in jede der anderen Dateien und hinzufügen
3. Der dritte wäre der Pycharm, der alle Klassen kennt, die Sie verwenden könnten.