将 Python 代码编译成 exe 文件，仅调用所需的 DLL

Question

关于这个主题的信息似乎很少 - 我试过 py2exe 无济于事（Python 3.5 出现错误），以及 pyinstaller. 后者似乎包括安装在除非它们在构建期间被明确排除，否则即使是小型构建也最终会达到 50+。我还看到了pyinst 和cxFreeze，您可以在其中指定要包含的包并将Python 与它捆绑在一起，但我想要简单而小巧。我所做的所有工作都涉及NumPy、SciPy 和Pandas。通常，这些都可以简化为 NumPy 唯一的函数，以及我在 Cython 中重写的最复杂的函数（使用 memoryviews）。环顾互联网，我发现python.exe 是一个仅调用Python.h 并加载python35.dll 的C++ 程序——这表明就像这个C++ 代码示例一样简单，它允许人们访问所有Python 和NumPy功能如下：

#include "Python.h"
#include <\numpy\core\include\numpy\ required includes>

int
wmain(int argc, wchar_t **argv)
{
    wchar_t *myargs[3] = { argv[0], L"-m", L"myscript.py" };
    return Py_Main(3, myargs);
}

示例来自： https://blogs.msdn.microsoft.com/pythonengineering/2016/04/26/cpython-embeddable-zip-file/

有没有人有一个好的方法或一个好的参考来生成一个小版本，其中只包含运行 exe 所需的内容？或者可以确认上述内容实际上适用于修改？非常感谢，我认为这个技能是一个小众主题......

Answer 1

如果可以取依赖，可以使用boost::python来帮忙。

下面有一个完整的工作示例应用程序，它仅链接 boost_python 和 python2.7 共享库。 -O3 构建只有 51K。

导入 python 模块：

您使用boost::python::exec 执行导入语句，将您的python 模块导入boost::python::object

bp::object import(const std::string& module, const std::string& path)
{
    bp::object globals = bp::import("__main__").attr("__dict__");

    bp::dict locals;
    locals["module_name"] = module;
    locals["path"]        = path;

    // execute some python code which imports the file
    bp::exec("import imp\n"
             "new_module = imp.load_module(module_name, open(path), path, ('bp', 'U', imp.PY_SOURCE))\n",
             globals,
             locals);
    return locals["new_module"];
}

// get an object containing the contents of the file "test.py"
bp::object module = import("test", "test.py");

获取python模块中元素的句柄：

// get a handle to something declared inside "test.py"
bp::object Script = module.attr("Script");

实例化一个对象：

// Instantiate a script object
bp::object script = Script();

调用Script的成员函数：

// calls Script.run(), passing no arguments
script.attr("run")();

您还可以将 C++ 代码公开给 python：

使用 boost::python::class 向刚刚导入的模块公开一个 C++ 类：

struct Foo
{
    void func();
}

bp::object FooWrapper(
    bp::class_<Foo>("Foo")
        .def("func", &Foo::func)
    );

bp::object foo    = FooWrapper(); // instantiate a python wrapped Foo object
bp::object script = Script(foo);  // create a Script instance, passing foo 

工作示例：

test.py

class Script(object):
    def __init__(self, ifc):
        print 'created script'
        self.ifc = ifc

    def run(self):
        print 'running'
        self.ifc.execute(5)

    def result(self, i):
        print 'result={}'.format(i)

main.cpp

#include <boost/python.hpp>

namespace bp = boost::python;

bp::object import(const std::string& module, const std::string& path)
{
    bp::object globals = bp::import("__main__").attr("__dict__");

    bp::dict locals;
    locals["module_name"] = module;
    locals["path"]        = path;

    bp::exec("import imp\n"
             "new_module = imp.load_module(module_name, open(path), path, ('bp', 'U', imp.PY_SOURCE))\n",
             globals,
             locals);
    return locals["new_module"];
}

///////////////////////////

class Runner
{
public:
    void init(bp::object script)
    {
        // capture methods at creation time so we don't have to look them up every time we call them
        _run    = script.attr("run");
        _result = script.attr("result");
    }

    void run()
    {
        _run(); // call the script's run method
    }

    void execute(int i) // this function is called by the python script
    {
        _result(i * 2); // call the script's result method
    }

    bp::object _run;
    bp::object _result;
};

int main()
{
    Py_Initialize();

    // load our python script and extract the Script class
    bp::object module = import("test", "test.py");
    bp::object Script = module.attr("Script");

    // wrap Runner and expose some functions to python
    bp::object RunnerWrapper(
        bp::class_<Runner>("Runner")
            .def("execute", &Runner::execute)
        );

    // create a python wrapped instance of Runner, which we will pass to the script so it can call back through it
    bp::object wrapper = RunnerWrapper();
    bp::object script  = Script(wrapper);

    // extract the runner instance from the python wrapped instance
    Runner& runner = bp::extract<Runner&>(wrapper);

    // initialise with the script, so we can get handles to the script's methods we require
    runner.init(script);

    runner.run();

    Py_Finalize();
    return 0;

CMakeLists.txt

cmake_minimum_required (VERSION 3.2.2)

find_package(Boost COMPONENTS python REQUIRED)
find_package(PythonLibs 2.7 REQUIRED)

add_executable            (py_embed main.cpp)
target_link_libraries     (py_embed ${Boost_PYTHON_LIBRARY} ${PYTHON_LIBRARIES})
target_include_directories(py_embed SYSTEM PRIVATE ${PYTHON_INCLUDE_DIRS})

可下载源代码here