1. 首先实现一个特定原型的函数,用Python C API来实现的话,所有函数必须是这种原型。必须是类似这样的
PyObject *Fun(PyObject *self, PyObject *args)
self应该是在用类的时候才会用到(我没有用到),args就是函数的参数。因为args是一个PyObject*类型(可以代表Python语言中的任何类型)
2. 将参数转换成C 语言表示的内容,用PyArg_ParseTuple函数。
3. 执行完需要的操作后,也必须返回一个PyObject*类型的值。通过Py_BuildValue函数来构建。
这里要说的是,假如希望返回一个Tuple类型的值,可以先用
PyObject *tuple = Py_BuildValue("(iis)", 1, 2, "three")
形式来构建,假如很多的话,可以用下面的方式来构建
PyObject *t
t = PyTuple_New(3)
PyTuple_SetItem(t, 0, PyLong_FromLong(1L))
PyTuple_SetItem(t, 1, PyLong_FromLong(2L))
PyTuple_SetItem(t, 2, PyString_FromString("three"))
这一点在刚开始开工的时候迷惑了很久。
4. 将要输出的所有函数放入一个数组中,数组的结构是:
struct PyMethodDef {
const char*ml_name /* The name of the built-in function/method */
PyCFunction ml_meth /* The C function that implements it */
int ml_flags/* Combination of METH_xxx flags, which mostly
describe the args expected by the C func */
const char*ml_doc /* The __doc__ attribute, or NULL */
}
数组以{NULL, NULL}结束
5. 构造一个Python import时初始化的函数
类似
PyMODINIT_FUNC
initexample(void)
{
Py_InitModule("example", example_methods)
}
这里有个特别需要注意的是,初始化函数名字有严格要求,init后面必须跟模块名,否则Python找不到确定的函数会报没有初始化函数的错误
扩展模块写完后,编译成动态库(Python要求此动态库名字为pyd,实际就是改个后缀而已)。就可以直接在Python脚本中用import的方式加载了,对于使用来说,根本不需要知道此库是用C API扩展写的还是直接用Python语句写的(这点Lua做的也是一样好)
最后,python的源代码中附带了一个叫做example_nt的例子,可以参考一样,完整的扩展代码如下:
#include "Python.h"
static PyObject *
ex_foo(PyObject *self, PyObject *args)
{
printf("Hello, world/n")
Py_INCREF(Py_None)
return Py_None
}
static PyMethodDef example_methods[] = {
{"foo", ex_foo, METH_VARARGS, "foo() doc string"},
{NULL, NULL}
}
PyMODINIT_FUNC
initexample(void)
{
Py_InitModule("example", example_methods)
}
二.C语言中调用Python语句
首先,void Py_Initialize()用来初始化,void Py_Finalize()用来结束Python的调用,这是必须要的。
燃火分两种情况,假如仅仅是几条语句的话,那么以PyRun_为前缀的一些函数都很好用,比如
int PyRun_SimpleString(const char *command)
函数就可以直接执行一条char*的Python语句。
需要获得返回值得话
PyObject* PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals)
也很好用,以上两个函数用来处理Python源代码已经读入内存的情况,在文件中的时候
int PyRun_SimpleFile(FILE *fp, const char *filename)
PyObject* PyRun_File(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals)
使用类似。不多讲了。
假如是个模块的话(比如一个函数),希望在C语言中调用的话那么使用起来就稍微复杂了一点。这种情况的需要在于你可以从C语言中向Python函数中传入参数并且执行,然后获取结果。
此处又分为几种情况:
在文件中,在内存中,编译过的,源代码。
在文件中都很好解决,和上面一样。这里主要讲在内存中的情况。(事实上我工作中需要并且耗费了很长时间才找到解决方法的就是这种情况)
未编译时:(也就是源代码)
1.通过
PyObject* Py_CompileString(const char *str, const char *filename, int start)
API首先编译一次。此API的参数我说明一下,str就是内存中的源代码,filename主要是出错时报错误用的,事实测试证明,你随意给个字符串也没有关系,但给NULL参数在运行时必然报错。start我一般用的是Py_file_input,因为的确是从文件中读取过来的,相对的还有Py_single_input用来表示一条语句,Py_eval_input的用法我也不是太清楚。
源代码通过此函数调用后,获得编译后的PyObject*,(其实假如跟进源代码中去看,是一个PyCodeObject结构)假设命名为lpCode。
2.此时再调用API
PyObject* PyImport_ExecCodeModule(char *name, PyObject *co)
导入模块。参数也说明一下,name为导入的模块名,co就是前面编译过的代码对象(lpCode)。返回的就是模块对象了,假设命名为lpMod。
3.再调用API
PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name)
获得函数对象。o就是模块对象(lpMod),attr_name就是你想要调用的函数名了,假设叫main的函数,就是”main”,然后返回的就是函数对象,假设命名为lpFun。
4.此时可以用API
int PyCallable_Check(PyObject *o)
去检查一下是不是获得了一个函数。假如确定的话,就可以直接用
PyObject_Call开头的一族函数调用lpFun了。这些函数包括很多,一般就是输入参数的不同,但是效果都是一样的,就是调用函数而已。参数一般可以通过前面说过的build函数来获得,返回值也是获得一个PyObject*,可以通过PyArg_那个函数来获取,但是好像不太好,那是分析参数用的。推荐用确定类型(假设为type)的类似Py[type]_As的函数来获取。
比如:
long PyLong_AsLong(PyObject *pylong)获取long
double PyLong_AsDouble(PyObject *pylong)获取double
这里想说的是,应该有直接从源代码中获取函数调用对象的方式,但是我本人没有试出来,有人知道请一定赐教!
编译过的代码:
对于编译过的代码和上面就是获得编译后的PyCodeObject对象,当然在源代码中表示还是PyObject*的方法不同(上例中的lpCode)。
当然要想以后获得一个编译后的lpCode,自然要先编译一下啦。但是纯粹编译成pyc结尾的文件后,直接读入内存,我没有找到将其转化为PyCodeObject对象的方法(也希望有人知道能告诉我!)
我找到的方法是先用
PyObject* PyMarshal_WriteObjectToString(PyObject *value, int version)
void PyMarshal_WriteLongToFile(long value, FILE *file, int version)
两个函数先把PyCodeObject对象(lpCode)序列化到文件或者内存中。
再在需要的时候用函数
PyObject* PyMarshal_ReadObjectFromFile(FILE *file)
PyObject* PyMarshal_ReadObjectFromString(char *string, Py_ssize_t len)
读出来,读出来的PyObject*其实就是想要的PyCodeObject对象了(lpCode)。接下来的步骤与未编译时的步骤一样。
光是这个扭曲的方法我还是参考老总给的半边资料反复研究出来的。而真正直接有效的方法我还是没有找到。
Cython是Python的一个超集,结合了Python的易用性和原生代码的速度,可以编译成C语言,产生的性能提升可以从几个百分点到几个数量级,具体取决于手头的任务。
使用Cython,你可以避开Python的许多原生限制,或者完全超越Python,而无需放弃Python的简便性和便捷性。
Python代码可以直接调用C模块。这些C模块可以是通用的C库或专门为Python工作的库。Cython生成第二种类型的模块:与Python内部对话的C库,可以与现有的Python代码绑定在一起。
Cython代码在设计上看起来很像Python代码。如果你给Cython编译器提供了一个Python程序,它将会按原样接受它,但是Cython的原生加速器都不会起作用。但是如果你用Cython的特殊语法来修饰Python代码,那么Cython就可以用快速的C代替慢的Python对象。
请注意,Cython的方法是渐进的。这意味着开发人员可以从现有的Python应用程序开始,通过对代码立刻进行更改来加快速度,而不是从头开始重写整个应用程序。
这种方法通常与软件性能问题的性质相吻合。在大多数程序中,绝大多数CPU密集型代码都集中在一些热点上,也就是帕累托原则的一个版本,也被称为“80/20”规则。因此,Python应用程序中的大部分代码不需要进行性能优化,只需要几个关键部分。你可以逐渐将这些热点转换为Cython,从而获得你最需要的性能提升。程序的其余部分可以保留在Python中,以方便开发人员。
相关推荐:《Python入门教程》
Cython优势
除了能够加速已经编写的代码之外,Cython还具有其他几个优点:
使用外部C库可以更快
像NumPy这样的Python软件包可以在Python界面中打包C库,使它们易于使用。但是,这些包在Python和C之间来回切换会减慢速度。Cython可以让你直接与底层库进行通信,而不需要Python(也支持C ++库)。
可以同时使用C和Python内存管理
如果你使用Python对象,它们就像在普通的Python中一样被内存管理和垃圾收集。但是如果你想创建和管理自己的C级结构,并使用malloc/free来处理它们,你可以这样做,只记得自己清理一下。
可以根据需要选择安全性或速度
Cython通过decorator 和编译器指令(例如@boundscheck(False))自动执行对C中弹出的常见问题的运行时检查,例如对数组的超出边界访问。因此,由Cython生成的C代码默认比手动C代码安全得多。
如果确信在运行时不需要这些检查,则可以在整个模块上或仅在选择功能上禁用它们以获得额外的编译速度。
Cython还允许本地访问使用“缓冲协议”的Python结构,以直接访问存储在内存中的数据(无需中间复制)。Cython的“记忆视图”可以高速地在这些结构上进行工作,并且具有适合任务的安全级别。
Cython C代码可以从释放GIL中受益
Python的全局解释器锁(Global Interpreter Lock,GIL)同步解释器中的线程,保护对Python对象的访问并管理资源的争用。但GIL被广泛批评为Python性能的绊脚石,特别是在多核系统上。
如果有一段代码不会引用Python对象并执行长时间运行,那么可以使用nogil:指令将其标记为允许它在没有GIL的情况下运行。这使得Python中间人可以做其他事情,并允许Cython代码使用多个内核(附加工作)。
Cython可以使用Python类型的提示语法
Python有一个类型提示语法,主要由linters和代码检查器使用,而不是CPython解释器。 Cython有它自己的代码装饰的自定义语法,但是最近修改了Cython,你可以使用Python类型提示语法为Cython提供类型提示。
Cython限制
请记住,Cython不是一个魔术棒。它不会自动将每一个poky Python代码变成极速的C代码。为了充分利用Cython,你必须明智地使用它,并理解它的局限性:
常规Python代码的加速很少
当Cython遇到Python代码时,它不能完全翻译成C语言,它将这些代码转换成一系列对Python内部的C调用。这相当于将Python的解释器从执行循环中提取出来,这使得代码默认加速了15%到20%。请注意,这是最好的情况。在某些情况下,可能看不到性能改善,甚至性能下降。
原生Python数据结构有一点加速
Python提供了大量的数据结构 - 字符串,列表,元组,字典等等。它们对于开发者来说非常方便,而且他们自带了自动内存管理功能,但是他们比纯C慢。
Cython让你继续使用所有的Python数据结构,尽管没有太多的加速。这又是因为Cython只是在Python运行时调用创建和操作这些对象的C API。因此,Python数据结构的行为与Cython优化的Python代码大致相同:有时会得到一个提升,但只有一点。
Cython代码运行速度最快时,“纯C”
如果你在C中有一个标有cdef关键字的函数,那么它的所有变量和内联函数调用都是纯C的,所以它的运行速度可以和C一样快。 但是,如果该函数引用任何Python原生代码(如Python数据结构或对内部Python API的调用),则该调用将成为性能瓶颈。
幸运的是,Cython提供了一种方法来发现这些瓶颈:一个源代码报告,一目了然地显示您的Cython应用程序的哪些部分是纯C以及哪些部分与Python交互。 对应用程序进行了更好的优化,就会减少与Python的交互。
为Cython应用程序生成的源代码报告。 白色区域纯C;黄色区域显示与Python内部的交互。一个精心优化的Cython程序将尽可能的黄色。 展开的最后一行显示了解释其相应Cython代码的C代码。
Cython NumPy
Cython改进了基于C的第三方数字运算库(如NumPy)的使用。由于Cython代码编译为C,它可以直接与这些库进行交互,并将Python的瓶颈带出循环。
但是NumPy特别适用于Cython。 Cython对NumPy中的特定结构具有本地支持,并提供对NumPy数组的快速访问。在传统的Python脚本中使用的熟悉的NumPy语法可以在Cython中使用。
但是,如果要创建Cython和NumPy之间最接近的绑定,则需要使用Cython的自定义语法进一步修饰代码。例如,cimport语句允许Cython代码在编译时在库中查看C级构造,以实现最快的绑定。
由于NumPy被广泛使用,Cython支持NumPy“开箱即用”。如果你安装了NumPy,你可以在你的代码中声明cimport numpy,然后添加进一步的装饰来使用暴露的函数。
Cython分析和性能
可以通过分析代码并亲眼目睹瓶颈在哪里获得最佳性能。Cython为Python的cProfile模块提供钩子,因此可以使用Python自己的分析工具来查看Cython代码的执行情况。无需在工具组之间切换;可以继续所熟悉和喜爱的Python世界中工作。
它有助于记住所有情况下,Cython不是魔术,仍然适用明智的现实世界的表现实践。在Python和Cython之间来回穿梭越少,你的应用运行得越快。
例如,如果你有一个你想要在Cython中处理的对象的集合,那么不要在Python中迭代它,并且在每一步调用一个Cython函数。将整个集合传递给你的Cython模块并在那里迭代。这种技术经常在管理数据的库中使用,因此这是在自己的代码中模拟的好模型。
我们使用Python是因为它为程序员提供了便利,并且能够快速开发。有时程序员的工作效率是以牺牲性能为代价的。使用Cython,只需要一点点额外的努力就可以给你两全其美的好处。
在C++的库上面套一层wrapper就可以了。可以包装成CPython模块,也可以包装成C库然后用ctypes、cffi调用。
要对付主要是是C++的函数命名和类型。
包装CPython模块可以看手册里「Extending and Embedding」的部分。只要保证initMODULENAME(2.x)或PyInit_MODULENAME(3.x)是extern "C"的就行,手册里的例子用了PyMODINIT_FUNC这个宏,已经自动给加好了。
包装C库就是把所有函数都声明成extern "C"的,把传递的C++类型以C类型替代。举个例子
namespace enemy {
void first_blood(int id)
} // namespace enemy
void double_kill()
void double_kill(int killer)
class Silencer
{
public:
std::string watch_and_learn()
}
包装之后大概是这样的:
extern "C" {
void enemy_first_blood(int id)
{
enemy::first_blood(id)
}
void double_kill_by_roshan()
{
double_kill()
}
void double_kill_by_hero(int killer)
{
double_kill(killer)
}
void* new_silencer()
{
return new Sliencer
}
void silencer_watch_and_learn(void *instacne, char *buffer)
{
std::string what = reinterpret_cast<Silencer*>(instance)->watch_and_learn()
strcpy(buffer, what.c_str())
}
void release_silencer(void *instacne)
{
delete reinterpret_cast<Silencer*>(instance)
}
} // extern "C"