# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2017, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , 2017.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-12-19 18:31+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Dong-gweon Oh \n"
"Language-Team: Korean (https://python.flowdas.com)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.7.0\n"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:8
msgid "Embedding Python in Another Application"
msgstr " "
#: /Users/flowdas/works/docs/python/src/Doc/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 ""
" , C "
". : C/C++ . C "
"C++ . "
"; . "
" ."
#: /Users/flowdas/works/docs/python/src/Doc/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 ""
" , . , "
" . --- "
" ."
#: /Users/flowdas/works/docs/python/src/Doc/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 ""
" , . "
" . , :c:func:`Py_Initialize` . "
" . ."
#: /Users/flowdas/works/docs/python/src/Doc/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 ""
" : "
":c:func:`PyRun_SimpleString`\\ , stdio ( "
") :c:func:`PyRun_SimpleFile`\\ . , "
" ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:42
msgid ":ref:`c-api-index`"
msgstr ":ref:`c-api-index`"
#: /Users/flowdas/works/docs/python/src/Doc/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 " C . ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:49
msgid "Very High Level Embedding"
msgstr " "
#: /Users/flowdas/works/docs/python/src/Doc/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 ""
" . "
" . "
". ::"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:78
msgid ""
"The :c:func:`Py_SetProgramName` function should be called before "
":c:func:`Py_Initialize` 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:func:`Py_SetProgramName` "
":c:func:`Py_Initialize`\\ . , "
":c:func:`Py_Initialize`\\ , . "
" , :c:func:`Py_FinalizeEx` . "
" ( , ) . "
" :c:func:`PyRun_SimpleFile` , "
" ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:93
msgid "Beyond Very High Level Embedding: An overview"
msgstr " : "
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:95
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 ""
" , "
" . . C , "
" ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:100
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 ""
" . "
" . , C :"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:105
msgid "Convert data values from Python to C,"
msgstr " C ,"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:107
msgid "Perform a function call to a C routine using the converted values, and"
msgstr " C ,"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:109
msgid "Convert the data values from the call from C to Python."
msgstr " C ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:111
msgid "When embedding Python, the interface code does:"
msgstr " , :"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:113
msgid "Convert data values from C to Python,"
msgstr " C ,"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:115
msgid ""
"Perform a function call to a Python interface routine using the converted"
" values, and"
msgstr " ,"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:118
msgid "Convert the data values from the call from Python to C."
msgstr " C ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:120
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 , ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:125
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 ""
" C . , "
" . , "
" ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:134
msgid "Pure Embedding"
msgstr " "
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:136
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 ""
" . , "
" ( )."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:141
msgid "The code to run a function defined in a Python script is:"
msgstr " :"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:146
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 ` this program"
" (let's call the finished executable :program:`call`), and use it to "
"execute a Python script, such as:"
msgstr ""
" ``argv[1]``\\ , ``argv[2]``\\ . "
" ``argv`` . :ref:` ` ( "
" :program:`call`\\ ), :"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:161
msgid "then the result should be:"
msgstr " :"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:169
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 ""
" , C . "
" ::"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:178
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_FromString` "
"data conversion routine. ::"
msgstr ""
" , :c:func:`PyImport_Import`\\ . "
" , :c:func:`PyUnicode_FromString` . ::"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:191
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`\\ "
". , , . "
" . ::"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:199
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``\\ . "
" ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:207
msgid "Extending Embedded Python"
msgstr " "
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:209
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 ""
" . API "
" . , . , "
" . . , "
" , . "
"::"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:246
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`\\ "
" ::"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:252
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` "
" . , "
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:261
msgid ""
"In a real application, the methods will expose an API of the application "
"to Python."
msgstr " , API ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:271
msgid "Embedding Python in C++"
msgstr "C++ "
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:273
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 ""
" C++ ; C++ ;"
" C++ , C++ . C++ "
" ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:282
msgid "Compiling and Linking under Unix-like systems"
msgstr " "
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:284
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 ""
" ( ) . , "
" C (:file:`.so` ) ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:290
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` ). "
", :"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:296
msgid ""
"``pythonX.Y-config --cflags`` will give you the recommended flags when "
"compiling:"
msgstr "``pythonX.Y-config --cflags``\\ :"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:304
msgid ""
"``pythonX.Y-config --ldflags`` will give you the recommended flags when "
"linking:"
msgstr "``pythonX.Y-config --ldflags``\\ :"
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:313
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 ""
" ( ) , "
":file:`python{X.Y}-config`\\ ."
#: /Users/flowdas/works/docs/python/src/Doc/extending/embedding.rst:318
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 "
"`) 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 ""
" ( ; , :ref:`"
" `\\ ), / "
":file:`Makefile`\\ ( "
":func:`sysconfig.get_makefile_filename`\\ ) . , "
":mod:`sysconfig` . :"