# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

#

# Translators:

# Leon H., 2017

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-06-27 07:36+0000\n"

"PO-Revision-Date: 2018-05-23 14:09+0000\n"

"Last-Translator: Adrian Liaw <adrianliaw2000@gmail.com>\n"

"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"

"tw)\n"

"Language: zh_TW\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../extending/embedding.rst:8

msgid "Embedding Python in Another Application"

msgstr "在其它 App 內嵌入 Python"

#: ../../extending/embedding.rst:10

msgid ""

"The previous chapters discussed how to extend Python, that is, how to extend "

"the functionality of Python by attaching a library of C functions to it. It "

"is also possible to do it the other way around: enrich your C/C++ "

"application by embedding Python in it. Embedding provides your application "

"with the ability to implement some of the functionality of your application "

"in Python rather than C or C++. This can be used for many purposes; one "

"example would be to allow users to tailor the application to their needs by "

"writing some scripts in Python. You can also use it yourself if some of the "

"functionality can be written in Python more easily."

msgstr ""

"前面的章節討論了如何擴充 Python，也就是如何透過附加一個 C 函式庫來擴充 "

"Python 的功能。但也可以反過來做：將 Python 嵌入你的 C/C++ 應用程式中"

"。嵌入讓你的應用程式能夠以 Python 而非 C 或 C++ 來實作應用程式的某些功能。"

"這可以用於許多目的；其中一個例子是允許使用者透過撰寫一些 Python 腳本來根據他們"

"的需求客製化應用程式。如果某些功能用 Python 寫起來比較容易，你也可以自己使用"

"這種方法。"

#: ../../extending/embedding.rst:20

msgid ""

"Embedding Python is similar to extending it, but not quite. The difference "

"is that when you extend Python, the main program of the application is still "

"the Python interpreter, while if you embed Python, the main program may have "

"nothing to do with Python --- instead, some parts of the application "

"occasionally call the Python interpreter to run some Python code."

msgstr ""

"嵌入 Python 與擴充 Python 類似，但不完全相同。差別在於當你擴充 Python 時，應用程式"

"的主程式仍然是 Python 直譯器，而當你嵌入 Python，主程式可能與 Python "

"無關 — 相反地，應用程式的某些部分偶爾會呼叫 Python 直譯器來執行一些 Python "

"程式碼。"

#: ../../extending/embedding.rst:26

msgid ""

"So if you are embedding Python, you are providing your own main program. "

"One of the things this main program has to do is initialize the Python "

"interpreter. At the very least, you have to call the function :c:func:"

"`Py_Initialize`. There are optional calls to pass command line arguments to "

"Python. Then later you can call the interpreter from any part of the "

"application."

msgstr ""

"所以如果你要嵌入 Python，你要提供自己的主程式。這個主程式必須做的事情之一是"

"初始化 Python 直譯器，或至少必須要呼叫函式 :c:func:`Py_Initialize`。還有一些"

"可選的呼叫來傳遞命令列引數給 Python。然後你就可以在應用程式的任何部分呼叫直譯"

"器。"

#: ../../extending/embedding.rst:32

msgid ""

"There are several different ways to call the interpreter: you can pass a "

"string containing Python statements to :c:func:`PyRun_SimpleString`, or you "

"can pass a stdio file pointer and a file name (for identification in error "

"messages only) to :c:func:`PyRun_SimpleFile`. You can also call the lower-"

"level operations described in the previous chapters to construct and use "

"Python objects."

msgstr ""

"有幾種不同的方式來呼叫直譯器：你可以傳遞一個包含 Python 陳述式的字串給 :c:func:"

"`PyRun_SimpleString`，或者你可以傳遞一個 stdio 檔案指標和檔案名稱（僅用於錯誤"

"訊息中的識別）給 :c:func:`PyRun_SimpleFile`。你也可以呼叫前面章節中描述的較低"

"層級操作來建構和使用 Python 物件。"

#: ../../extending/embedding.rst:41

