Python 博格模式在两个不同模块中使用时的意外行为

我使用的是模块相互包含的博格模式。请参阅下面的示例代码（不是真正的代码，但它显示了问题）。在本例中，我有两个不同的Borg，因为解释器认为类名（我猜是类）是不同的

在这种情况下，有没有一种方法可以在不修改模块架构的情况下使用Borg

模块

borg.py

import borg2

class Borg:
    _we_are_one = {}

    def __init__(self):
        self.__dict__ = Borg._we_are_one
        try:
            self.name
        except AttributeError:
            self.name = "?"
        print self.__class__, id(self.__dict__)

def fct_ab():
    a = Borg()
    a.name = "Bjorn"

    b = Borg()
    print b.name

if __name__ == "__main__":
    fct_ab()
    borg2.fct_c()

import borg

def fct_c():
    c = borg.Borg()
    print c.name

模块

borg2.py

import borg2

class Borg:
    _we_are_one = {}

    def __init__(self):
        self.__dict__ = Borg._we_are_one
        try:
            self.name
        except AttributeError:
            self.name = "?"
        print self.__class__, id(self.__dict__)

def fct_ab():
    a = Borg()
    a.name = "Bjorn"

    b = Borg()
    print b.name

if __name__ == "__main__":
    fct_ab()
    borg2.fct_c()

import borg

def fct_c():
    c = borg.Borg()
    print c.name

结果是

\uuuuu main\uuuuuu.Borg 40106720
__梅因博格40106720
比约恩
博格，博格40106288
?

为了澄清我的问题：

---

为什么Python会考虑<代码> Borg？<代码>和<代码>博格？Borg <代码>作为两个不同的类？

< P>这不是问题的类名。我不完全清楚为什么Python认为Borg类和Borg.Borg类不同，可能是因为您从

\uuuu main\uuuu

运行它，我认为Python没有意识到

\uu main\uuug>和Borg是同一个模块

解决办法很简单。将fct_ab更改为：

def fct_ab():
    import borg
    a =  borg.Borg()
    a.name = "Bjorn"

    b = borg.Borg()
    print b.name

这就解决了问题。
问题不在于类名。我不完全清楚为什么Python认为Borg类和Borg.Borg类不同，可能是因为您从
\uuuu main\uuuu
运行它，我认为Python没有意识到
\uu main\uuug>和Borg是同一个模块

解决办法很简单。将fct_ab更改为：

def fct_ab():
    import borg
    a =  borg.Borg()
    a.name = "Bjorn"

    b = borg.Borg()
    print b.name

这就解决了问题。
问题只出现在主函数中。移动那个密码
到它自己的文件，一切都是你所期望的。此代码

import borg
import borg2

if __name__ == "__main__":
    borg.fct_ab()
    borg2.fct_c()

提供以下输出：

borg.Borg 10438672
borg.Borg 10438672
Bjorn
borg.Borg 10438672
Bjorn

问题只发生在主函数中。移动那个密码
到它自己的文件，一切都是你所期望的。此代码

import borg
import borg2

if __name__ == "__main__":
    borg.fct_ab()
    borg2.fct_c()

提供以下输出：

borg.Borg 10438672
borg.Borg 10438672
Bjorn
borg.Borg 10438672
Bjorn

我通过修复导入中的一个错误，解决了实际应用程序中的问题

事实上，我有两个不同的模块使用相同的第三个模块

第一个是导入mypackage.mymodule，而第二个是导入mymodule。mypackage是作为python鸡蛋安装的，我正在处理的代码位于我的开发文件夹中

所以这两个代码都导入了不同的模块，我想在这种情况下有两个不同的类是正常的

关于我使用的示例代码，问题来自于当前模块接收main作为名称。我试图通过执行
\uu name\uu='borg'
来重命名。它可以工作，但是如果uuu name uuuu==“uuuu main uuuuuu”
条件，它会中断
。作为结论，我要说，必须避免相互包容，而且在大多数情况下没有必要

谢谢大家的帮助。
我已经通过修复导入中的一个错误解决了实际应用程序中的问题

事实上，我有两个不同的模块使用相同的第三个模块

第一个是导入mypackage.mymodule，而第二个是导入mymodule。mypackage是作为python鸡蛋安装的，我正在处理的代码位于我的开发文件夹中

所以这两个代码都导入了不同的模块，我想在这种情况下有两个不同的类是正常的

关于我使用的示例代码，问题来自于当前模块接收main作为名称。我试图通过执行
\uu name\uu='borg'
来重命名。它可以工作，但是如果uuu name uuuu==“uuuu main uuuuuu”
条件，它会中断
。作为结论，我要说，必须避免相互包容，而且在大多数情况下没有必要

谢谢大家的帮助。
在与单身汉和博格进行了漫长的一天斗争之后，我的结论如下：

似乎使用不同的“导入路径”多次导入的Python模块实际上是多次导入的。如果该模块包含一个单例，则会得到多个实例

例如：

myproject/
  module_A
  some_folder/
    module_B
    module_C

如果模块A使用
从myproject.some_文件夹导入模块C
导入模块C，模块B使用
导入模块C
导入同一模块C，则该模块实际导入两次（至少根据我的观察）。通常情况下，这并不重要，但对于Singleton或borg，您实际上会得到两个应该是唯一的实例。（这是两组共享两种不同内部状态的borgs）

解决方案：给自己一个import语句约定并坚持它：我从一个公共根文件夹开始导入所有模块，即使模块文件与我正在处理的文件平行，因此在上面的示例中，模块A和模块B都使用myproject中的
导入模块C。一些文件夹导入模块C
经过一天与单身汉和博格人的斗争，我的结论如下：

似乎使用不同的“导入路径”多次导入的Python模块实际上是多次导入的。如果该模块包含一个单例，则会得到多个实例

例如：

myproject/
  module_A
  some_folder/
    module_B
    module_C

如果模块A使用
从myproject.some_文件夹导入模块C
导入模块C，模块B使用
导入模块C
导入同一模块C，则该模块实际导入两次（至少根据我的观察）。通常情况下，这并不重要，但对于Singleton或borg，您实际上会得到两个应该是唯一的实例。（这是两组共享两种不同内部状态的borgs）

解决方案：给自己一个import语句约定并坚持它：我从一个公共根文件夹开始导入所有模块，即使模块文件与我正在处理的文件平行，因此在上面的示例中，模块A和模块B都使用myproject中的
导入模块C。一些文件夹导入模块C
正如前面提到的，解决方案是避免主模块的递归
导入，但是
borg.py
不会被“导入两次”。问题是，在它已经执行时导入它会导致您定义