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)

测试/user.py：

from test.team import team

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

测试/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。有什么更好的选择？

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

编辑：

我希望有更详细的例子来阐明我要达到的目标。为了便于阅读而省略了文件（但是有一个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而使用进行user某些操作team。

这里最糟糕的做法是from module import member。该team模块正在尝试user在导入时获取该类，而该user模块正在尝试获取team该类。但是team该类尚不存在，因为您仍处于team.pywhenuser.py运行的第一行。

而是，仅导入模块。这样可以更清晰地命名空间，使以后的猴子修补成为可能，并解决了导入问题。因为您只是在导入时导入 模块 ，所以您不在乎尚未定义 模块
中的 类 。等到您开始使用该类时，它就会成为现实。

因此，test / users.py：

import test.teams

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

测试/teams.py：

import test.users

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

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

另外，如果Team和User比较简单，请将它们放在同一模块中。您无需遵循Java每个文件一个类的习惯用法。该isinstance测试和set方法也尖叫unpythonic-
Java的疣给我; 根据您在做什么，最好使用普通的，非类型检查的@property。