msgid ":ref:`c-api-index`"

msgstr ":ref:`c-api-index`"

#: ../../extending/embedding.rst:42

msgid ""

"The details of Python's C interface are given in this manual. A great deal "

"of necessary information can be found here."

msgstr ""

"Python 的 C 介面詳細資訊在此手冊中提供。大量必要的資訊可以在這裡找到。"

#: ../../extending/embedding.rst:49

msgid "Very High Level Embedding"

msgstr "非常高階的嵌入"

#: ../../extending/embedding.rst:51

msgid ""

"The simplest form of embedding Python is the use of the very high level "

"interface. This interface is intended to execute a Python script without "

"needing to interact with the application directly. This can for example be "

"used to perform some operation on a file. ::"

msgstr ""

"嵌入 Python 最簡單的形式是使用非常高階的介面。此介面用於執行 Python 腳本而"

"無需直接與應用程式互動。例如這可以用來對檔案執行一些操作。 ::"

#: ../../extending/embedding.rst:56

msgid ""

"#define PY_SSIZE_T_CLEAN\n"

"#include <Python.h>\n"

"\n"

"int\n"

"main(int argc, char *argv[])\n"

"{\n"

" PyStatus status;\n"

" PyConfig config;\n"

" PyConfig_InitPythonConfig(&config);\n"

"\n"

" /* optional but recommended */\n"

" status = PyConfig_SetBytesString(&config, &config.program_name, "

"argv[0]);\n"

" if (PyStatus_Exception(status)) {\n"

" goto exception;\n"

" }\n"

"\n"

" status = Py_InitializeFromConfig(&config);\n"

" if (PyStatus_Exception(status)) {\n"

" goto exception;\n"

" }\n"

" PyConfig_Clear(&config);\n"

"\n"

" PyRun_SimpleString(\"from time import time,ctime\\n\"\n"

" \"print('Today is', ctime(time()))\\n\");\n"

" if (Py_FinalizeEx() < 0) {\n"

" exit(120);\n"

" }\n"

" return 0;\n"

"\n"

" exception:\n"

" PyConfig_Clear(&config);\n"

" Py_ExitStatusException(status);\n"

"}"

msgstr ""

"#define PY_SSIZE_T_CLEAN\n"

"#include <Python.h>\n"

"\n"

"int\n"

"main(int argc, char *argv[])\n"

"{\n"

" PyStatus status;\n"

" PyConfig config;\n"

" PyConfig_InitPythonConfig(&config);\n"

"\n"

" /* 建議但非必要 */\n"

" status = PyConfig_SetBytesString(&config, &config.program_name, "

"argv[0]);\n"

" if (PyStatus_Exception(status)) {\n"

" goto exception;\n"

" }\n"

"\n"

" status = Py_InitializeFromConfig(&config);\n"

" if (PyStatus_Exception(status)) {\n"

" goto exception;\n"

" }\n"

" PyConfig_Clear(&config);\n"

"\n"

" PyRun_SimpleString(\"from time import time,ctime\\n\"\n"

" \"print('Today is', ctime(time()))\\n\");\n"

" if (Py_FinalizeEx() < 0) {\n"

" exit(120);\n"

" }\n"

" return 0;\n"

"\n"

" exception:\n"

" PyConfig_Clear(&config);\n"

" Py_ExitStatusException(status);\n"

"}"

#: ../../extending/embedding.rst:92

msgid ""

"``#define PY_SSIZE_T_CLEAN`` was used to indicate that ``Py_ssize_t`` should "

"be used in some APIs instead of ``int``. It is not necessary since Python "

"3.13, but we keep it here for backward compatibility. See :ref:`arg-parsing-"

"string-and-buffers` for a description of this macro."

msgstr ""

"``#define PY_SSIZE_T_CLEAN`` 被用來指示某些 API 應該使用 ``Py_ssize_t`` 而不是 "

"``int``。從 Python 3.13 開始不再需要它，但我們保留它以維持向後相容性。"

