Python.Net中多次调用函数时如何重置环境/作用域

问题概述 #

需要多次执行同一个Python函数，保证每次执行环境完全隔离，但通过Python.Net调用时，第一次执行修改的全局变量会保留到第二次执行，无法恢复初始状态，与命令行执行的预期结果不符。

测试代码与现象 #

Python测试代码：

var1=1

def Met(n) :
    global var1

    if n!=1 : var1=n
    print(f"Py: {var1}")
    
    return var1
    
if __name__ == "__main__":
    import sys
    args = sys.argv
    globals()[args[1]](*args[2:])

• 命令行执行（符合预期）：

  python .\Test1.py Met 2
  python .\Test1.py Met 1
  

  输出：

  Py: 2
  Py: 1
  

• Python.Net调用（不符合预期）：
  输出：

  Py: 2
  Py: 2
  

现有C#调用代码（简化版） #

public string Met2(int n) {
    dynamic txtResul="X";

     using ( Py.GIL() ) { 
        using (var scope=gbl.NewScope() ) { // 无此代码也无法解决
            dynamic f=Py.Import(NOM_FICH_Py);
            txtResul=f.Met(n);
        }
    }        

    return txtResul.ToString();
}

已尝试的方案 #

• 带/不带初始化代码的调用（PythonEngine.Initialize()、Py.CreateScope()等）
• 每次调用后终止资源（PythonEngine.Shutdown()）
• 将函数调用作为独立脚本执行（scope.Exec()）

解决方案 #

方案1：强制重新加载Python模块 #

Python默认会缓存已导入的模块，因此每次调用时需用importlib.reload重新加载模块，重置全局变量：

public string Met2(int n) {
    dynamic txtResul="X";

    using ( Py.GIL() ) { 
        dynamic importlib = Py.Import("importlib");
        // 先导入模块，再强制重新加载
        dynamic f = importlib.reload(Py.Import(NOM_FICH_Py));
        txtResul = f.Met(n);
    }        

    return txtResul.ToString();
}

原理：重新加载模块会重新执行模块内的代码，将全局变量恢复到初始值。

方案2：重构Python代码，用类封装避免全局变量 #

将全局变量改为类的实例变量，每次调用创建新实例实现隔离：
修改后的Python代码：

class MetExecutor:
    def __init__(self):
        self.var1 = 1

    def Met(self, n):
        if n != 1:
            self.var1 = n
        print(f"Py: {self.var1}")
        return self.var1

if __name__ == "__main__":
    import sys
    executor = MetExecutor()
    executor.Met(int(sys.argv[2]))

对应的C#调用代码：

public string Met2(int n) {
    dynamic txtResul="X";

    using ( Py.GIL() ) { 
        dynamic f = Py.Import(NOM_FICH_Py);
        // 每次创建新实例，保证变量独立
        dynamic executor = f.MetExecutor();
        txtResul = executor.Met(n);
    }        

    return txtResul.ToString();
}

原理：每个类实例拥有独立的变量空间，从根源上避免全局变量共享问题。

方案3：通过子进程执行Python脚本 #

启动独立的Python进程执行脚本，完全模拟命令行的隔离环境：

using System.Diagnostics;

public string Met2(int n) {
    var psi = new ProcessStartInfo
    {
        FileName = "python",
        Arguments = $".\\Test1.py Met {n}",
        RedirectStandardOutput = true,
        UseShellExecute = false,
        CreateNoWindow = true
    };

    using (var process = Process.Start(psi))
    {
        process.WaitForExit();
        return process.StandardOutput.ReadToEnd().Trim();
    }
}

原理：每个子进程都是独立的Python解释器实例，完全隔离环境，缺点是进程启动开销较大。

额外问题解答 #

关于CreateScope、NewScope、Exec等函数的文档：

• 官方Wiki确实缺少详细API说明，可参考Python.Net仓库的源代码注释，相关类（如PyScope）的注释会标注函数功能
• 查看仓库的单元测试代码，里面有大量使用这些方法的示例，可直观理解用法
• 这些方法是对Python原生API的封装：CreateScope对应Python的作用域机制，Exec对应Python原生exec()函数，可参考Python官方文档中这些原生函数的说明辅助理解。

内容的提问来源于stack exchange，提问作者Enrique