1. 在其它應(yīng)用程序嵌入 Python?

1.1. 高層次的嵌入?

最簡單的 Python 嵌入形式就是采用非常高層的接口。該接口的目標(biāo)是只執(zhí)行一段 Python 腳本，而無需與應(yīng)用程序直接交互。比如以下代碼可以用來對某個文件進(jìn)行一些操作。

#define PY_SSIZE_T_CLEAN
#include <Python.h>

int
main(int argc, char *argv[])
{
    wchar_t *program = Py_DecodeLocale(argv[0], NULL);
    if (program == NULL) {
        fprintf(stderr, "Fatal error: cannot decode argv[0]\n");
        exit(1);
    }
    Py_SetProgramName(program);  /* optional but recommended */
    Py_Initialize();
    PyRun_SimpleString("from time import time,ctime\n"
                       "print('Today is', ctime(time()))\n");
    if (Py_FinalizeEx() < 0) {
        exit(120);
    }
    PyMem_RawFree(program);
    return 0;
}

在 Py_Initialize() 之前，應(yīng)該先調(diào)用 Py_SetProgramName() 函數(shù)，以便向解釋器告知 Python運行庫的路徑。接下來，Py_Initialize() 會初始化 Python 解釋器，然后執(zhí)行硬編碼的 Python 腳本，打印出日期和時間。之后，調(diào)用 Py_FinalizeEx() 關(guān)閉解釋器，程序結(jié)束。在真實的程序中，可能需要從其他來源獲取 Python 腳本，或許是從文本編輯器例程、文件，或者某個數(shù)據(jù)庫。利用 PyRun_SimpleFile() 函數(shù)可以更好地從文件中獲取 Python 代碼，可省去分配內(nèi)存空間和加載文件內(nèi)容的麻煩。

1.2. 突破高層次嵌入的限制：概述?

高級接口能從應(yīng)用程序中執(zhí)行任何 Python 代碼，但至少交換數(shù)據(jù)可說是相當(dāng)麻煩的。如若需要交換數(shù)據(jù)，應(yīng)使用較低級別的調(diào)用。幾乎可以實現(xiàn)任何功能，代價是得寫更多的 C 代碼。

應(yīng)該注意，盡管意圖不同，但擴(kuò)展 Python 和嵌入 Python 的過程相當(dāng)類似。前幾章中討論的大多數(shù)主題依然有效。為了說明這一點，不妨來看一下從 Python 到 C 的擴(kuò)展代碼到底做了什么：

1. 將 Python 的數(shù)據(jù)轉(zhuǎn)換為 C 格式，

2. 用轉(zhuǎn)換后的數(shù)據(jù)執(zhí)行 C 程序的函數(shù)調(diào)用，

3. 將調(diào)用返回的數(shù)據(jù)從 C 轉(zhuǎn)換為 Python 格式。

嵌入 Python 時，接口代碼會這樣做：

1. 將 C 數(shù)據(jù)轉(zhuǎn)換為 Python 格式，

2. 用轉(zhuǎn)換后的數(shù)據(jù)執(zhí)行對 Python 接口的函數(shù)調(diào)用，

3. 將調(diào)用返回的數(shù)據(jù)從 Python 轉(zhuǎn)換為 C 格式。

可見只是數(shù)據(jù)轉(zhuǎn)換的步驟交換了一下順序，以順應(yīng)跨語言的傳輸方向。唯一的區(qū)別是在兩次數(shù)據(jù)轉(zhuǎn)換之間調(diào)用的函數(shù)不同。在執(zhí)行擴(kuò)展時，調(diào)用一個 C 函數(shù)，而執(zhí)行嵌入時調(diào)用的是個 Python 函數(shù)。

本文不會討論如何將數(shù)據(jù)從 Python 轉(zhuǎn)換到 C 去，反之亦然。另外還假定讀者能夠正確使用引用并處理錯誤。由于這些地方與解釋器的擴(kuò)展沒有區(qū)別，請參考前面的章節(jié)以獲得所需的信息。

1.3. 只做嵌入?

第一個程序的目標(biāo)是執(zhí)行 Python 腳本中的某個函數(shù)。就像高層次接口那樣，Python 解釋器并不會直接與應(yīng)用程序進(jìn)行交互（但下一節(jié)將改變這一點）。

