Edit File - File Manager

Edit File: embedding.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 
 <title>5. Embedding Python in Another Application &mdash; Python v2.6.6 documentation</title>
 <link rel="stylesheet" href="../_static/default.css" type="text/css" />
 <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
 <script type="text/javascript">
 var DOCUMENTATION_OPTIONS = {
 URL_ROOT: '../',
 VERSION: '2.6.6',
 COLLAPSE_MODINDEX: false,
 FILE_SUFFIX: '.html',
 HAS_SOURCE: true
 };
 </script>
 <script type="text/javascript" src="../_static/jquery.js"></script>
 <script type="text/javascript" src="../_static/doctools.js"></script>
 <link rel="search" type="application/opensearchdescription+xml"
 title="Search within Python v2.6.6 documentation"
 href="../_static/opensearch.xml"/>
 <link rel="author" title="About these documents" href="../about.html" />
 <link rel="copyright" title="Copyright" href="../copyright.html" />
 <link rel="top" title="Python v2.6.6 documentation" href="../index.html" />
 <link rel="up" title="Extending and Embedding the Python Interpreter" href="index.html" />
 <link rel="next" title="Python/C API Reference Manual" href="../c-api/index.html" />
 <link rel="prev" title="4. Building C and C++ Extensions on Windows" href="windows.html" />
 <link rel="shortcut icon" type="image/png" href="../_static/py.png" />

</head>
 <body>
 <div class="related">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="../genindex.html" title="General Index"
 accesskey="I">index</a></li>
 <li class="right" >
 <a href="../modindex.html" title="Global Module Index"
 accesskey="M">modules</a> |</li>
 <li class="right" >
 <a href="../c-api/index.html" title="Python/C API Reference Manual"
 accesskey="N">next</a> |</li>
 <li class="right" >
 <a href="windows.html" title="4. Building C and C++ Extensions on Windows"
 accesskey="P">previous</a> |</li>
 <li><img src="../_static/py.png" alt=""
 style="vertical-align: middle; margin-top: -1px"/></li>
 <li><a href="../index.html">Python v2.6.6 documentation</a> &raquo;</li>

<li><a href="index.html" accesskey="U">Extending and Embedding the Python Interpreter</a> &raquo;</li> 
 </ul>
 </div>

<div class="document">
 <div class="documentwrapper">
 <div class="bodywrapper">
 <div class="body">
 
 <div class="section" id="embedding-python-in-another-application">
<h1>5. Embedding Python in Another Application<a class="headerlink" href="#embedding-python-in-another-application" title="Permalink to this headline">¶</a></h1>
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.
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 &#8212; instead, some parts of the application occasionally call
the Python interpreter to run some Python code.
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 <a title="Py_Initialize" class="reference external" href="../c-api/init.html#Py_Initialize"><tt class="xref docutils literal">Py_Initialize()</tt></a>. There are
optional calls to pass command line arguments to Python. Then later you can
call the interpreter from any part of the application.
There are several different ways to call the interpreter: you can pass a string
containing Python statements to <a title="PyRun_SimpleString" class="reference external" href="../c-api/veryhigh.html#PyRun_SimpleString"><tt class="xref docutils literal">PyRun_SimpleString()</tt></a>, or you can pass a
stdio file pointer and a file name (for identification in error messages only)
to <a title="PyRun_SimpleFile" class="reference external" href="../c-api/veryhigh.html#PyRun_SimpleFile"><tt class="xref docutils literal">PyRun_SimpleFile()</tt></a>. You can also call the lower-level operations
described in the previous chapters to construct and use Python objects.
A simple demo of embedding Python can be found in the directory
<tt class="docutils literal">Demo/embed/</tt> of the source distribution.
<div class="admonition-see-also admonition seealso">
See also
<dl class="last docutils">
<dt><a class="reference external" href="../c-api/index.html#c-api-index">Python/C API Reference Manual</a></dt>
<dd>The details of Python&#8217;s C interface are given in this manual. A great deal of
necessary information can be found here.</dd>
</dl>
</div>
<div class="section" id="very-high-level-embedding">
<h2>5.1. Very High Level Embedding<a class="headerlink" href="#very-high-level-embedding" title="Permalink to this headline">¶</a></h2>
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.
<div class="highlight-c"><div class="highlight"><pre>#include &lt;Python.h&gt;