"關於此巨集的描述請參閱 :ref:`arg-parsing-string-and-buffers`。"

#: ../../extending/embedding.rst:97

msgid ""

"Setting :c:member:`PyConfig.program_name` should be called before :c:func:"

"`Py_InitializeFromConfig` to inform the interpreter about paths to Python "

"run-time libraries. Next, the Python interpreter is initialized with :c:"

"func:`Py_Initialize`, followed by the execution of a hard-coded Python "

"script that prints the date and time. Afterwards, the :c:func:"

"`Py_FinalizeEx` call shuts the interpreter down, followed by the end of the "

"program. In a real program, you may want to get the Python script from "

"another source, perhaps a text-editor routine, a file, or a database. "

"Getting the Python code from a file can better be done by using the :c:func:"

"`PyRun_SimpleFile` function, which saves you the trouble of allocating "

"memory space and loading the file contents."

msgstr ""

":c:member:`PyConfig.program_name` 的設定應該在 :c:func:`Py_InitializeFromConfig` "

"前呼叫，以告知直譯器 Python run-time 函式庫的路徑。接下來，Python 直譯器會用 :c:"

"func:`Py_Initialize` 初始化，然後執行一個硬編碼的 Python 腳本來印出日期和時間。"

"之後，:c:func:`Py_FinalizeEx` 呼叫會關閉直譯器，接著程式結束。在真實的程式中，"

"你可能想要從另一個來源取得 Python 腳本，或許是文字編輯器例程、檔案或資料庫。"

"從檔案取得 Python 程式碼可以更好地使用 :c:func:`PyRun_SimpleFile` 函式來完成，"

"這樣可以省去分配記憶體空間和載入檔案內容的麻煩。"

#: ../../extending/embedding.rst:112

msgid "Beyond Very High Level Embedding: An overview"

msgstr "超越非常高階嵌入：概觀"

#: ../../extending/embedding.rst:114

msgid ""

"The high level interface gives you the ability to execute arbitrary pieces "

"of Python code from your application, but exchanging data values is quite "

"cumbersome to say the least. If you want that, you should use lower level "

"calls. At the cost of having to write more C code, you can achieve almost "

"anything."

msgstr ""

"高階介面讓你能夠從應用程式中執行任意的 Python 程式碼片段，但交換資料"

"值的過程可以說相當繁瑣。如果你想進行這類操作，應該使用較低階的呼叫。"

"雖然需要撰寫更多的 C 程式碼，但幾乎可以實現任何功能。"

#: ../../extending/embedding.rst:119

msgid ""

"It should be noted that extending Python and embedding Python is quite the "

"same activity, despite the different intent. Most topics discussed in the "

"previous chapters are still valid. To show this, consider what the extension "

"code from Python to C really does:"

msgstr ""

"需要注意的是，雖然目的不同，但擴充 Python 與嵌入 Python 其實是非常相似的操作，"

"前面章節討論的大多數主題在這裡同樣適用。為了說明這一點，請思考從 Python 到 C "

"的擴充程式碼實際上做了什麼："

#: ../../extending/embedding.rst:124

msgid "Convert data values from Python to C,"

msgstr "將資料值從 Python 轉換為 C，"

#: ../../extending/embedding.rst:126

msgid "Perform a function call to a C routine using the converted values, and"

msgstr "使用轉換後的值呼叫 C 例程，並"

#: ../../extending/embedding.rst:128

msgid "Convert the data values from the call from C to Python."

msgstr "將呼叫中的資料值從 C 轉換為 Python。"

#: ../../extending/embedding.rst:130

msgid "When embedding Python, the interface code does:"

msgstr "當嵌入 Python 時，介面程式碼會："

#: ../../extending/embedding.rst:132

msgid "Convert data values from C to Python,"

msgstr "將資料值從 C 轉換為 Python，"

#: ../../extending/embedding.rst:134

msgid ""

"Perform a function call to a Python interface routine using the converted "

"values, and"

msgstr "使用轉換後的值呼叫 Python 介面例程，並"