要運行 Python 腳本中定義的函數(shù)，代碼如下：

#define PY_SSIZE_T_CLEAN
#include <Python.h>

int
main(int argc, char *argv[])
{
    PyObject *pName, *pModule, *pFunc;
    PyObject *pArgs, *pValue;
    int i;

    if (argc < 3) {
        fprintf(stderr,"Usage: call pythonfile funcname [args]\n");
        return 1;
    }

    Py_Initialize();
    pName = PyUnicode_DecodeFSDefault(argv[1]);
    /* Error checking of pName left out */

    pModule = PyImport_Import(pName);
    Py_DECREF(pName);

    if (pModule != NULL) {
        pFunc = PyObject_GetAttrString(pModule, argv[2]);
        /* pFunc is a new reference */

        if (pFunc && PyCallable_Check(pFunc)) {
            pArgs = PyTuple_New(argc - 3);
            for (i = 0; i < argc - 3; ++i) {
                pValue = PyLong_FromLong(atoi(argv[i + 3]));
                if (!pValue) {
                    Py_DECREF(pArgs);
                    Py_DECREF(pModule);
                    fprintf(stderr, "Cannot convert argument\n");
                    return 1;
                }
                /* pValue reference stolen here: */
                PyTuple_SetItem(pArgs, i, pValue);
            }
            pValue = PyObject_CallObject(pFunc, pArgs);
            Py_DECREF(pArgs);
            if (pValue != NULL) {
                printf("Result of call: %ld\n", PyLong_AsLong(pValue));
                Py_DECREF(pValue);
            }
            else {
                Py_DECREF(pFunc);
                Py_DECREF(pModule);
                PyErr_Print();
                fprintf(stderr,"Call failed\n");
                return 1;
            }
        }
        else {
            if (PyErr_Occurred())
                PyErr_Print();
            fprintf(stderr, "Cannot find function \"%s\"\n", argv[2]);
        }
        Py_XDECREF(pFunc);
        Py_DECREF(pModule);
    }
    else {
        PyErr_Print();
        fprintf(stderr, "Failed to load \"%s\"\n", argv[1]);
        return 1;
    }
    if (Py_FinalizeEx() < 0) {
        return 120;
    }
    return 0;
}

上述代碼先利用 argv[1] 加載 Python 腳本，再調(diào)用 argv[2] 指定的函數(shù)。函數(shù)的整數(shù)參數(shù)是 argv 數(shù)組中的其余值。如果 編譯并鏈接 該程序（此處將最終的可執(zhí)行程序稱作 call）, 并用它執(zhí)行一個 Python 腳本，例如：

def multiply(a,b):
    print("Will compute", a, "times", b)
    c = 0
    for i in range(0, a):
        c = c + b
    return c

然后結(jié)果應(yīng)該是：

$ call multiply multiply 3 2
Will compute 3 times 2
Result of call: 6

盡管相對其功能而言，該程序體積相當(dāng)龐大，但大部分代碼是用于 Python 和 C 之間的數(shù)據(jù)轉(zhuǎn)換，以及報告錯誤。嵌入 Python 的有趣部分從此開始：

Py_Initialize();
pName = PyUnicode_DecodeFSDefault(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);

初始化解釋器之后，則用 PyImport_Import() 加載腳本。此函數(shù)的參數(shù)需是個 Python 字符串，一個用 PyUnicode_FromString() 數(shù)據(jù)轉(zhuǎn)換函數(shù)構(gòu)建的字符串。

pFunc = PyObject_GetAttrString(pModule, argv[2]);
/* pFunc is a new reference */

if (pFunc && PyCallable_Check(pFunc)) {
    ...
}
Py_XDECREF(pFunc);

腳本一旦加載完畢，就會用 PyObject_GetAttrString() 查找屬性名稱。如果名稱存在，并且返回的是可調(diào)用對象，即可安全地視其為函數(shù)。然后程序繼續(xù)執(zhí)行，照常構(gòu)建由參數(shù)組成的元組。然后用以下方式調(diào)用 Python 函數(shù)：

pValue = PyObject_CallObject(pFunc, pArgs);

當(dāng)函數(shù)返回時，pValue 要么為 NULL，要么包含對函數(shù)返回值的引用。請確保用完后釋放該引用。

1.4. 對嵌入 Python 功能進(jìn)行擴(kuò)展?

