Python通过多个其他模块重用同一模块

有可能在python中实现这一点吗？基本上，shared_fun是一个非常常用的实用函数，用于多个模块user_module1和user_module2。但是，每个用户都需要一个稍微不同的参数SHARE\u GLOBAL\u VAR

我希望这样做的一些动机：

想象一下，这里有很多共享的乐趣，共享的乐趣1，共享的乐趣2。。。。。。所有这些公司都依赖于相同的股票、全球风险价值，但用它做不同的事情。因此，我真的不想让SHARE\u GLOBAL\u VAR成为所有这些SHARE\u funSHARE\u GLOBAL\u VAR的参数

B.我想使共享的维护变得简单，这样我就不想将代码单独复制到每个user_module.py文件中

我认为任务可以归结为在每个用户模块名称空间中创建共享模块名称空间的副本，我不确定这在python中是否合法

#share.py:
SHARE_GLOBAL_VAR = 0
def shared_fun():
    return SHARE_GLOBAL_VAR

#user_module1.py:
import share
share.SHARE_GLOBAL_VAR = 1
def user1_fun():
    return share.shared_fun()

#user_module2.py:
import share
share.SHARE_GLOBAL_VAR = 2
def user2_fun():
    return share.shared_fun()

#main.py:
import user_module1
import user_module2
# expecting a result of 1
print(user_module1.user1_fun())
# expecting a result of 2
print(user_module2.user2_fun())

---

例如，您可以使用闭包的概念

def sharedFun():
    shared_var=0
    def getSharedVariable(shared_value=None):
        if shared_value:
            return shared_value
        else:
            return shared_var
    return getSharedVariable


shared=sharedFun()
print shared(1) # output 1
print shared(2) # output 2
print shared(3) # output 3
print shared() # output 0

---

您可以找到有关闭包的更多信息

对于磁盘上的给定文件，每个进程中最多有一个内存模块对象，因此您上面显示的在一个进程中有多个导入的内容将不起作用。这就是为什么第三方库模块使用“monkey patch”标准库模块是“不礼貌”的原因，也是为什么通常不鼓励使用全局数据变量的原因。

闭包是非常棒的！！！我对函数式编程知之甚少，但这确实激励了我去深入研究它

另一方面，我刚刚为我的具体问题提出了一个面向对象的解决方案：使shared.py成为一个类和所有shared\u fun as class方法，而SHARE\u GLOBAL\u VAR现在是类数据成员。每个用户模块1/2现在只需使用不同的share\u GLOBAL\u VAR实例化share类的一个对象

这实现了类似的想法，即通过一个类创建共享乐趣的多个副本，而不是复制模块导入，这在每个类中是不可能的

在本例中，我非常天真地比较了OOP和Functional：闭包解决方案在创建不同版本的函数时提供了更多的自由。由于闭包为每个函数而不是每个全局共享变量提供函数副本，因此它可以节省创建OOP解决方案从未使用过的不必要方法的开销

---

是时候认真对待函数式编程了

认领那个家伙。让我一步一步地给你解释

首先，仔细看看你接受的答案。事实上，这个答案和你原来问题的修改版本没有本质区别

#share.py:
SHARE_GLOBAL_VAR = 0
def getSharedVariable(shared_value=None):
    if shared_value:
        return shared_value
    else:
        return SHARE_GLOBAL_VAR

在接受的回答中，作用域是function sharedFun，而在上述代码段中作用域是module。几乎是一样的。您可以像这样使用上述代码段：

import share
shared = share.getSharedVariable
print shared(1) # output 1
print shared(2) # output 2
print shared(3) # output 3
print shared() # output 0

您仍在向getSharedVariable传递相同的值

此外，让我们讨论一下OOP解决方案。这是毫无意义的。如果每个对象都有各自不同的SHARE\u GLOBAL\u VAR，为什么这个变量称为SHARE\u GLOBAL\u VAR？它只是一个正常的局部变量

最后，让我们修改已接受的答案：

# assume SHARE_GLOBAL_VAR equals to 0.
def getSharedVariable(shared_value=SHARE_GLOBAL_VAR):
    return shared_value

shared = getSharedVariable
print shared(1) # output 1
print shared(2) # output 2
print shared(3) # output 3
print shared() # output 0

---

你注意到你真正想要什么了吗？只是一个默认参数。

使用相同的函数和不同的参数不是比使用不同的函数更简单吗？如果你真的想，你可以把赋值移到函数里面。如果需要将相同的值传递给每个共享函数，那么值得考虑。2.如果在函数内部赋值，如果两个函数user\u module1/2.user1/2\u-fun交替调用，则性能会很差，这会导致大量切换开销。目标是创建函数的多个副本，而无需编写重复的代码。OOP或闭包方法实际上说明并解决了这两个问题。这太神奇了！重用代码以生成多用途函数的好方法！谢谢你的解释，斯劳！我已经平静了几天，同时接触到了更多的闭包和装饰师，我喜欢这个被接受的答案，因为我欣赏它的强大和它确实解决了问题的事实。你的回答当然也会起作用。然而，在share.py模块中，实际上有更多的函数与share_GLOBAL_VAR类似。我承认这是一个不好的命名，因为它实际上是一个模块级常量，不应该在main.py中直接访问，让我们将其重命名为share_CONST_VAR。同样的想法也适用于user_module1.py和user_module2.py，因为有很多类似的函数基于shared.SHARE\u CONST\u VAR。我需要某些数据封装，同时让每个user\u module.py都有自己独特的SHARE\u CONST\u VAR。这是我不愿意在user\u module.py中的每个函数中都使用默认值的参数的主要原因。为了实现这一点，并且考虑到整个程序中只存在一个shared.SHARE\u CONST\u VAR，我必须在不同的user\u module.py中创建多个版本的函数，这可以实现 由用户OOP提供，或者由接受的答案使用闭包提供。