#: ../../extending/embedding.rst:137

msgid "Convert the data values from the call from Python to C."

msgstr "將呼叫中的資料值從 Python 轉換為 C。"

#: ../../extending/embedding.rst:139

msgid ""

"As you can see, the data conversion steps are simply swapped to accommodate "

"the different direction of the cross-language transfer. The only difference "

"is the routine that you call between both data conversions. When extending, "

"you call a C routine, when embedding, you call a Python routine."

msgstr ""

"如你所見，資料轉換的步驟只是互換了順序，以配合跨語言傳遞方向的不同。唯一的差別在於"

"兩個資料轉換之間所呼叫的例程：在擴充時你呼叫的是 C 例程；在嵌入時則呼叫 Python "

"例程。"

#: ../../extending/embedding.rst:144

msgid ""

"This chapter will not discuss how to convert data from Python to C and vice "

"versa. Also, proper use of references and dealing with errors is assumed to "

"be understood. Since these aspects do not differ from extending the "

"interpreter, you can refer to earlier chapters for the required information."

msgstr ""

"本章不會討論如何將資料從 Python 轉換為 C 或從 C 轉換回 Python，且假設讀者已經知道參照的"

"正確使用方式與錯誤處理。由於這些部分與擴充直譯器時相同，"

"相關資訊可參考前面的章節。"

#: ../../extending/embedding.rst:153

msgid "Pure Embedding"

msgstr "純嵌入"

#: ../../extending/embedding.rst:155

msgid ""

"The first program aims to execute a function in a Python script. Like in the "

"section about the very high level interface, the Python interpreter does not "

"directly interact with the application (but that will change in the next "

"section)."

msgstr ""

"第一個程式的目標是執行 Python 腳本中的函式。就像在非常高階介面的章節中一樣，"

"Python 直譯器不會直接與應用程式互動（但這在下一節會改變）。"

#: ../../extending/embedding.rst:160

msgid "The code to run a function defined in a Python script is:"

msgstr "執行 Python 腳本中定義函式的程式碼是："

#: ../../extending/embedding.rst:162

msgid ""

"#define PY_SSIZE_T_CLEAN\n"

"#include <Python.h>\n"

"\n"

"int\n"

"main(int argc, char *argv[])\n"

"{\n"

" PyObject *pName, *pModule, *pFunc;\n"

" PyObject *pArgs, *pValue;\n"

" int i;\n"

"\n"

" if (argc < 3) {\n"

" fprintf(stderr,\"Usage: call pythonfile funcname [args]\\n\");\n"

" return 1;\n"

" }\n"

"\n"

" Py_Initialize();\n"

" pName = PyUnicode_DecodeFSDefault(argv[1]);\n"

" /* Error checking of pName left out */\n"

"\n"

" pModule = PyImport_Import(pName);\n"

" Py_DECREF(pName);\n"

"\n"

" if (pModule != NULL) {\n"

" pFunc = PyObject_GetAttrString(pModule, argv[2]);\n"

" /* pFunc is a new reference */\n"

"\n"

" if (pFunc && PyCallable_Check(pFunc)) {\n"

" pArgs = PyTuple_New(argc - 3);\n"

" for (i = 0; i < argc - 3; ++i) {\n"

" pValue = PyLong_FromLong(atoi(argv[i + 3]));\n"

" if (!pValue) {\n"

" Py_DECREF(pArgs);\n"

" Py_DECREF(pModule);\n"

" fprintf(stderr, \"Cannot convert argument\\n\");\n"

" return 1;\n"

" }\n"

" /* pValue reference stolen here: */\n"

" PyTuple_SetItem(pArgs, i, pValue);\n"

" }\n"

" pValue = PyObject_CallObject(pFunc, pArgs);\n"

" Py_DECREF(pArgs);\n"

" if (pValue != NULL) {\n"

" printf(\"Result of call: %ld\\n\", PyLong_AsLong(pValue));\n"

