48

让我们考虑 python (3.x) 脚本:

主要.py:

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

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

测试/用户.py:

from test.team import team

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

测试/团队.py:

from test.user import user

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

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

所以,不是pythonista,我有三个问题。首先:

一世。我怎样才能使这件事起作用?

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

ii. 为什么这个设计不好?

最后,第三个:

iii. 有什么更好的选择?

准确地说,上面的类型检查只是一个例子,还有一个基于类的索引层,它允许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]

所以,除了这个邪恶的循环导入之外,它工作得很好(省略了实现细节,但没有什么复杂的)。

4

5 回答 5

82

循环进口本质上并不是一件坏事。在team使用. user_ user_team

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

相反,只导入模块。这导致更清晰的命名空间,使以后的猴子修补成为可能,并解决了导入问题。因为您只是在导入时导入模块,所以您并不关心其中的尚未定义。当您开始使用该课程时,它将是。

所以,测试/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少写。那仍然是导入模块,而不是模块成员。

另外,如果TeamUser比较简单,把它们放在同一个模块中。您不需要遵循 Java 一个文件一个类的习惯用法。测试isinstanceset方法也让我尖叫 unpythonic-Java-wart;取决于你在做什么,你最好使用一个普通的、未经类型检查的@property.

于 2010-10-18T01:10:20.337 回答
3

一世。要使其工作,您可以使用延迟导入。一种方法是不理会 user.py 并将 team.py 更改为:

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

iii. 作为替代方案,为什么不将团队和用户类放在同一个文件中?

于 2010-10-17T23:35:39.953 回答
2

不良做法/臭味如下:

  • 可能是不必要的类型检查(另见此处)。只需使用您作为用户/团队获得的对象并在异常发生时引发异常(或者在大多数情况下,引发异常而不需要额外的代码)。离开这个,你的循环导入就会消失(至少现在是这样)。只要您获得的对象表现得像用户/团队,它们就可以是任何东西。(鸭打字
  • 小写类(这或多或少是一个口味问题,但普遍接受的标准(PEP 8)的做法不同
  • 不需要的地方:你可以说:my_team.leader=user_buser_b.team=my_team
  • 数据一致性问题:如果(my_team.leader.team!=my_team)
于 2010-10-18T00:37:41.220 回答
0

这是我还没有看到的东西。直接使用是一个坏主意/设计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文件中,我们只是从其他“私有”文件中导入所有对象,我说私有,因为这些文件不打算直接访问,而是我们通过原始文件访问它们:

# 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

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

最后,我只会指出这样做是为了帮助用户提高可读性(更短的文件),因此我不会说循环导入“天生”不好。一切都可以在同一个文件中完成,但我们正在使用它,以便我们可以分离代码并且在滚动浏览大文件时不会混淆自己。

于 2014-03-13T19:37:47.023 回答
0

您可以修复依赖关系图;例如,用户可能不必知道它是团队的一部分这一事实。大多数循环依赖都承认这种重构。

# 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

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

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

于 2019-03-25T05:24:02.470 回答