To call Python code in C, you must first initialize the interpreter, and then you can achieve interaction by executing strings, files, or calling specific functions. 1. Use Py_Initialize() to initialize the interpreter and close it with Py_Finalize(); 2. Use PyRun_SimpleString to execute string code or PyRun_SimpleFile to execute script files; 3. Import the module through PyImport_ImportModule, get the function through PyObject_GetAttrString, construct parameters of Py_BuildValue, call the function through PyObject_CallObject and process the return value; 4. Pay attention to version matching, path setting, reference count management and exception check. The entire process is structured clearly but requires careful handling of errors and resource management.
Calling Python code from C programs is not actually mysterious. The key is to use the C API provided by Python. As long as it is configured properly, you can create interpreters, execute scripts, and even pass parameters in C.

Initialize the Python interpreter
To call Python in C, the first step is to initialize the Python interpreter. This step is necessary, otherwise subsequent operations will fail.

- Use
Py_Initialize()
to start the interpreter - Remember to call
Py_Finalize()
after use to free the resource - If your program may be initialized and closed multiple times, you need to pay attention to thread safety issues (Python does not support multi-threaded embedding by default)
Sample code snippet:
#include <Python.h> int main() { Py_Initialize(); // ... The code that calls Python Py_Finalize(); return 0; }
Note: You need to link Python libraries when compiling, such as using the -lpython3.10
parameter (the specific version depends on the Python version you installed).

Execute a simple Python script or statement
Once initialization is complete, you can directly run a piece of Python string code, such as printing a sentence or defining a function.
- Using
PyRun_SimpleString
is the easiest way - It is suitable for executing some statements that do not require a return value
For example:
PyRun_SimpleString("print('Hello from Python!')");
If you want to go a step further, such as executing a .py
file, you can do this:
FILE* fp = fopen("script.py", "r"); if (fp) { PyRun_SimpleFile(fp, "script.py"); fclose(fp); }
This method is suitable for situations when you want to load the entire script file, but be careful whether the path is correct and whether the file is readable.
Call Python function and get the return value
If you want to call a specific Python function and get its return value, you need a slightly more complicated operation.
The steps are as follows:
- Import module: Use
PyImport_ImportModule
- Get function object: Use
PyObject_GetAttrString
- Construct parameters: Create tuple or other types using
Py_BuildValue
- Call function: Use
PyObject_CallObject
- Process the return value: Check whether it is NULL, and then extract the actual value
For example, suppose there is a file called math_utils.py
, with a function called add
:
# math_utils.py def add(a, b): return ab
C calls it as follows:
PyObject* pModule = PyImport_ImportModule("math_utils"); PyObject* pFunc = PyObject_GetAttrString(pModule, "add"); PyObject* pArgs = PyTuple_Pack(2, PyLong_FromLong(3), PyLong_FromLong(4)); PyObject* pResult = PyObject_CallObject(pFunc, pArgs); long result = PyLong_AsLong(pResult); // result == 7
This process is quite cumbersome, but the structure is clear. The key is to handle error checks at each step, such as determining whether pModule
is NULL to avoid crashes.
Frequently Asked Questions and Precautions
- Python version matching : Make sure your C compile environment is linked to the correct Python version, otherwise compatibility issues may occur.
- Path settings : If the Python script is not in the current directory, you may need to set the search path through
PySys_SetPath
. - Reference Count Management : Python uses the reference counting mechanism, remember to increase or decrease references appropriately to avoid memory leaks.
- Exception handling : It is best to check whether any exceptions occur after each call to the Python API. You can use
PyErr_Occurred()
to judge.
Basically that's it. Although it seems a bit troublesome, as long as you follow the process step by step, you can successfully implement the function of C calling Python.
The above is the detailed content of How to call Python from C ?. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

A common method to traverse two lists simultaneously in Python is to use the zip() function, which will pair multiple lists in order and be the shortest; if the list length is inconsistent, you can use itertools.zip_longest() to be the longest and fill in the missing values; combined with enumerate(), you can get the index at the same time. 1.zip() is concise and practical, suitable for paired data iteration; 2.zip_longest() can fill in the default value when dealing with inconsistent lengths; 3.enumerate(zip()) can obtain indexes during traversal, meeting the needs of a variety of complex scenarios.

ForwardreferencesinPythonallowreferencingclassesthatarenotyetdefinedbyusingquotedtypenames.TheysolvetheissueofmutualclassreferenceslikeUserandProfilewhereoneclassisnotyetdefinedwhenreferenced.Byenclosingtheclassnameinquotes(e.g.,'Profile'),Pythondela

Processing XML data is common and flexible in Python. The main methods are as follows: 1. Use xml.etree.ElementTree to quickly parse simple XML, suitable for data with clear structure and low hierarchy; 2. When encountering a namespace, you need to manually add prefixes, such as using a namespace dictionary for matching; 3. For complex XML, it is recommended to use a third-party library lxml with stronger functions, which supports advanced features such as XPath2.0, and can be installed and imported through pip. Selecting the right tool is the key. Built-in modules are available for small projects, and lxml is used for complex scenarios to improve efficiency.

In C, the lambda capture clause controls how external variables are introduced into the lambda function through values, references, or default patterns. 1. The capture list is at the beginning of the lambda expression and is used to capture variables in the external scope for internal use of the lambda. 2. The variable will be copied through value capture ([var]). Modifications in the lambda will not affect the original variable. If you need to modify the copy, you need to use the mutable keyword. 3. By reference capture ([&var]) allows lambda to directly modify the original variable, but there is a risk of dangling references. 4. Default capture mode [=] automatically captures all used variables by value, [&] automatically captures by reference, but should be used with caution to avoid potential errors.

When multiple conditional judgments are encountered, the if-elif-else chain can be simplified through dictionary mapping, match-case syntax, policy mode, early return, etc. 1. Use dictionaries to map conditions to corresponding operations to improve scalability; 2. Python 3.10 can use match-case structure to enhance readability; 3. Complex logic can be abstracted into policy patterns or function mappings, separating the main logic and branch processing; 4. Reducing nesting levels by returning in advance, making the code more concise and clear. These methods effectively improve code maintenance and flexibility.

The descriptor protocol is a mechanism used in Python to control attribute access behavior. Its core answer lies in implementing one or more of the __get__(), __set__() and __delete__() methods. 1.__get__(self,instance,owner) is used to obtain attribute value; 2.__set__(self,instance,value) is used to set attribute value; 3.__delete__(self,instance) is used to delete attribute value. The actual uses of descriptors include data verification, delayed calculation of properties, property access logging, and implementation of functions such as property and classmethod. Descriptor and pr

A common way to verify that JSON data complies with a specific structure is to use the jsonschema library. 1. Install the library: pipinstalljsonschema; 2. Define the schema to describe the expected structure; 3. Use the validate function to verify the data. If it does not match, an exception will be thrown. Common considerations include field type matching, required fields exist, correct description of nested structures, and default values ??will not be automatically filled. Alternatives are Pydantic and fastjsonschema, which are suitable for complex models or scenarios with high performance requirements. Pay attention to the consistency between schema writing and data during operation.

Classes in Python are blueprints for creating objects, which contain properties and methods. 1. An attribute is a variable belonging to a class or its instance, used to store data; 2. A method is a function defined in a class, describing the operations that an object can perform. By calling the class to create an object, for example, my_dog=Dog("Buddy"), Python will automatically call the constructor __init__init__init object. Reasons for using classes include code reusability, encapsulation, abstraction, and effective modeling of real-world entities. Classes help keep the code clear and maintainable when building complex systems.