" Py_DECREF(pValue);\n"

" }\n"

" else {\n"

" Py_DECREF(pFunc);\n"

" Py_DECREF(pModule);\n"

" PyErr_Print();\n"

" fprintf(stderr,\"Call failed\\n\");\n"

" return 1;\n"

" }\n"

" }\n"

" else {\n"

" if (PyErr_Occurred())\n"

" PyErr_Print();\n"

" fprintf(stderr, \"Cannot find function \\\"%s\\\"\\n\", "

"argv[2]);\n"

" }\n"

" Py_XDECREF(pFunc);\n"

" Py_DECREF(pModule);\n"

" }\n"

" else {\n"

" PyErr_Print();\n"

" fprintf(stderr, \"Failed to load \\\"%s\\\"\\n\", argv[1]);\n"

" return 1;\n"

" }\n"

" if (Py_FinalizeEx() < 0) {\n"

" return 120;\n"

" }\n"

" return 0;\n"

"}\n"

msgstr ""

#: ../../extending/embedding.rst:165

msgid ""

"This code loads a Python script using ``argv[1]``, and calls the function "

"named in ``argv[2]``. Its integer arguments are the other values of the "

"``argv`` array. If you :ref:`compile and link <compiling>` this program "

"(let's call the finished executable :program:`call`), and use it to execute "

"a Python script, such as:"

msgstr ""

"此程式碼使用 ``argv[1]`` 載入 Python 腳本，並呼叫 ``argv[2]`` 中所指定的函式。"

"其整數引數則來自 ``argv`` 陣列中的其他值。如果你\\ :ref:`編譯並連結 <compiling>`\\ 此"

"程式（我們稱完成的可執行檔為 :program:`call`），並用它來執行 Python 腳本，"

"例如："

#: ../../extending/embedding.rst:171

msgid ""

"def multiply(a,b):\n"

" print(\"Will compute\", a, \"times\", b)\n"

" c = 0\n"

" for i in range(0, a):\n"

" c = c + b\n"

" return c"

msgstr ""

"def multiply(a,b):\n"

" print(\"Will compute\", a, \"times\", b)\n"

" c = 0\n"

" for i in range(0, a):\n"

" c = c + b\n"

" return c"

#: ../../extending/embedding.rst:180

msgid "then the result should be:"

msgstr "那麼結果應該是："

#: ../../extending/embedding.rst:182

msgid ""

"$ call multiply multiply 3 2\n"

"Will compute 3 times 2\n"

"Result of call: 6"

msgstr ""

"$ call multiply multiply 3 2\n"

"Will compute 3 times 2\n"

"Result of call: 6"

#: ../../extending/embedding.rst:188

msgid ""

"Although the program is quite large for its functionality, most of the code "

"is for data conversion between Python and C, and for error reporting. The "

"interesting part with respect to embedding Python starts with ::"

msgstr ""

"雖然以其功能而言這個程式相當龐大，但大部分的程式碼是用於 Python 與 C 之間的資料"

"轉換以及錯誤回報。至於與嵌入 Python 有關的重點部分，則從以下開始： ::"

#: ../../extending/embedding.rst:192

msgid ""

"Py_Initialize();\n"

"pName = PyUnicode_DecodeFSDefault(argv[1]);\n"

"/* Error checking of pName left out */\n"

"pModule = PyImport_Import(pName);"

msgstr ""

"Py_Initialize();\n"

"pName = PyUnicode_DecodeFSDefault(argv[1]);\n"

"/* Error checking of pName left out */\n"

"pModule = PyImport_Import(pName);"

#: ../../extending/embedding.rst:197

msgid ""

"After initializing the interpreter, the script is loaded using :c:func:"

"`PyImport_Import`. This routine needs a Python string as its argument, "

"which is constructed using the :c:func:`PyUnicode_DecodeFSDefault` data "

"conversion routine. ::"

msgstr ""

"在初始化直譯器後，腳本使用 :c:func:`PyImport_Import` 載入。此例程需要一個 "

