没有循环导入的 Python 类型提示

Question

我正试图将我的大班一分为二；好吧，基本上进入“主”类和一个带有附加功能的mixin，如下所示：

main.py文件：

import mymixin.py

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

mymixin.py文件：

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

现在，虽然这工作得很好，但MyMixin.func2 中的类型提示当然不能工作。我无法导入main.py，因为我会得到一个循环导入并且没有提示，我的编辑器（PyCharm）无法分辨self 是什么。

我正在使用 Python 3.4，但如果那里有可用的解决方案，我愿意迁移到 3.5。

有什么方法可以将我的类拆分为两个文件并保留所有“连接”，以便我的 IDE 仍然为我提供自动完成功能以及它所带来的所有其他好处吗？

Answer 1

原来我最初的尝试也非常接近解决方案。这是我目前正在使用的：

# 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
        ...

注意 if False 语句中的导入永远不会被导入（但 IDE 无论如何都知道）并使用 Main 类作为字符串，因为它在运行时是未知的。

Answer 2

从 Python 3.5 开始，将类分解为单独的文件很容易。

实际上可以在class ClassName: 块的inside 中使用import 语句，以便将方法导入类中。例如，

class_def.py:

class C:
    from _methods1 import a
    from _methods2 import b

    def x(self):
        return self.a() + " " + self.b()

在我的例子中，

• C.a() 将是一个返回字符串 hello 的方法
• C.b() 将是一个返回 hello goodbye 的方法
• C.x() 将因此返回 hello hello goodbye。

要实现a 和b，请执行以下操作：

_methods1.py:

from __future__ import annotations
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from class_def import C

def a(self: C):
    return "hello"

解释：当类型检查器读取代码时，TYPE_CHECKING 是 True。由于类型检查器不需要执行代码，循环导入在 if TYPE_CHECKING: 块中发生时是可以的。 __future__ 导入启用 postponed annotations。这是可选的；没有它，您必须引用类型注释（即def a(self: "C"):）。

我们同样定义_methods2.py：

from __future__ import annotations
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from class_def import C

def b(self: C):
    return self.a() + " goodbye"

在 VS Code 中，悬停时我可以看到从 self.a() 检测到的类型：

一切都按预期运行：

>>> from class_def import C
>>> c = C()
>>> c.x()
'hello hello goodbye'

关于旧 Python 版本的说明

对于小于等于 3.4 的 Python 版本，TYPE_CHECKING 未定义，因此此解决方案不起作用。

对于小于等于 3.6 的 Python 版本，未定义延迟注释。作为一种解决方法，请省略 from __future__ import annotations 并引用上面提到的类型声明。

Answer 3

我建议按照其他人的建议重构您的代码。

我可以告诉你我最近遇到的一个循环错误：

之前：

# person.py
from spell import Heal, Lightning

class Person:
    def __init__(self):
        self.life = 100

class Jedi(Person):
    def heal(self, other: Person):
        Heal(self, other)

class Sith(Person):
    def lightning(self, other: Person):
        Lightning(self, other)

# spell.py
from person import Person, Jedi, Sith

class Spell:
    def __init__(self, caster: Person, target: Person):
        self.caster: Person = caster
        self.target: Person = target

class Heal(Spell):
    def __init__(self, caster: Jedi, target: Person):
        super().__init__(caster, target)
        target.life += 10

class Lightning(Spell):
    def __init__(self, caster: Sith, target: Person):
        super().__init__(caster, target)
        target.life -= 10

# main.py
from person import Jedi, Sith

一步一步：

# main starts to import person
from person import Jedi, Sith

# main did not reach end of person but ...
# person starts to import spell
from spell import Heal, Lightning

# Remember: main is still importing person
# spell starts to import person
from person import Person, Jedi, Sith

控制台：

ImportError: cannot import name 'Person' from partially initialized module
'person' (most likely due to a circular import)

一个脚本/模块只能由一个且只有一个脚本导入。

之后：

# person.py
class Person:
    def __init__(self):
        self.life = 100

# spell.py
from person import Person

class Spell:
    def __init__(self, caster: Person, target: Person):
        self.caster: Person = caster
        self.target: Person = target

# jedi.py
from person import Person
from spell import Spell

class Jedi(Person):
    def heal(self, other: Person):
        Heal(self, other)

class Heal(Spell):
    def __init__(self, caster: Jedi, target: Person):
        super().__init__(caster, target)
        target.life += 10

# sith.py
from person import Person
from spell import Spell

class Sith(Person):
    def lightning(self, other: Person):
        Lightning(self, other)

class Lightning(Spell):
    def __init__(self, caster: Sith, target: Person):
        super().__init__(caster, target)
        target.life -= 10

# main.py
from jedi import Jedi
from sith import Sith

jedi = Jedi()
print(jedi.life)
Sith().lightning(jedi)
print(jedi.life)

执行行的顺序：

from jedi import Jedi  # start read of jedi.py
from person import Person  # start AND finish read of person.py
from spell import Spell  # start read of spell.py
from person import Person  # start AND finish read of person.py
# finish read of spell.py

# idem for sith.py

控制台：

100
90

文件组合是关键 希望它会有所帮助：D

Answer 4

对于那些在只为类型检查导入类时遇到循环导入问题的人：您可能希望使用Forward Reference（PEP 484 - 类型提示）：

当类型提示包含尚未定义的名称时，该定义可以表示为字符串文字，稍后再解析。

所以而不是：

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

你会的：

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

Answer 5

恐怕没有一种非常优雅的方式来处理导入周期。您的选择是重新设计代码以消除循环依赖，或者如果不可行，请执行以下操作：

# some_file.py

from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from main import Main

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

TYPE_CHECKING 常量在运行时始终为 False，因此不会评估导入，但 mypy（和其他类型检查工具）会评估该块的内容。

我们还需要将Main 类型注释变成一个字符串，有效地向前声明它，因为Main 符号在运行时不可用。

如果您使用的是 Python 3.7+，我们至少可以通过利用 PEP 563 跳过提供显式字符串注释：

# 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):
        ...

from __future__ import annotations 导入将使 all 类型提示成为字符串并跳过评估它们。这有助于使我们的代码更符合人体工程学。

综上所述，在 mypy 中使用 mixins 可能需要比目前更多的结构。 Mypy recommends an approach 这基本上就是deceze 所描述的——创建一个你的Main 和MyMixin 类都继承的ABC。如果你最终需要做类似的事情来让 Pycharm 的检查器满意，我不会感到惊讶。

Answer 6

我认为完美的方法应该是在一个文件中导入所有类和依赖项（如__init__.py），然后在所有其他文件中导入from __init__ import *。

在这种情况下你是

1. 避免多次引用这些文件和类，并且
2. 也只需要在每个其他文件中添加一行，并且
3. 第三个是 pycharm，它知道您可能使用的所有类。

Answer 7

更大的问题是你的类型一开始就不健全。 MyMixin 做了一个硬编码假设，即它将被混合到 Main 中，而它可以混合到任意数量的其他类中，在这种情况下它可能会中断。如果您的 mixin 被硬编码为混合到一个特定的类中，那么您最好将方法直接写入该类，而不是将它们分开。

要正确输入，MyMixin 应该针对 interface 或 Python 用语中的抽象类进行编码：

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')