int
main(int argc, char *argv[])
{
 Py_Initialize();
 PyRun_SimpleString(&quot;from time import time,ctime\n&quot;
 &quot;print &#39;Today is&#39;,ctime(time())\n&quot;);
 Py_Finalize();
 return 0;
}
</pre></div>
</div>
The above code first initializes the Python interpreter with
<a title="Py_Initialize" class="reference external" href="../c-api/init.html#Py_Initialize"><tt class="xref docutils literal">Py_Initialize()</tt></a>, followed by the execution of a hard-coded Python script
that print the date and time. Afterwards, the <a title="Py_Finalize" class="reference external" href="../c-api/init.html#Py_Finalize"><tt class="xref docutils literal">Py_Finalize()</tt></a> 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 <a title="PyRun_SimpleFile" class="reference external" href="../c-api/veryhigh.html#PyRun_SimpleFile"><tt class="xref docutils literal">PyRun_SimpleFile()</tt></a> function, which saves you the
trouble of allocating memory space and loading the file contents.
</div>
<div class="section" id="beyond-very-high-level-embedding-an-overview">
<h2>5.2. Beyond Very High Level Embedding: An overview<a class="headerlink" href="#beyond-very-high-level-embedding-an-overview" title="Permalink to this headline">¶</a></h2>
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.
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:
<ol class="arabic simple">
<li>Convert data values from Python to C,</li>
<li>Perform a function call to a C routine using the converted values, and</li>
<li>Convert the data values from the call from C to Python.</li>
</ol>
When embedding Python, the interface code does:
<ol class="arabic simple">
<li>Convert data values from C to Python,</li>
<li>Perform a function call to a Python interface routine using the converted
values, and</li>
<li>Convert the data values from the call from Python to C.</li>
</ol>
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.
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.
</div>
<div class="section" id="pure-embedding">
<h2>5.3. Pure Embedding<a class="headerlink" href="#pure-embedding" title="Permalink to this headline">¶</a></h2>
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).
The code to run a function defined in a Python script is:
<div class="highlight-c"><div class="highlight"><pre>#include &lt;Python.h&gt;

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

Py_Initialize();
 pName = PyString_FromString(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 &amp;&amp; PyCallable_Check(pFunc)) {
 pArgs = PyTuple_New(argc - 3);
 for (i = 0; i &lt; argc - 3; ++i) {
 pValue = PyInt_FromLong(atoi(argv[i + 3]));
 if (!pValue) {
 Py_DECREF(pArgs);
 Py_DECREF(pModule);
 fprintf(stderr, &quot;Cannot convert argument\n&quot;);
 return 1;
 }
 /* pValue reference stolen here: */
 PyTuple_SetItem(pArgs, i, pValue);
 }
 pValue = PyObject_CallObject(pFunc, pArgs);
 Py_DECREF(pArgs);
 if (pValue != NULL) {
 printf(&quot;Result of call: %ld\n&quot;, PyInt_AsLong(pValue));
 Py_DECREF(pValue);
 }
 else {
 Py_DECREF(pFunc);
 Py_DECREF(pModule);
 PyErr_Print();
 fprintf(stderr,&quot;Call failed\n&quot;);
 return 1;
 }
 }
 else {
 if (PyErr_Occurred())
 PyErr_Print();
 fprintf(stderr, &quot;Cannot find function \&quot;%s\&quot;\n&quot;, argv[2]);
 }
 Py_XDECREF(pFunc);
 Py_DECREF(pModule);
 }
 else {
 PyErr_Print();
 fprintf(stderr, &quot;Failed to load \&quot;%s\&quot;\n&quot;, argv[1]);
 return 1;
 }
 Py_Finalize();
 return 0;
}
</pre></div>
</div>
This code loads a Python script using <tt class="docutils literal">argv[1]</tt>, and calls the function named
in <tt class="docutils literal">argv[2]</tt>. Its integer arguments are the other values of the <tt class="docutils literal">argv</tt>
array. If you compile and link this program (let&#8217;s call the finished executable
call), and use it to execute a Python script, such as:
<div class="highlight-c"><div class="highlight"><pre>def multiply(a,b):
 print &quot;Will compute&quot;, a, &quot;times&quot;, b
 c = 0
 for i in range(0, a):
 c = c + b
 return c
