pythonc++混合编程（怎样让Python脚本与C++程序互相调用）
本文目录
- 怎样让Python脚本与C++程序互相调用
- 我会Python，且第三方系统有接口，我应该如何通过Python去调用第三方系统的接口，进行对接
- c/c++扩展python，采用回调机制，怎么回传函数
- Python 与C++哪个适合初学者，哪个工资更好一点这两门语言的优缺点是什么
- python 可扩展主要体现
- 如何使Python嵌入C++应用程序
- 如何通过Boost.Python在Python中使用C++类和函数
- 如何实现C与python混合编程
- 请教高手，我在C/C++中嵌入python，用PyImport
怎样让Python脚本与C++程序互相调用
二、Python调用C/C++
1、Python调用C动态链接库
Python调用C库比较简单，不经过任何封装打包成so，再使用python的ctypes调用即可。
（1）C语言文件：pycall.c
view plain copy
/***gcc -o libpycall.so -shared -fPIC pycall.c*/
#include 《stdio.h》
#include 《stdlib.h》
int foo(int a, int b)
{
printf("you input %d and %d\n", a, b);
return a+b;
}
（2）gcc编译生成动态库libpycall.so：gcc -o libpycall.so -shared -fPIC pycall.c。使用g++编译生成C动态库的代码中的函数或者方法时，需要使用extern "C"来进行编译。
（3）Python调用动态库的文件：pycall.py
view plain copy
import ctypes
ll = ctypes.cdll.LoadLibrary
lib = ll("./libpycall.so")
lib.foo(1, 3)
print ’***finish***’
（4）运行结果：
2、Python调用C++(类)动态链接库
需要extern "C"来辅助，也就是说还是只能调用C函数，不能直接调用方法，但是能解析C++方法。不是用extern "C"，构建后的动态链接库没有这些函数的符号表。
（1）C++类文件：pycallclass.cpp
view plain copy
#include 《iostream》
using namespace std;
class TestLib
{
public:
void display();
void display(int a);
};
void TestLib::display() {
cout《《"First display"《《endl;
}
void TestLib::display(int a) {
cout《《"Second display:"《《a《《endl;
}
extern "C" {
TestLib obj;
void display() {
obj.display();
}
void display_int() {
obj.display(2);
}
}
（2）g++编译生成动态库libpycall.so：g++ -o libpycallclass.so -shared -fPIC pycallclass.cpp。
（3）Python调用动态库的文件：pycallclass.py
view plain copy
import ctypes
so = ctypes.cdll.LoadLibrary
lib = so("./libpycallclass.so")
print ’display()’
lib.display()
print ’display(100)’
lib.display_int(100)
（4）运行结果：
3、Python调用C/C++可执行程序
（1）C/C++程序：main.cpp
view plain copy
#include 《iostream》
using namespace std;
int test()
{
int a = 10, b = 5;
return a+b;
}
int main()
{
cout《《"---begin---"《《endl;
int num = test();
cout《《"num="《《num《《endl;
cout《《"---end---"《《endl;
}
（2）编译成二进制可执行文件：g++ -o testmain main.cpp。
（3）Python调用程序：main.py
view plain copy
import commands
import os
main = "./testmain"
if os.path.exists(main):
rc, out = commands.getstatusoutput(main)
print ’rc = %d, \nout = %s’ % (rc, out)
print ’*’*10
f = os.popen(main)
data = f.readlines()
f.close()
print data
print ’*’*10
os.system(main)
（4）运行结果：
4、扩展Python（C++为Python编写扩展模块）
所有能被整合或导入到其它python脚本的代码，都可以被称为扩展。可以用Python来写扩展，也可以用C和C++之类的编译型的语言来写扩展。Python在设计之初就考虑到要让模块的导入机制足够抽象。抽象到让使用模块的代码无法了解到模块的具体实现细节。Python的可扩展性具有的优点：方便为语言增加新功能、具有可定制性、代码可以实现复用等。
为 Python 创建扩展需要三个主要的步骤：创建应用程序代码、利用样板来包装代码和编译与测试。
（1）创建应用程序代码
view plain copy
#include 《stdio.h》
#include 《stdlib.h》
#include 《string.h》
int fac(int n)
{
if (n 《 2) return(1); /* 0! == 1! == 1 */
return (n)*fac(n-1); /* n! == n*(n-1)! */
}
char *reverse(char *s)
{
register char t, /* tmp */
*p = s, /* fwd */
*q = (s + (strlen(s) - 1)); /* bwd */
while (p 《 q) /* if p 《 q */
{
t = *p; /* swap & move ptrs */
*p++ = *q;
*q-- = t;
}
return(s);
}
int main()
{
char s;
printf("4! == %d\n", fac(4));
printf("8! == %d\n", fac(8));
printf("12! == %d\n", fac(12));
strcpy(s, "abcdef");
printf("reversing ’abcdef’, we get ’%s’\n", \
reverse(s));
strcpy(s, "madam");
printf("reversing ’madam’, we get ’%s’\n", \
reverse(s));
return 0;
}
上述代码中有两个函数，一个是递归求阶乘的函数fac()；另一个reverse()函数实现了一个简单的字符串反转算法，其主要目的是修改传入的字符串，使其内容完全反转，但不需要申请内存后反着复制的方法。
（2）用样板来包装代码
接口的代码被称为“样板”代码，它是应用程序代码与Python解释器之间进行交互所必不可少的一部分。样板主要分为4步：a、包含Python的头文件；b、为每个模块的每一个函数增加一个型如PyObject* Module_func()的包装函数；c、为每个模块增加一个型如PyMethodDef ModuleMethods的数组；d、增加模块初始化函数void initModule()。
我会Python，且第三方系统有接口，我应该如何通过Python去调用第三方系统的接口，进行对接
python因为良好的编码性和扩展库正被大规模的使用，但他有两个缺点：1、代码可见；2、执行效率低，于是在实际应用中经常会把高效和核心代码用C/C++实现，业务部分用python实现。这就需要进行混合编程，本文对python调用动态库的方法及注意事项进行记录
主题
python标准库函数中提供了调用动态库的包————ctypes
加载动态库
查找动态库ctypes.util.find_library
根据动态库调用方式的不同，可以分为cdecl和stdcall两种，这两种方式的主要区别见下表。后面的例子以cdecl调用方式为例，stdcall类同。
调用标准内存栈维护者函数名
cdecl调用者前面加下划线，后面加“@”符号和参数的字节数
stdcall被调用者在输出函数名前面加下划线
* ctypes加载动态库有两种方式。构造类对象libc = CDLL("libtestlib.dll")和实例化instancelibc = cdll.LoadLibrary("libtestlib.dll")。这两种方式都会返回一个动态库操作的句柄，
c/c++扩展python，采用回调机制，怎么回传函数
属于混合编程的问题。较全面的介绍一下，不仅限于题主提出的问题。以下讨论中，Python指它的标准实现，即CPython（虽然不是很严格）本文分4个部分C/C++调用Python（基础篇）—仅讨论Python官方提供的实现方式Python调用C/C++（基础篇）—仅讨论Python官方提供的实现方式C/C++调用Python（高级篇）—使用CythonPython调用C/C++（高级篇）—使用SWIG练习本文中的例子，需要搭建Python扩发环境。具体细节见搭建Python扩发环境-蛇之魅惑-知乎专栏1C/C++调用Python（基础篇）Python本身就是一个C库。你所看到的可执行体python只不过是个stub。真正的python实体在动态链接库里实现，在Windows平台上，这个文件位于%SystemRoot%\System32\python27.dll。
Python 与C++哪个适合初学者，哪个工资更好一点这两门语言的优缺点是什么
本人c++开发 python也会一些
对于初学者来说建议python 简单易学 前景也不错，现已延伸很多领域。使用量也大。
c++对于新手来说是非常难的不只是新手 ，就算是5年以上的老司机都经常掉坑。
工资的话python好像初始工资比c++高很多（c++老司机表示很不爽，钱这东西看来并不完全取决于语言难度）可能是国内稀缺吧，还有python开发效率非常高相比较c++开发效率就很低了。这样会为公司节省很大的成本。不过运行效率的话c++因为是编译语言所以是最高的。 现在是一个混合编程的时代。
python 可扩展主要体现
就算你的项目中有大量的Python代码,你也依旧可以有条不紊地通过将其分离为多个文件或模块加以组织管理。而且你可以从一个模块中选取代码，而从另一个模块中读取属性。更棒的是，对于所有模块，Python的访问语法都是相同的。不管这个模块是Python标准库中的还是你一分钟之前创造的，哪怕是你用其他语言写的扩展都没问题!借助这些特点，你会感觉自己根据需要“扩展”了这门语言，而且你已经这么做了。
代码中的瓶颈，可能是在性能分析中总排在前面的那些热门或者一些特别强调性能的地方，可以作为Python扩展用C重写。需要重申的是，这些接口和纯Python模块的接口是一模一样的，乃至代码和对象的访问方法也是如出一辙的。唯一不同的是，这些代码为性能带来了显著的提升。自然，这全部取决你的应用程序以及它对资源的需求情况。很多时候，使用编译型代码重写程序的瓶颈部分绝对是益处多多的，因为它能明显提升整体性能。
程序设计语言中的这种可扩展性使得工程师能够灵活附加或定制工具，缩短开发周期。虽然像C、C++乃至Java等主流第三代语言(3GL)都拥有该特性，但是这么容易地使用C编写扩展确实是Python的优势。此外，还有像PyRex这样的工具，允许C和Python混合编程，使编写扩展更加轻而易举，因为它会把所有的代码都转换成C语言代码。
因为Python的标准实现是使用C语言完成的(也就是CPython)，所以要使用C和C++编写Python扩展。Python 的Java实现被称作Jython,要使用Java编写其扩展。最后,还有IronPython,这是针对.NET或Mono平台的C#实现。你可以使用C#或者VB.Net扩展IronPython.
如何使Python嵌入C++应用程序
Python容易扩展和嵌入。Python提供的许多标准模块支持C或者C++接口。Python和C可以一起工作，它可以嵌入到C或者C++的应用程序当中，因此可用Python语言为应用程序提供脚本接口，由于支持跨语言开发。
可用Python设计概念化应用程序，并逐步移植到C，使用前不必用C重写应用程序。(Jython使Python可以和Java一起工作，使开发者可以在Python里面调Java的包，也可以在Java里面使用Python的对象。还有更妙的,由于Jython的解释器完全用Java编写，因此可以在支持Java的任何平台上部署Python程序，甚至WEB浏览器也可以直接运行Python脚本。)
提出问题在某个C++应用程序中，我们用一组插件来实现一些具有统一接口的功能，我们使用Python来代替动态链接库形式的插件，这样可以方便地根据需求的变化改写脚本代码，而不是必须重新编译链接二进制的动态链接库。Python强大的功能足以胜任，但是有一些操作系统特定的功能需要用C++来实现，再由Python调用。所以，最基础地，我们需要做到：
1. 把Python嵌入到C++应用程序中，在C++程序中调用Python函数和获得变量的值；
2. 用C++为Python编写扩展模块(动态链接库)，在Python程序中调用C++开发的扩展功能函数。
如何通过Boost.Python在Python中使用C++类和函数
（1）从Boost官方网站下载Boost库源文件，将其解压至某一目录中。
（2）将Boost解压至的目录添加到VC++ 6.0的【Include files】中，
（3）进入Boost目录下的“libs\python\build\VisualStudio”子目录中，在VC++ 6.0中打开其中的“boost_python.dsw”文件。
（4）单击【Build】|【Batch Build】命令，分别编译Boost.Python的Debug和Release版。
（5）编译完成后将在Boost目录下的“libs\python\build\bin-stage”子目录中生成动态链接库和库文件。由于使
用Boost.Python编写的Python扩展在运行时根据版本不同需要“boost_python.dll”和
“boost_python_debug.dll”文件。为了方便，可以将其放到Windows安装目录下的“system32”目录下。否则，需要将其
和Python扩展放在同一目录中。
（6）将Boost目录下的“libs\python\build\bin-stage”子目录添加到VC++ 6.0的【Library files】中，
完成上述设置后就可以使用Boost.Python编写Python扩展了。
使用Boost.Python扩展和嵌入Python
通过Boost.Python可以在Python内使用C++类和函数。和SWIG一样Boost.Python简化了编写Python扩展的代码，而不用使用Python/C API。但与SWIG不同，Boost.Python是一个类库，无需再使用接口文件。
初始化和方法列表
在Boost.Python中可以通过使用BOOST_PYTHON_MODULE来命名模块名。在BOOST_PYTHON_MODULE中则可以使用def来实现使用Python/C API定义的方法列表。以下是一个简单的例子。
void show()
声明show函数
{
cout 《《 "Boost.Python";
}
BOOST_PYTHON_MODULE(example)
使用BOOST_PYTHON_MODULE命名模块名为“example”
{
def("show",show);
相当于定义方法列表
以上就是对如何编译Boost.Python以及如何使用Boost.Python扩展和嵌入Python的相关的内容的介绍，望你会有所收获。
如何实现C与python混合编程
实现C与python混合编程方法
代码如下:
/* tcpportping.c */
#include 《Python.h》
#include 《string.h》
#include 《sys/types.h》
#include 《sys/socket.h》
#include 《netinet/in.h》
#include 《netdb.h》
#include 《sys/time.h》
/* count time functi*** */
static double mytime(void)
{
struct timeval tv;
if (gettimeofday(&tv, NULL) == -1)
return 0.0;
return (double)tv.tv_usec + (double)tv.tv_sec * 1000000;
}
static PyObject * /* returns object */
tcpping(PyObject *self, PyObject *args )
{
struct sockaddr_in addr;
struct hostent *hp;
double time;
char *host = NULL;
int fd;
int port, timeout;
if (!PyArg_ParseTuple(args, "sii", &host, &port, &timeout)) /* convert Python -》 C */
return NULL; /* null=raise exception */
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) 《 0) {
return Py_BuildValue("d", -1.0); /* convert C -》 Python */
}
bzero((char *)&addr, sizeof(addr));
if ((hp = gethostbyname(host)) == NULL) {
return Py_BuildValue("d", -2.0); /* convert C -》 Python */
}
bcopy(hp-》h_addr, &addr.sin_addr, hp-》h_length);
addr.sin_family = AF_INET;
addr.sin_port = ht***(port);
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = timeout * 1000;
double stime = mytime();
if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) 《 0) {
return Py_BuildValue("d", -3.0); /* convert C -》 Python */
}
fd_set read, write;
FD_ZERO(&read);
FD_ZERO(&write);
FD_SET(fd, &read);
FD_SET(fd, &write);
if (select(fd + 1, &read, &write, NULL, &tv) == 0) {
close(fd);
return Py_BuildValue("d", -4.0); /* convert C -》 Python */
}
double etime = mytime();
time = etime - stime;
if (!FD_ISSET(fd, &read) && !FD_ISSET(fd, &write)) {
close(fd);
return Py_BuildValue("d", -4.0); /* convert C -》 Python */
}
close(fd);
return Py_BuildValue("d", time/1000); /* convert C -》 Python */
}
/* registration table */
static struct PyMethodDef portping_methods = {
{"tcpping", tcpping, METH_VARARGS}, /* method name, C func ptr, always-tuple */
{NULL, NULL} /* end of table marker */
};
/* module initializer */
void inittcpportping( ) /* called on first import */
{ /* name matters if loaded dynamically */
(void) Py_InitModule("tcpportping", portping_methods); /* mod name, table ptr */
}
请教高手，我在C/C++中嵌入python，用PyImport
#include 《iostream》
#include 《Python.h》
using namespace std;
void HelloWorld();
void Add();
void TestTransferDict();
void TestClass();
int main()
{
cout 《《 "Starting Test..." 《《 endl;
cout 《《 "HelloWorld()-------------" 《《 endl;
HelloWorld();
cout 《《 "Add()--------------------" 《《 endl;
Add();
cout 《《 "TestDict-----------------" 《《 endl;
TestTransferDict();
cout 《《 "TestClass----------------" 《《 endl;
TestClass();
system("pause");
return 0;
}
//调用输出"Hello World"函数
void HelloWorld()
{
Py_Initialize(); //使用python之前，要调用Py_Initialize();这个函数进行初始化
PyObject * pModule = NULL; //声明变量
PyObject * pFunc = NULL; //声明变量
pModule =PyImport_ImportModule("Test001"); //这里是要调用的Python文件名
pFunc= PyObject_GetAttrString(pModule, "HelloWorld"); //这里是要调用的函数名
PyEval_CallObject(pFunc, NULL); //调用函数,NULL表示参数为空
Py_Finalize(); //调用Py_Finalize,这个和Py_Initialize相对应的.
}
//调用Add函数,传两个int型参数
void Add()
{
Py_Initialize();
PyObject * pModule = NULL;
PyObject * pFunc = NULL;
pModule =PyImport_ImportModule("Test001"); //Test001:Python文件名
pFunc= PyObject_GetAttrString(pModule, "add"); //Add:Python文件中的函数名
//创建参数:
PyObject *pArgs = PyTuple_New(2); //函数调用的参数传递均是以元组的形式打包的,2表示参数个数
PyTuple_SetItem(pArgs, 0, Py_BuildValue("i", 5));//0---序号 i表示创建int型变量
PyTuple_SetItem(pArgs, 1, Py_BuildValue("i", 7));//1---序号
//返回值
PyObject *pReturn = NULL;
pReturn = PyEval_CallObject(pFunc, pArgs); //调用函数
//将返回值转换为int类型
int result;
PyArg_Parse(pReturn, "i", &result); //i表示转换成int型变量
cout 《《 "5+7 = " 《《 result 《《 endl;
Py_Finalize();
}
//参数传递的类型为字典
void TestTransferDict()
{
Py_Initialize();
PyObject * pModule = NULL;
PyObject * pFunc = NULL;
pModule =PyImport_ImportModule("Test001"); //Test001:Python文件名
pFunc= PyObject_GetAttrString(pModule, "TestDict"); //Add:Python文件中的函数名
//创建参数:
PyObject *pArgs = PyTuple_New(1);
PyObject *pDict = PyDict_New(); //创建字典类型变量
PyDict_SetItemString(pDict, "Name", Py_BuildValue("s", "WangYao")); //往字典类型变量中填充数据
PyDict_SetItemString(pDict, "Age", Py_BuildValue("i", 25)); //往字典类型变量中填充数据
PyTuple_SetItem(pArgs, 0, pDict);//0---序号 将字典类型变量添加到参数元组中
//返回值
PyObject *pReturn = NULL;
pReturn = PyEval_CallObject(pFunc, pArgs); //调用函数
//处理返回值:
int size = PyDict_Size(pReturn);
cout 《《 "返回字典的大小为: " 《《 size 《《 endl;
PyObject *pNewAge = PyDict_GetItemString(pReturn, "Age");
int newAge;
PyArg_Parse(pNewAge, "i", &newAge);
cout 《《 "True Age: " 《《 newAge 《《 endl;
Py_Finalize();
}
//测试类
void TestClass()
{
Py_Initialize();
PyObject * pModule = NULL;
PyObject * pFunc = NULL;
pModule =PyImport_ImportModule("Test001"); //Test001:Python文件名
pFunc= PyObject_GetAttrString(pModule, "TestDict"); //Add:Python文件中的函数名
//获取Person类
PyObject *pClassPerson = PyObject_GetAttrString(pModule, "Person");
//创建Person类的实例
PyObject *pInstancePerson = PyInstance_New(pClassPerson, NULL, NULL);
//调用方法
PyObject_CallMethod(pInstancePerson, "greet", "s", "Hello Kitty"); //s表示传递的是字符串,值为"Hello Kitty"
Py_Finalize();
}
#test.py
def HelloWorld():
print "Hello World"
def add(a, b):
return a+b
def TestDict(dict):
print dict
dict = 17
return dict
class Person:
def greet(self, greetStr):
print greetStr
#print add(5,7)
#a = raw_input("Enter To Continue...")
结果：
配置：
注意两点：
若编译Debug版，请将C:/Python26/libs下的python26.lib复制一份改名为python26_d.lib
test.py 记得放项目的当前目录。
测试通过
