python 循环导入再次（又名此设计有什么问题）

Question

让我们考虑一下 python (3.x) 脚本：

main.py:

from test.team import team
from test.user import user

if __name__ == '__main__':
    u = user()
    t = team()
    u.setTeam(t)
    t.setLeader(u)

test/user.py:

from test.team import team

class user:
    def setTeam(self, t):
        if issubclass(t, team.__class__):
            self.team = t

test/team.py:

from test.user import user

class team:
    def setLeader(self, u):
        if issubclass(u, user.__class__):
            self.leader = u

现在，当然，我有了循环导入和出色的 ImportError。

所以，我不是 pythonista，我有三个问题。首先：

我。我怎样才能让这个东西发挥作用？

并且，知道有人不可避免地会说“循环导入总是表明设计问题”，第二个问题来了：

ii。为什么这个设计不好？

最后，第三个：

iii。什么是更好的选择？

准确的说，上面的类型检查只是一个例子，还有一个基于class的索引层，允许ie。找到所有用户都是一个团队的成员（用户类别有许多子类，因此对于一般用户和每个特定子类，索引加倍）或所有将用户作为成员的团队

编辑：

我希望这个更详细的例子将阐明我试图实现的目标。为了便于阅读而省略了文件（但是有一个 300kb 的源文件不知怎的让我害怕，所以请假设每个类都在不同的文件中）

# ENTITY

class Entity:
    _id    = None
    _defs  = {}
    _data  = None

    def __init__(self, **kwargs):
        self._id   = uuid.uuid4() # for example. or randint(). or x+1.
        self._data = {}.update(kwargs)

    def __settattr__(self, name, value):
        if name in self._defs:
            if issubclass(value.__class__, self._defs[name]):
                self._data[name] = value

                # more stuff goes here, specially indexing dependencies, so we can 
                # do Index(some_class, name_of_property, some.object) to find all   
                # objects of some_class or its children where
                # given property == some.object

            else:
                raise Exception('Some misleading message')
        else:
            self.__dict__[name] = value    

    def __gettattr__(self, name):
        return self._data[name]

# USERS 

class User(Entity):
    _defs  = {'team':Team}

class DPLUser(User):
    _defs  = {'team':DPLTeam}

class PythonUser(DPLUser)
    pass

class PerlUser(DPLUser)
    pass

class FunctionalUser(User):
    _defs  = {'team':FunctionalTeam}

class HaskellUser(FunctionalUser)
    pass

class ErlangUser(FunctionalUser)
    pass

# TEAMS

class Team(Entity):
    _defs  = {'leader':User}

class DPLTeam(Team):
    _defs  = {'leader':DPLUser}

class FunctionalTeam(Team):
    _defs  = {'leader':FunctionalUser}

，现在有一些用法：

t1 = FunctionalTeam()
t2 = DLPTeam()
t3 = Team()

u1 = HaskellUser()
u2 = PythonUser()

t1.leader = u1 # ok
t2.leader = u2 # ok
t1.leader = u2 # not ok, exception
t3.leader = u2 # ok

# now , index

print(Index(FunctionalTeam, 'leader', u2)) # -> [t2]
print(Index(Team, 'leader', u2)) # -> [t2,t3]

所以，它工作得很好（省略了实现细节，但没有什么复杂的）除此之外邪恶的圆形进口东西。

Answer 1

你可以只修复依赖图；例如，用户可能不必知道自己是团队的一部分。大多数循环依赖都允许这样的重构。

# team -> user instead of team <-> user
class Team:
    def __init__(self):
        self.users = set()
        self.leader = None

    def add_user(self, user):
        self.users.add(user)

    def get_leader(self):
        return self.leader

    def set_leader(self, user):
        assert user in self.users, 'leaders must be on the team!'
        self.leader = user

循环依赖使重构变得非常复杂，抑制了代码重用，并降低了测试中的隔离性。

尽管在 Python 中可以通过运行时导入、导入到模块级别或使用此处提到的其他技巧来规避 ImportError，但这些策略确实掩盖了设计缺陷。如果可能的话，值得避免循环导入。

Answer 2

循环进口本质上并不是一件坏事。 team 代码很自然地依赖 user，而 user 则与 team 一起执行某些操作。

这里最糟糕的做法是from module import member。 team 模块尝试在导入时获取 user 类，并且 user 模块尝试获取 team< /代码> 类。但 team 类尚不存在，因为当 user.py 运行时，您仍位于 team.py 的第一行。

