如何在Python中重新加载模块的函数？

Question

跟进这个有关重新加载模块的问题，如何做我从更改的模块中重新加载特定功能？

伪代码：

from foo import bar

if foo.py has changed:
    reload bar

Answer 1

在 Python 中，热重载不是你可以在不爆头的情况下可靠地完成的事情。如果不以特殊方式编写代码，您实际上无法支持重新加载，并且尝试编写和维护支持重新加载的代码需要严格的纪律，并且过于混乱，不值得付出努力。测试这样的代码也不是一件容易的事。

解决方案是当代码发生更改时完全重新启动 Python 进程。可以无缝地完成此操作，但具体方式取决于您的具体问题领域。

Answer 2

虽然重新加载函数不是 reload 函数的功能，但它仍然是可能的。我不建议在生产中这样做，但它的工作原理如下：
您要替换的函数是内存中某处的对象，并且您的代码可能包含对它的许多引用（而不是对函数名称的引用）。但是该函数在调用时实际执行的操作并不保存在该对象中，而是保存在另一个对象中，而该对象又由该函数对象在其属性 __code__ 中引用。因此，只要您有对该函数的引用，您就可以更新其代码：

Module mymod:

from __future__ import print_function
def foo():
    print("foo")

Other module / python session:

>>> import mymod
>>> mymod.foo()
foo
>>> old_foo_ref = mymod.foo
>>> # edit mymod.py to make function "foo" print "bar"
>>> reload(mymod)
<module 'mymod' from 'mymod.py'>
>>> old_foo_ref()   # old reference is running old code
foo
>>> mymod.foo()     # reloaded module has new code
bar
>>> old_foo_ref.__code__ = mymod.foo.__code__
>>> old_foo_ref()   # now the old function object is also running the new code
bar
>>> 

现在，如果您没有对旧函数的引用（即 lambda code> 传递到另一个函数中），您可以尝试使用 gc 模块通过搜索所有对象的列表来获取它：

>>> def _apply(f, x):
...     return lambda: f(x)
... 
>>> tmp = _apply(lambda x: x+1, 1)  # now there is a lambda we don't have a reference to
>>> tmp()
2
>>> import gc
>>> lambdas = [obj for obj in gc.get_objects() if getattr(obj,'__name__','') == '<lambda>'] # get all lambdas
[<function <lambda> at 0x7f315bf02f50>, <function <lambda> at 0x7f315bf12050>]     
# i guess the first one is the one i passed in, and the second one is the one returned by _apply
# lets make sure:
>>> lambdas[0].__code__.co_argcount
1  # so this is the "lambda x: ..."
>>> lambdas[1].__code__.co_argcount
0  # and this is the "lambda: ..."
>>> lambdas[0].__code__ = (lambda x: x+2).__code__  # change lambda to return arg + 2
>>> tmp()
3  # 
>>> 

Answer 3

这个也行。

• 优点：它支持 from ... import ... 而不是 module.my_function，并且不需要将模块写为字符串。
• 缺点：需要导入模块。

# Import of my_function and module
import my_utils
from my_utils import my_function

# Test:
my_function()

# For reloading:
from importlib import reload
reload(my_utils)
from my_utils import my_function

# Test again:
my_function()

Answer 4

您必须使用 reload 来重新加载模块，因为您不能仅重新加载该函数：

>>> import sys
>>> reload(sys)
<module 'sys' (built-in)>
>>>

Answer 5

您无法从模块重新加载方法，但可以使用新名称再次加载模块，例如 foo2 并说 bar = foo2.bar 来覆盖当前引用。

请注意，如果 bar 对 foo 中的其他内容有任何依赖或任何其他副作用，您将会遇到麻烦。因此，虽然它有效，但它只适用于最简单的情况。

Answer 6

如果您是 foo.py 的作者，您可以这样写：

with open('bar.py') as f: bar_code=compile(f.read(),'bar.py','exec')

def bar(a,b):
    exec(bar_code)

def reload_bar():
    global bar_code
    with open('bar.py') as f: bar_code=compile(f.read(),'bar.py','exec') 

然后，在您的伪代码中，如果 bar.py 已更改，则重新加载。当 bar 与想要热重载它的代码位于同一模块中，而不是 OP 位于不同模块中的情况时，这种方法特别好。

Answer 7

截至今天，执行此操作的正确方法是：

import sys, importlib
importlib.reload(sys.modules['foo'])
from foo import bar

在 python 2.7、3.5、3.6 上测试。

Answer 8

你想要的是可能的，但需要重新加载两件事......首先reload(foo)，但你还必须reload(baz)（假设baz 是包含 from foo import bar 语句的模块的名称）。

至于为什么......第一次加载foo时，会创建一个foo对象，其中包含一个bar对象。当您将 bar 导入 baz 模块时，它会存储对 bar 的引用。当调用 reload(foo) 时，foo 对象被清空，并且模块重新执行。这意味着所有 foo 引用仍然有效，但是已经创建了一个新的 bar 对象...因此所有已导入某处的引用仍然是对 的引用旧的bar对象。通过重新加载 baz，您可以使其重新导入新的 bar。

---

或者，您可以在模块中执行 import foo 操作，并始终调用 foo.bar()。这样，每当您reload(foo)时，您都会获得最新的bar引用。

注意：从 Python 3 开始，需要首先通过 from importlib import reload 导入 reload 函数