到目前為止，嵌入的 Python 解釋器還不能訪問應(yīng)用程序本身的功能。Python API 通過擴(kuò)展嵌入解釋器實現(xiàn)了這一點。 也就是說，用應(yīng)用程序提供的函數(shù)對嵌入的解釋器進(jìn)行擴(kuò)展。雖然聽起來有些復(fù)雜，但也沒那么糟糕。只要暫時忘記是應(yīng)用程序啟動了 Python 解釋器。而把應(yīng)用程序看作是一堆子程序，然后寫一些膠水代碼讓 Python 訪問這些子程序，就像編寫普通的 Python 擴(kuò)展程序一樣。 例如：

static int numargs=0;

/* Return the number of arguments of the application command line */
static PyObject*
emb_numargs(PyObject *self, PyObject *args)
{
    if(!PyArg_ParseTuple(args, ":numargs"))
        return NULL;
    return PyLong_FromLong(numargs);
}

static PyMethodDef EmbMethods[] = {
    {"numargs", emb_numargs, METH_VARARGS,
     "Return the number of arguments received by the process."},
    {NULL, NULL, 0, NULL}
};

static PyModuleDef EmbModule = {
    PyModuleDef_HEAD_INIT, "emb", NULL, -1, EmbMethods,
    NULL, NULL, NULL, NULL
};

static PyObject*
PyInit_emb(void)
{
    return PyModule_Create(&EmbModule);
}

在 main() 函數(shù)之前插入上述代碼。并在調(diào)用 Py_Initialize() 之前插入以下兩條語句：

numargs = argc;
PyImport_AppendInittab("emb", &PyInit_emb);

這兩行代碼初始化了 numargs 變量，并讓 emb.numargs() 函數(shù)能被嵌入的 Python 解釋器訪問到。有了這些擴(kuò)展，Python 腳本可以執(zhí)行類似以下功能：

import emb
print("Number of arguments", emb.numargs())

在真實的應(yīng)用程序中，這種方法將把應(yīng)用的 API 暴露給 Python 使用。

1.5. 在 C++ 中嵌入 Python?

還可以將 Python 嵌入到 C++ 程序中去；確切地說，實現(xiàn)方式將取決于 C++ 系統(tǒng)的實現(xiàn)細(xì)節(jié)；一般需用 C++ 編寫主程序，并用 C++ 編譯器來編譯和鏈接程序。不需要用 C++ 重新編譯 Python 本身。

1.6. 在類 Unix 系統(tǒng)中編譯和鏈接?

為了將 Python 解釋器嵌入應(yīng)用程序，找到正確的編譯參數(shù)傳給編譯器 (和鏈接器) 并非易事，特別是因為 Python 加載的庫模塊是以 C 動態(tài)擴(kuò)展（.so 文件）的形式實現(xiàn)的。

為了得到所需的編譯器和鏈接器參數(shù)，可執(zhí)行 pythonX.Y-config 腳本，它是在安裝 Python 時生成的（也可能存在 python3-config 腳本）。該腳本有幾個參數(shù)，其中以下幾個參數(shù)會直接有用：

• pythonX.Y-config --cflags 將給出建議的編譯參數(shù)。

  $ /opt/bin/python3.4-config --cflags
  -I/opt/include/python3.4m -I/opt/include/python3.4m -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes
  

• pythonX.Y-config --ldflags 將給出建議的鏈接參數(shù)。

  $ /opt/bin/python3.4-config --ldflags
  -L/opt/lib/python3.4/config-3.4m -lpthread -ldl -lutil -lm -lpython3.4m -Xlinker -export-dynamic
  

如果上述方案不起作用（不能保證對所有 Unix 類平臺都生效；歡迎提出 bug 報告），就得閱讀系統(tǒng)關(guān)于動態(tài)鏈接的文檔，并檢查 Python 的 Makefile （用 sysconfig.get_makefile_filename() 找到所在位置）和編譯參數(shù)。這時 sysconfig 模塊會是個有用的工具，可用編程方式提取需組合在一起的配置值。比如：

>>> import sysconfig
>>> sysconfig.get_config_var('LIBS')
'-lpthread -ldl  -lutil'
>>> sysconfig.get_config_var('LINKFORSHARED')
'-Xlinker -export-dynamic'