相反，仅导入模块。这会产生更清晰的命名空间，使以后的猴子修补成为可能，并解决了导入问题。因为您仅在导入时导入模块，所以您不必关心其中的类是否尚未定义。当你开始使用这个类时，它就会发生。

所以， test/users.py:

import test.teams

class User:
    def setTeam(self, t):
        if isinstance(t, test.teams.Team):
            self.team = t

test/teams.py:

import test.users

class Team:
    def setLeader(self, u):
        if isinstance(u, test.users.User):
            self.leader = u

from test import groups 然后 teams.Team 也可以，如果你想写 test少。这仍然是导入模块，而不是模块成员。

另外，如果Team和User相对简单，请将它们放在同一个模块中。您无需遵循 Java 每个文件一个类的习惯用法。 isinstance 测试和 set 方法也让我尖叫着 unpythonic-Java-wart；根据您正在做的事情，您可能最好使用普通的、未经类型检查的@property。

Answer 3

我。为了使其正常工作，您可以使用延迟导入。一种方法是保留 user.py 并将 team.py 更改为

class team:
    def setLeader(self, u):
        from test.user import user
        if issubclass(u, user.__class__):
            self.leader = u

：作为替代方案，为什么不将团队和用户类放在同一个文件中？

Answer 4

不好的做法/臭味如下：

• 可能不必要的类型检查（另请参阅此处）。只需使用您获得的对象，就像用户/团队一样，并在异常时引发异常（或者在大多数情况下，无需额外代码即可引发异常）。离开这个，你的循环导入就会消失（至少现在是这样）。只要您获得的对象表现得像用户/团队，它们可以是任何东西。 (Duck Typing)
• 小写类（这或多或少是一个品味问题，但是 做了不同的
• 普遍接受的标准（PEP 8）在不必要的地方 设置：您可以说： my_team.leader=user_b 和 user_b.team=my_team
• 数据一致性问题：如果 (my_team.leader.team!=my_team) 会怎样？ ？

Answer 5

这是我还没见过的东西。直接使用 sys.modules 是一个坏主意/设计吗？阅读@bobince解决方案后，我以为我已经了解了整个导入业务，但后来遇到了一个类似于 问题 的问题，该问题链接到这个。

这是解决方案的另一种看法：

# main.py
from test import team
from test import user

if __name__ == '__main__':
    u = user.User()
    t = team.Team()
    u.setTeam(t)
    t.setLeader(u)

---

# test/team.py
from test import user

class Team:
    def setLeader(self, u):
        if isinstance(u, user.User):
            self.leader = u

---

# test/user.py
import sys
team = sys.modules['test.team']

class User:
    def setTeam(self, t):
        if isinstance(t, team.Team):
            self.team = t

文件 test/__init__.py 文件为空。之所以有效，是因为首先导入了 test.team 。当 python 导入/读取文件时，它将模块附加到 sys.modules 中。当我们导入 test/user.py 时，模块 test.team 已经被定义，因为我们是在 main.py 中导入它的。

我开始喜欢这个想法，因为模块变得非常大，但有相互依赖的函数和类。假设有一个名为 util.py 的文件，并且该文件包含许多相互依赖的类。也许我们可以将代码拆分到相互依赖的不同文件中。我们如何解决循环导入？

好吧，在 util.py 文件中，我们只需从其他“私有”文件导入所有对象，我说私有是因为这些文件不应该直接访问，而是通过原始文件访问它们file：

# mymodule/util.py
from mymodule.private_util1 import Class1
from mymodule.private_util2 import Class2
from mymodule.private_util3 import Class3

然后在其他每个文件上：

# mymodule/private_util1.py
import sys
util = sys.modules['mymodule.util']
class Class1(object):
    # code using other classes: util.Class2, util.Class3, etc

---

# mymodule/private_util2.py
import sys
util = sys.modules['mymodule.util']
class Class2(object):
    # code using other classes: util.Class1, util.Class3, etc

只要首先尝试导入 mymodule.util，sys.modules 调用就会起作用。

最后，我只会指出这样做是为了帮助用户提高可读性（较短的文件），因此我不会说循环导入“本质上”是不好的。一切都可以在同一个文件中完成，但我们使用它是为了可以分离代码，并且在滚动浏览大文件时不会感到困惑。