AttributeError: '模块'对象没有'func'属性，仅在C++调用时出现

Question

我一直在努力把一个脚本系统整合进现有的架构中，并且使用了boost.python这个库。

我的目标是让我创建的Python环境和现有代码中预期的环境完全一样，或者尽量接近，比如保持命名空间的规则等等。这里的难点在于，我有两个源文件展示了一个用例，这个用例在独立启动解释器时可以正常工作，但在我的环境中却不行，这意味着我一定是哪里做错了。

需要说明的是，我不是一个经验丰富的Python用户，所以可能会把一些专业术语搞错。

core.py

import sys

def func():    
    print "sys is",sys

print "call from core"  
func()

main.py

import core

print "---------GLOBALS-------------"
globals_ = dict(globals())
for g in globals_:
    print g

print "--------------LOCALS---------"   
locals_ = dict(locals())
for l in locals_:
    print l

print "call from main"
core.func()

从命令提示符中调用 python main.py

call from core
sys is <module 'sys' (built-in)>
---------GLOBALS-------------
core
__builtins__
__name__
__file__
__doc__
__package__
--------------LOCALS---------
core
g
__builtins__
__file__
globals_
__package__
__name__
__doc__
call from main
sys is <module 'sys' (built-in)>

我理解的步骤是：

1. main调用import来导入core.py。
2. core模块被加载；core的命名空间和它提供的属性可以在main中访问。在这个过程中，core调用了它的func方法，打印出与sys绑定的内容。
3. main调用了在core模块下绑定的函数。

这是我如何启动脚本环境的例子：

void Run()
{
    Py_Initialize();
    if(PyErr_Occurred())
    {
        PyErr_Print();
    }

    // Install builtins in __main__
    boost::python::object main_module = boost::python::import(ToplevelScope.c_str());
    boost::python::object main_namespace = main_module.attr("__dict__");
    boost::python::dict main_dictionary = boost::python::extract<boost::python::dict>(main_namespace);
    main_dictionary["__builtins__"] =  boost::python::handle<>(boost::python::borrowed(PyEval_GetBuiltins()));

    // Load modules
    LoadModule("core.py",GetDataForCore());
    LoadModule("main.py",GetDataForMain());
}

void LoadModule(std::string name, char* data)
{
    // First, see if the module already exists.
    PyObject* new_module;
    if( new_module = PyImport_AddModule(name.c_str()) )
    {
        if( PyDict_GetItemString(new_module,"__name__") )
        {
            return; // already loaded. no work to do.
        }
    }

    // Initialize default namespace parameters - global, local
    boost::python::dict base_dict = boost::python::dict();
    base_dict["__builtins__"] = boost::python::handle<>(PyImport_AddModule("__builtin__"));
    base_dict["__name__"] = name.c_str();
    base_dict["__file__"] = name.c_str();
    base_dict["__doc__"] = "None";
    base_dict["__package__"] = name.c_str();

    boost::python::exec(    data,
                            boost::python::dict(base_dict),  // make a copy of base_dict for both global & local
                            boost::python::dict(base_dict) );
}

结果输出：

call from core
sys is <module 'sys' (built-in)>
---------GLOBALS-------------
core
__builtins__
__name__
__file__
__doc__
__package__
--------------LOCALS---------
core
g
__builtins__
__file__
globals_
__package__
__name__
__doc__
call from main
[LOG] Framework error while loading script main.py.
Traceback (most recent call last):
  File "<string>", line 17, in <module>
AttributeError: 'module' object has no attribute 'func'

看起来core中的函数在导入后对main来说还是不可访问。

我怀疑这和我没有完全初始化core模块有关。把exec替换成PyRun_String、PyImport_ImportModule……结果都是一样的。在这里，我创建了一个基础字典的副本，并把name设置为模块名（在这个例子中是core），并将其作为全局和本地字典提供。

我觉得我可能没有完全初始化模块，还需要做很多阅读来搞清楚……任何见解都会非常感激！！

Answer 1

看起来你是在试图重新发明轮子。boost::python::import 正好可以满足你的需求。它可以加载一个模块，或者如果这个模块之前已经被导入过，它会从 sys.modules 中获取。如果你不想使用 boost，那你可以用 PyObject* PyImport_ImportModule(const char *name)。只要确保这个模块在 Python 的路径上就可以了。

不过，如果这个模块并不存在于文件中（比如说它的源代码只存在于内存里），那么下面的代码可以重新实现这个功能（这段代码没有进行错误检查，你需要自己加上）。

py::object LoadModule(std::string name, const char* module_source)
{
    namespace py = boost::python;

    // create module name and filenames
    py::object name_str(py::str(name.c_str()));
    std::string file = name;
    file += ".py";
    py::object file_str(py::str(file.c_str()));

    // get helper modules
    py::object types(py::import("types"));
    py::object sys(py::import("sys"));

    if (py::dict(sys.attr("modules")).has_key(name_str)) {
        return sys.attr("modules")[name_str];
    }

    // create empty module
    py::object module(types.attr("ModuleType")(name_str));

    // init module dict
    py::dict base_dict = py::extract<py::dict>(module.attr("__dict__"));
    base_dict["__builtins__"] = py::import("__builtins__");
    base_dict["__name__"] = name_str;
    base_dict["__file__"] = file_str;

    // execute module code in module context
    py::exec(module_source, base_dict, base_dict);

    // add module to sys.modules
    sys.attr("modules")[name] = module;

    return module;
}