"Python 字串作為其引數，該字串使用 :c:func:`PyUnicode_DecodeFSDefault` 資料"

"轉換例程建構。 ::"

#: ../../extending/embedding.rst:202

msgid ""

"pFunc = PyObject_GetAttrString(pModule, argv[2]);\n"

"/* pFunc is a new reference */\n"

"\n"

"if (pFunc && PyCallable_Check(pFunc)) {\n"

" ...\n"

"}\n"

"Py_XDECREF(pFunc);"

msgstr ""

"pFunc = PyObject_GetAttrString(pModule, argv[2]);\n"

"/* pFunc is a new reference */\n"

"\n"

"if (pFunc && PyCallable_Check(pFunc)) {\n"

" ...\n"

"}\n"

"Py_XDECREF(pFunc);"

#: ../../extending/embedding.rst:210

msgid ""

"Once the script is loaded, the name we're looking for is retrieved using :c:"

"func:`PyObject_GetAttrString`. If the name exists, and the object returned "

"is callable, you can safely assume that it is a function. The program then "

"proceeds by constructing a tuple of arguments as normal. The call to the "

"Python function is then made with::"

msgstr ""

"腳本載入後，會使用 :c:func:`PyObject_GetAttrString` 來取得所需的名稱。如果"

"該名稱存在，且回傳的物件是可呼叫的，便可安全地假設它是一個函式。接著，程式會以"

"一般方式建立引數的元組。之後便以下列方式呼叫該 Python 函式： ::"

#: ../../extending/embedding.rst:216

msgid "pValue = PyObject_CallObject(pFunc, pArgs);"

msgstr "pValue = PyObject_CallObject(pFunc, pArgs);"

#: ../../extending/embedding.rst:218

msgid ""

"Upon return of the function, ``pValue`` is either ``NULL`` or it contains a "

"reference to the return value of the function. Be sure to release the "

"reference after examining the value."

msgstr ""

"函式回傳時，``pValue`` 要不是 ``NULL`` 就是包含函式回傳值的參照。請務必在檢查"

"值之後釋放參照。"

#: ../../extending/embedding.rst:226

msgid "Extending Embedded Python"

msgstr "擴充嵌入式 Python"

#: ../../extending/embedding.rst:228

msgid ""

"Until now, the embedded Python interpreter had no access to functionality "

"from the application itself. The Python API allows this by extending the "

"embedded interpreter. That is, the embedded interpreter gets extended with "

"routines provided by the application. While it sounds complex, it is not so "

"bad. Simply forget for a while that the application starts the Python "

"interpreter. Instead, consider the application to be a set of subroutines, "

"and write some glue code that gives Python access to those routines, just "

"like you would write a normal Python extension. For example::"

msgstr ""

"到目前為止，嵌入式 Python 直譯器尚無法存取應用程式本身的功能。Python API 允許透過"

"擴充嵌入式直譯器來達成這點。也就是說，嵌入式直譯器可以由應用程式所提供的例程加以"

"擴充。雖然聽起來複雜但其實並不難。只要暫時忘記是應用程式啟動了 Python 直譯器，"

"改以將應用程式視為一組子程序，並撰寫一些膠合程式碼讓 Python 能夠存取"

"這些例程，就像你撰寫一般 Python 擴充一樣。例如： ::"

#: ../../extending/embedding.rst:237

msgid ""

"static int numargs=0;\n"

"\n"

"/* Return the number of arguments of the application command line */\n"

"static PyObject*\n"

"emb_numargs(PyObject *self, PyObject *args)\n"

"{\n"

" if(!PyArg_ParseTuple(args, \":numargs\"))\n"

" return NULL;\n"

" return PyLong_FromLong(numargs);\n"

"}\n"

"\n"

"static PyMethodDef emb_module_methods[] = {\n"

" {\"numargs\", emb_numargs, METH_VARARGS,\n"

" \"Return the number of arguments received by the process.\"},\n"

" {NULL, NULL, 0, NULL}\n"

