18

以下代码允许您runtime.py在运行时修改的内容。换句话说，你不必打断runner.py。

#runner.py
import time
import imp

def main():
    while True:
        mod = imp.load_source("runtime", "./runtime.py")
        mod.function()
        time.sleep(1)

if __name__ == "__main__":
    main()

运行时导入的模块是：

# runtime.py
def function():
    print("I am version one of runtime.py")

这种原始机制允许您“如何交换” Python 代码（a la Erlang）。有更好的选择吗？

请注意，这只是一个学术问题，因为我没有必要做这样的事情。但是，我有兴趣了解更多有关 Python 运行时的信息。

编辑：

我创建了以下解决方案：Engine对象为模块中包含的函数提供接口（在这种情况下，模块被称为engine.py）。该Engine对象还产生一个线程来监视源文件中的变化，如果检测到变化，它会调用notify()引擎上的方法，重新加载源文件。

在我的实现中，更改检测基于每秒轮询一次frequency检查文件的 SHA1 校验和，但其他实现也是可能的。

在此示例中，检测到的每个更改都记录到名为 的文件hotswap.log中，其中注册了校验和。

检测更改的其他机制可能是服务器或线程inotify中的使用。Monitor

import imp
import time
import hashlib
import threading
import logging

logger = logging.getLogger("")

class MonitorThread(threading.Thread):
    def __init__(self, engine, frequency=1):
        super(MonitorThread, self).__init__()
        self.engine = engine
        self.frequency = frequency
        # daemonize the thread so that it ends with the master program
        self.daemon = True 

    def run(self):
        while True:
            with open(self.engine.source, "rb") as fp:
                fingerprint = hashlib.sha1(fp.read()).hexdigest()
            if not fingerprint == self.engine.fingerprint:
                self.engine.notify(fingerprint)
            time.sleep(self.frequency)

class Engine(object):
    def __init__(self, source):
        # store the path to the engine source
        self.source = source        
        # load the module for the first time and create a fingerprint
        # for the file
        self.mod = imp.load_source("source", self.source)
        with open(self.source, "rb") as fp:
            self.fingerprint = hashlib.sha1(fp.read()).hexdigest()
        # turn on monitoring thread
        monitor = MonitorThread(self)
        monitor.start()

    def notify(self, fingerprint):
        logger.info("received notification of fingerprint change ({0})".\
                        format(fingerprint))
        self.fingerprint = fingerprint
        self.mod = imp.load_source("source", self.source)

    def __getattr__(self, attr):
        return getattr(self.mod, attr)

def main():
    logging.basicConfig(level=logging.INFO, 
                        filename="hotswap.log")
    engine = Engine("engine.py")
    # this silly loop is a sample of how the program can be running in
    # one thread and the monitoring is performed in another.
    while True:
        engine.f1()
        engine.f2()
        time.sleep(1)

if __name__ == "__main__":
    main()

engine.py文件：

# this is "engine.py"
def f1():
    print("call to f1")

def f2():
    print("call to f2")

日志样本：

INFO:root:received notification of fingerprint change (be1c56097992e2a414e94c98cd6a88d162c96956)
INFO:root:received notification of fingerprint change (dcb434869aa94897529d365803bf2b48be665897)
INFO:root:received notification of fingerprint change (36a0a4b20ee9ca6901842a30aab5eb52796649bd)
INFO:root:received notification of fingerprint change (2e96b05bbb8dbe8716c4dd37b74e9f58c6a925f2)
INFO:root:received notification of fingerprint change (baac96c2d37f169536c8c20fe5935c197425ed40)
INFO:root:received notification of fingerprint change (be1c56097992e2a414e94c98cd6a88d162c96956)
INFO:root:received notification of fingerprint change (dcb434869aa94897529d365803bf2b48be665897)

再说一次 - 这是一个学术讨论，因为此时我不需要热交换 Python 代码。但是，我喜欢能够了解一点运行时并意识到什么是可能的，什么是不可能的。请注意，加载机制可以添加锁，以防它正在使用资源，以及异常处理，以防模块未成功加载。

注释？

4

3 回答 3

7

您可以轮询 runtime.py 文件，等待它更改。一旦它改变，只需调用

reload(runtime)

每当我调试 python 模块时，我都会在交互式 python 命令提示符中使用这种方法（除了我手动调用 reload()，我不轮询任何东西）。

编辑：要检测文件中的更改，请查看这个 SO question。轮询可能是最可靠的选择，但我只会在修改时间更新时重新加载文件，而不是在每次轮询时重新加载。您还应该考虑在重新加载时捕获异常，尤其是语法错误。而且您可能会也可能不会遇到线程安全问题。

于 2011-07-19T18:03:30.543 回答
1 
globe = __import__('copy').copy(globals())
while True:
    with open('runtime.py', 'r') as mod:
        exec mod in globe
    __import__('time').sleep(1)

将反复读取和运行runtime.py几乎未受污染的globals()no locals()，并且不会污染全局范围，但所有运行时的命名空间都将在globe

于 2011-07-19T17:57:52.577 回答
0

如果您想要在使用 import out of functions 等时发现的热交换代码，则需要覆盖模块的全局 var，例如，如果您使用：

import mylib

在代码中加载模块时需要将新模块分配给 mylib。其他提示是在使用线程的程序中尝试此操作以了解线程是否安全，并且当使用多处理时，这仅在一个进程中发现，对于所有进程中的更改代码都需要加载新代码，是否有必要尝试在多进程中是否安全。

而且，有趣的是，首先检查是否有新代码是否不加载相同的代码。并且认为只有在 Python 中您才能加载新模块并替换模块的变量名，但如果您真的需要一个好的热更改代码，请参阅Erlang语言和 OTP，它非常好。

于 2013-03-12T10:35:49.447 回答