</pre></div>
</div>
then the result should be:
<div class="highlight-c"><pre>$ call multiply multiply 3 2
Will compute 3 times 2
Result of call: 6</pre>
</div>
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
<div class="highlight-c"><div class="highlight"><pre>Py_Initialize();
pName = PyString_FromString(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
</pre></div>
</div>
After initializing the interpreter, the script is loaded using
<a title="PyImport_Import" class="reference external" href="../c-api/import.html#PyImport_Import"><tt class="xref docutils literal">PyImport_Import()</tt></a>. This routine needs a Python string as its argument,
which is constructed using the <a title="PyString_FromString" class="reference external" href="../c-api/string.html#PyString_FromString"><tt class="xref docutils literal">PyString_FromString()</tt></a> data conversion
routine.
<div class="highlight-c"><div class="highlight"><pre>pFunc = PyObject_GetAttrString(pModule, argv[2]);
/* pFunc is a new reference */

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

static PyMethodDef EmbMethods[] = {
 {&quot;numargs&quot;, emb_numargs, METH_VARARGS,
 &quot;Return the number of arguments received by the process.&quot;},
 {NULL, NULL, 0, NULL}
};
</pre></div>
</div>
Insert the above code just above the <tt class="xref docutils literal">main()</tt> function. Also, insert the
following two statements directly after <a title="Py_Initialize" class="reference external" href="../c-api/init.html#Py_Initialize"><tt class="xref docutils literal">Py_Initialize()</tt></a>:
<div class="highlight-c"><div class="highlight"><pre>numargs = argc;
Py_InitModule(&quot;emb&quot;, EmbMethods);
</pre></div>
</div>
These two lines initialize the <tt class="docutils literal">numargs</tt> variable, and make the
<tt class="xref docutils literal">emb.numargs()</tt> function accessible to the embedded Python interpreter.
With these extensions, the Python script can do things like
<div class="highlight-c"><div class="highlight"><pre>import emb
print &quot;Number of arguments&quot;, emb.numargs()
</pre></div>
</div>
In a real application, the methods will expose an API of the application to
Python.
</div>
<div class="section" id="embedding-python-in-c">
<h2>5.5. Embedding Python in C++<a class="headerlink" href="#embedding-python-in-c" title="Permalink to this headline">¶</a></h2>
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++.
</div>
<div class="section" id="linking-requirements">
<h2>5.6. Linking Requirements<a class="headerlink" href="#linking-requirements" title="Permalink to this headline">¶</a></h2>
While the configure script shipped with the Python sources will
correctly build Python to export the symbols needed by dynamically linked
extensions, this is not automatically inherited by applications which embed the
Python library statically, at least on Unix. This is an issue when the
application is linked to the static runtime library (<tt class="docutils literal">libpython.a</tt>) and
needs to load dynamic extensions (implemented as <tt class="docutils literal">.so</tt> files).
The problem is that some entry points are defined by the Python runtime solely
for extension modules to use. If the embedding application does not use any of
these entry points, some linkers will not include those entries in the symbol
table of the finished executable. Some additional options are needed to inform
the linker not to remove these symbols.
Determining the right options to use for any given platform can be quite
difficult, but fortunately the Python configuration already has those values.
To retrieve them from an installed Python interpreter, start an interactive
interpreter and have a short session like this:
<div class="highlight-c"><pre>&gt;&gt;&gt; import distutils.sysconfig
&gt;&gt;&gt; distutils.sysconfig.get_config_var('LINKFORSHARED')
'-Xlinker -export-dynamic'</pre>
</div>
The contents of the string presented will be the options that should be used.
If the string is empty, there&#8217;s no need to add any additional options. The
<tt class="xref docutils literal">LINKFORSHARED</tt> definition corresponds to the variable of the same name
in Python&#8217;s top-level <tt class="docutils literal">Makefile</tt>.
</div>
</div>

</div>
 </div>
 </div>
 <div class="sphinxsidebar">
 <div class="sphinxsidebarwrapper">
 <h3><a href="../contents.html">Table Of Contents</a></h3>
 <ul>
<li><a class="reference external" href="#">5. Embedding Python in Another Application</a><ul>
<li><a class="reference external" href="#very-high-level-embedding">5.1. Very High Level Embedding</a></li>
<li><a class="reference external" href="#beyond-very-high-level-embedding-an-overview">5.2. Beyond Very High Level Embedding: An overview</a></li>
<li><a class="reference external" href="#pure-embedding">5.3. Pure Embedding</a></li>
<li><a class="reference external" href="#extending-embedded-python">5.4. Extending Embedded Python</a></li>
<li><a class="reference external" href="#embedding-python-in-c">5.5. Embedding Python in C++</a></li>
<li><a class="reference external" href="#linking-requirements">5.6. Linking Requirements</a></li>
</ul>
</li>
</ul>

<h4>Previous topic</h4>
 <a href="windows.html"
 title="previous chapter">4. Building C and C++ Extensions on Windows</a>
 <h4>Next topic</h4>
 <a href="../c-api/index.html"
 title="next chapter">Python/C API Reference Manual</a>
<h3>This Page</h3>
<ul class="this-page-menu">
 <li><a href="../bugs.html">Report a Bug</a></li>
 <li><a href="../_sources/extending/embedding.txt"
 rel="nofollow">Show Source</a></li>
</ul>

<div id="searchbox" style="display: none">
 <h3>Quick search</h3>
 <form class="search" action="../search.html" method="get">
 <input type="text" name="q" size="18" />
 <input type="submit" value="Go" />
 <input type="hidden" name="check_keywords" value="yes" />
 <input type="hidden" name="area" value="default" />
 </form>
 
 Enter search terms or a module, class or function name.
 
 </div>
 <script type="text/javascript">$('#searchbox').show(0);</script>
 </div>
 </div>
 <div class="clearer"></div>
 </div>
 <div class="related">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="../genindex.html" title="General Index"
 >index</a></li>
 <li class="right" >
 <a href="../modindex.html" title="Global Module Index"
 >modules</a> |</li>
 <li class="right" >
 <a href="../c-api/index.html" title="Python/C API Reference Manual"
 >next</a> |</li>
 <li class="right" >
 <a href="windows.html" title="4. Building C and C++ Extensions on Windows"
 >previous</a> |</li>
 <li><img src="../_static/py.png" alt=""
 style="vertical-align: middle; margin-top: -1px"/></li>
 <li><a href="../index.html">Python v2.6.6 documentation</a> &raquo;</li>

<li><a href="index.html" >Extending and Embedding the Python Interpreter</a> &raquo;</li> 
 </ul>
 </div>
 <div class="footer">
 &copy; <a href="../copyright.html">Copyright</a> 1990-2011, Python Software Foundation.
 
 The Python Software Foundation is a non-profit corporation. 
 <a href="http://www.python.org/psf/donations/">Please donate.</a>
 
 Last updated on Jul 20, 2011.
 <a href="../bugs.html">Found a bug</a>?
 
 Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.6.6.
 </div>

</body>
</html>

Back to File Manager