"};\n"

"\n"

"static struct PyModuleDef emb_module = {\n"

" .m_base = PyModuleDef_HEAD_INIT,\n"

" .m_name = \"emb\",\n"

" .m_size = 0,\n"

" .m_methods = emb_module_methods,\n"

"};\n"

"\n"

"static PyObject*\n"

"PyInit_emb(void)\n"

"{\n"

" return PyModuleDef_Init(&emb_module);\n"

"}"

msgstr ""

#: ../../extending/embedding.rst:267

msgid ""

"Insert the above code just above the :c:func:`main` function. Also, insert "

"the following two statements before the call to :c:func:`Py_Initialize`::"

msgstr ""

"在 :c:func:`main` 函式的正上方插入上述程式碼。同時，在呼叫 :c:func:"

"`Py_Initialize` 之前插入以下兩個陳述式： ::"

#: ../../extending/embedding.rst:270

msgid ""

"numargs = argc;\n"

"PyImport_AppendInittab(\"emb\", &PyInit_emb);"

msgstr ""

"numargs = argc;\n"

"PyImport_AppendInittab(\"emb\", &PyInit_emb);"

#: ../../extending/embedding.rst:273

msgid ""

"These two lines initialize the ``numargs`` variable, and make the :func:`!"

"emb.numargs` function accessible to the embedded Python interpreter. With "

"these extensions, the Python script can do things like"

msgstr ""

"這兩行初始化 ``numargs`` 變數，並讓 :func:`!emb.numargs` 函式可供嵌入式 Python "

"直譯器使用。有了這些擴充後，Python 腳本便可以執行像是以下的操作"

#: ../../extending/embedding.rst:277

msgid ""

"import emb\n"

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

msgstr ""

"import emb\n"

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

#: ../../extending/embedding.rst:282

msgid ""

"In a real application, the methods will expose an API of the application to "

"Python."

msgstr "在真實的應用程式中，這些方法會向 Python 公開應用程式的 API。"

#: ../../extending/embedding.rst:292

msgid "Embedding Python in C++"

msgstr "在 C++ 中嵌入 Python"

#: ../../extending/embedding.rst:294

msgid ""

"It is also possible to embed Python in a C++ program; precisely how this is "

"done will depend on the details of the C++ system used; in general you will "

"need to write the main program in C++, and use the C++ compiler to compile "

"and link your program. There is no need to recompile Python itself using C+"

"+."

msgstr ""

"也可以將 Python 嵌入 C++ 程式中；具體如何做取決於所使用的 C++ 系統的細節；"

"一般來說，你需要用 C++ 撰寫主程式，並使用 C++ 編譯器來編譯和連結你的程式。"

"不需要使用 C++ 重新編譯 Python 本身。"

#: ../../extending/embedding.rst:303

msgid "Compiling and Linking under Unix-like systems"

msgstr "在類 Unix 系統下編譯和連結"

#: ../../extending/embedding.rst:305

msgid ""

"It is not necessarily trivial to find the right flags to pass to your "

"compiler (and linker) in order to embed the Python interpreter into your "

"application, particularly because Python needs to load library modules "

"implemented as C dynamic extensions (:file:`.so` files) linked against it."

msgstr ""

"要找到傳遞給編譯器（和連結器）的正確旗標以便將 Python 直譯器嵌入你的應用程式"

"中，並不一定是簡單的事，特別是因為 Python 需要載入作為 C 動態擴充（:file:`.so` 檔案）實作的函式庫"

"模組，而這些模組又必須與 Python 進行連結。"

#: ../../extending/embedding.rst:311

msgid ""

"To find out the required compiler and linker flags, you can execute the :"

"file:`python{X.Y}-config` script which is generated as part of the "

"installation process (a :file:`python3-config` script may also be "

"available). This script has several options, of which the following will be "

"directly useful to you:"

msgstr ""

"要找出所需的編譯器和連結器旗標，你可以執行作為安裝過程的一部分產生的 :file:"

"`python{X.Y}-config` 腳本（也可能有 :file:`python3-config` 腳本可用）。此腳本"

"提供多種選項，其中以下幾個最為實用："

#: ../../extending/embedding.rst:317

msgid ""

"``pythonX.Y-config --cflags`` will give you the recommended flags when "

"compiling:"

msgstr "``pythonX.Y-config --cflags`` 會給你編譯時建議的旗標："

#: ../../extending/embedding.rst:320

msgid ""

"$ /opt/bin/python3.11-config --cflags\n"

"-I/opt/include/python3.11 -I/opt/include/python3.11 -Wsign-compare -DNDEBUG "

"-g -fwrapv -O3 -Wall"

msgstr ""

"$ /opt/bin/python3.11-config --cflags\n"

"-I/opt/include/python3.11 -I/opt/include/python3.11 -Wsign-compare -DNDEBUG "

"-g -fwrapv -O3 -Wall"

#: ../../extending/embedding.rst:325

msgid ""

"``pythonX.Y-config --ldflags --embed`` will give you the recommended flags "

"when linking:"

msgstr "``pythonX.Y-config --ldflags --embed`` 會給你連結時建議的旗標："

#: ../../extending/embedding.rst:328

msgid ""

"$ /opt/bin/python3.11-config --ldflags --embed\n"

"-L/opt/lib/python3.11/config-3.11-x86_64-linux-gnu -L/opt/lib -lpython3.11 -"

"lpthread -ldl -lutil -lm"

msgstr ""

"$ /opt/bin/python3.11-config --ldflags --embed\n"

"-L/opt/lib/python3.11/config-3.11-x86_64-linux-gnu -L/opt/lib -lpython3.11 -"

"lpthread -ldl -lutil -lm"

#: ../../extending/embedding.rst:334

msgid ""

"To avoid confusion between several Python installations (and especially "

"between the system Python and your own compiled Python), it is recommended "

"that you use the absolute path to :file:`python{X.Y}-config`, as in the "

"above example."

msgstr ""

"為了避免多個 Python 安裝之間產生混淆（特別是系統自帶的 Python 與自行編譯的 Python "

"之間），建議使用 :file:`python{X.Y}-config` 的絕對路徑，如上面的例子所示。"

#: ../../extending/embedding.rst:339

msgid ""

"If this procedure doesn't work for you (it is not guaranteed to work for all "

"Unix-like platforms; however, we welcome :ref:`bug reports <reporting-"

"bugs>`) you will have to read your system's documentation about dynamic "

"linking and/or examine Python's :file:`Makefile` (use :func:`sysconfig."

"get_makefile_filename` to find its location) and compilation options. In "

"this case, the :mod:`sysconfig` module is a useful tool to programmatically "

"extract the configuration values that you will want to combine together. "

"For example:"

msgstr ""

"如果此程序對你不起作用（並不保證在所有類 Unix 平台上都能運作；不過我們歡迎\\ :ref:"

"`錯誤回報 <reporting-bugs>`），你將需要參閱系統的動態連結相關文件，並／或檢查 "

"Python 的 :file:`Makefile`\\ （可使用 :func:`sysconfig.get_makefile_filename` 來"

"找到其位置）和編譯選項。在這種情況下，:mod:`sysconfig` 模組是一個實用的工具，"

"可用於以程式化方式擷取並組合所需的組態值。例如："

#: ../../extending/embedding.rst:348

msgid ""

">>> import sysconfig\n"

">>> sysconfig.get_config_var('LIBS')\n"

"'-lpthread -ldl -lutil'\n"

">>> sysconfig.get_config_var('LINKFORSHARED')\n"

"'-Xlinker -export-dynamic'"

msgstr ""

">>> import sysconfig\n"

">>> sysconfig.get_config_var('LIBS')\n"

"'-lpthread -ldl -lutil'\n"

">>> sysconfig.get_config_var('LINKFORSHARED')\n"

"'-Xlinker -export-dynamic'"