Cython的类型
1 类型定义
1.1 定义一个C变量：
1.1.1 在Cython里定义一个C变量和C语言类似，不同的地方就是在声明的最前面要加上cdef,另外，末尾不用加分号";“如：
cdef int an[10]
cdef int n = 123
cdef int *pn = &n
printf("%d ",pn[0])
1.1.2 这里要注意的是，以Cython里不能用类似*ptr这样代码来对指针变量进行取值，而必须用ptr[0]这样的形式，如上面的例子中，printf("%d ",*pn)是编译通不过的
1.2 定义一个Python对象
1.2.1 和Python没有区别，直接给一个变量名赋值即可，如：
b = [1,2,3]
a = 'hello,world'
1.2.2 每个变量名实现上都是一个Python对象指针
2 类型转换
2.1 在Cython里用<>替代了()来进行类型转换，如：
cdef float a= 123.456
cdef int b
b = <int>a
2.2 再如：
cdef int n
a = 'hello,world'
n = <int>a
2.2.1 这里要注意的是：n = <int>a 把一个Python字符串对象指针强制转换成了一个整形变量，这在封装回调函数时经常会用到强制将一个Python对象指针强制转换成C类型的情况。
Cython的函数
1 函数定义：
1.1 在Cython里定义一个类C函数：
1.1.1 在这里之所以说是定义一个"类C”函数，而不是一个C函数，是因为它和纯C函数的定义还是有区别的，具体看下面的例子：
1.1.2 例1：
if a>b:
return a
else:
return b
可见，定义一个C函数和纯C还是比较相似的
但是语法却是遵循python的语法
1.1.3 再来看成一个比较怪异的例子，例2：
cdef Max(int a,b):
if a>b:
return a
else:
return b
这个例子就有点怪了，牛不是牛，马不像马，还是从翻译出来的c代码中去找答案吧：
先创建一个test.pyx
cdef Max(int a,b):
if a>b:
return a
else:
return b
再转成C代码：
cython -o test.c test.pyx
打开test.c，搜索cdef Max定义到下面的代码：
/* "test.pyx":1
* cdef Max(int a,b): #<<<<<<<<<<<<<<
* if a>b:
* return a
*/
static PyObject *__pyx_f_4test_Max(int __pyx_v_a, PyObject *__pyx_v_b) {
...
总结一下：
如果一个函数的参数或者返回值没有指定类型，那么它就是一个python对象，在进行操作时会将python对象转换成相应的C类型
如果参数或者返回值指定了类型，那么不会进行任何转换
1.1.4 再来看一个例子，例3
cdef object Max(int a,object b):
if a>b:
return a
else:
return b
和上一个例子不同的地方就是加了object关键，这表明这是一个python对象
它其实和上面生成的C代码是一样的，
这也验证了上面那个例子的理解是正确的
1.1.5 一个问题，如何在C代码里调用Cython里定义的C函数呢？
有时候，我们不仅仅是需要在Python代码里调用C代码，还有可能需要在Cython之外中的C代码里里调用Python的代码，
而我们知道，在Cython里定义的C函数是可以直接调用Python代码的
这样,可以通过在Cython外的C函数里调用Cython里定义的C函数来达到在C代码里调用Python代码的目的
但是，从上面的例子来看，经过Cython的翻译之后，函数名称被改变了，并且函数是static的，对外不可见，是不是无法调用？
答案很否定的，只要将Cython中定义的C函数声明为public或者extern即可，具体的来例子：
cdef public int Max(int a,int b):
if a>b:
return a
else:
return b
用Cython翻译成C代码后：
* cdef public int Max(int a,int b): #<<<<<<<<<<<<<<
* if a>b:
* return a
*/
int Max(int __pyx_v_a,int __pyx_v_b) {
...
这样，这个函数就可以另外的C代码中补调用了。
但是，调用是可以调用，但是如果这个C函数里又调用了Python代码的话，在C代码里直接调用这个函数，程序会崩溃，这个另外的篇幅中再详细的讨论。
1.2 在Cython里定义一个类Python函数：
1.2.1 和类C函数的定义相似，只是以def开头，而不是以cdef开头
1.2.2 不同的地方是不能指定返回值的类型，这个很好理解，Python的函数肯定返回的是一个Python对象了，不可能返回一个C类型
1.2.3 即使你在Python里没有调用return，或者没有return一个对象，Python也默认会返回一个None对象
2 让类C函数在出错时抛出异常
2.1 这里有两种出错的情况
2.1.1 一种是C函数返回一个错误值
2.1.2 另外一种情况就是C函数里调用的Python代码出现的异常
2.2 首先来看一个例子：
cdef int ExceptTest(int n):
a = "abc"
print a.length()
return n
def CallExceptTest(intn):
return ExceptTest(n)
2.2.1 这里故意调用了一个字符串对象不存在的方法length
Subtopic
2.2.2 运行例子：
>>> import test
>>> test.CallExceptTest(-1)
Exception AttributeError: "'str'object has no attribute 'length'" in 'test.ExceptTest' ignored
0
2.2.3 可见错误被忽略了
2.3 如何让C函数抛出异常呢？还是先看例子：
import traceback
import sys
cdef int ExceptTest() except -1:
a = "abc"
print a.length()
return 1
def CallExceptTest():
try:
ExceptTest()
except Exception:
print "Exceptionin user code:"
traceback.print_exc(file=sys.stdout)
2.3.1 这个例子比上个例子在函数的声明时加上了 except -1
2.3.2 意思是异常产生时返回-1
2.3.3 测试一下：
>>> import test;test.CallExceptTest()
Exception in user code:
Traceback (most recent call last):
File "test.pyx", line 14,in test.CallExceptTest (test.c:809)
ExceptTest()
File "test.pyx", line 9,in test.ExceptTest (test.c:718)
print a.length()
AttributeError: 'str' object has noattribute 'length'
>>>
可见，这可比上个例子中只打印只一句冷冰冰的ignore好多了
通过异常时打出来的堆栈信息，可以定位到具体在test.pyx的哪一行出的错
这是不是比没有延时异常时好多了？
2.4 再来看下如果不是在C函数中调用的Python中出错会怎样：
import traceback
import sys
cdef int ExceptTest() except -1:
return -1
def CallExceptTest():
try:
ExceptTest()
except Exception:
print "Exceptionin user code:"
traceback.print_exc(file=sys.stdout)
2.4.1 这个例子中直接返了了-1
2.4.2 测试一下：
>>> importtest;test.CallExceptTest()
Traceback (most recent call last):
File "<stdin>", line1, in <module>
SystemError: errorreturn without exception set
2.4.3 直接抛出了一个SystemError，也没有堆栈信息输出
2.5 问题：有没有办法只要想在C函数中调用Python代码出错时抛出异常呢
2.5.1 答案当然是肯定的，在编程的世界里，永远都是只有想不到的，没有做不到的，
2.5.2 只要将except -1改成except? -1即可，
2.5.3 这样Cython就会在函数返回-1时调用PyErr_Occurred()来判断是否真的有一个异常产生，从而避免上个例子中出现的情况。
2.6 如果函数是void型，没有返回值，怎么让函数返回异常?
2.6.1 很简单，用except* 即可
如 cdef void Test() except*
Cython应用手记
作者: 日期:
| gashero |
| 2010-03-29 |
目录
- 1 简介
- 2 基本使用
- 3 调用其他C库
- 3.1 简单例子
- 3.2 重新定义外部C库的定义
- 4 类定义
- 5 与Python交互
1 简 介
一种为Python写C扩展的方式，尝试一下。
参考文献：
- [r] 官方主页： http://www.cython.org/
- [r] Cython三分钟入门： http://blog.csdn.net/lanphaday/archive/2009/09/17/4561611.aspx
- [u] A quick Cython introduction： http://www.perrygeo.net/wordpress/?p=116 其实就是上文的原文
- [i] Cython's Documentation： http://docs.cython.org/ 看到"Extensioin types"
2 基 本使用
Cython基于pyrex，但是拥有更多功能和优化。用来写Python的C扩展的，并生成有效的C代码。写出的文件扩展名是 ".pyx" ，已经可以算作一种语言了。
一个简单的加法函数( addtest.pyx ):
def addtest(a,b):
cdef float c=a+b
return c
编译和生成动态库:
cython addtest.pyx gcc -c -fPIC -I/usr/include/python2.5 addtest.c gcc -shared addtest.o -o addtest.so
使用:
$ python >>> import addtest >>> addtest(1,2) 3.0
构建Cython代码的方式：
- 使用 setup.py ，常用
- 使用pyximport导入 ".pyx" 文件
- 运行cython命令编译出.c文件后再编译成.so文件
- 使用Sage
使用 setup.py 方式，例如一个 hello.pyx 文件，编写的 setup.py 如下:
from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext
ext_modules=[Extension('hello',['hello.pyx'])]
setup(
name='Hello world app',
cmdclass={'build_ext':build_ext},
ext_modules=ext_modules
)
构建使用命令 python setup.py build_ext --inplace 。
Cython提高速度的主要原因是使用静态类型。可以在任何参数前直接使用C的类型定义。函数内的话要加"cdef"前缀。如:
def f(double x):
cdef double ret
ret=x**2-x
return ret
仅仅使用Cython编译纯Python代码可以提高35%的性能，几乎全部使用静态类型以后提高4倍。
C风格函数声明，"except? -2"表示返回-2时就是出错了。不过"except *"是肯定安全的。如:
cdef double f(double) except? -2:
return x**2-x
使用cpdef时，这个函数就可以同时被C和Python调用了。当使用了C函数时，因为避开了昂贵的函数调用，旺旺可以提高150倍的速度。
不要过度优化，一步步的优化并且查看profile。使用"cython -a"参数可以查看HTML报告。
3 调 用其他C库
3.1 简 单例子
导入"math.h"中的 sin() 函数并使用:
cdef extern from "math.h":
double sin(double)
cdef double f(double x):
return sin(x*x)
Cython不会去扫描头文件，所以自己必须再声明一遍。下面是使用时必须连接上其他库的 setup.py 文件:
from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext
ext_modules=[
Extension('demo',['demo.pyx',],libraries=['m',])
]
setup(
name='Demos',
cmdclass={'build_ext':build_ext},
ext_modules=ext_modules,
)
同理可以使用任何动态或静态编译的库。
3.2 重 新定义外部C库的定义
一段C代码，头文件中的类型定义与函数声明:
typedef struct _Queue Queue; typedef void *QueueValue; Queue *queue_new(void); void queue_free(Queue *queue); int queue_push_head(Queue *queue, QueueValue data); QueueValue queue_pop_head(Queue *queue); QueueValue queue_peek_head(Queue *queue); int queue_push_tail(Queue *queue, QueueValue data); QueueValue queue_pop_tail(Queue *queue); QueueValue queue_peek_tail(Queue *queue); int queue_is_empty(Queue *queue);
对应的Cython定义，写入一个".pxd"文件中:
cdef extern from "libcalg/queue.h":
ctypedef struct Queue:
pass
ctypedef void* QueueValue
Queue* new_queue()
void queue_free(Queue* queue)
int queue_push_head(Queue* queue, QueueValue data)
QueueValue queue_pop_head(Queue* queue)
QueueValue queue_peek_head(Queue* queue)
int queue_push_tail(Queue* queue, QueueValue data)
QueueValue queue_pop_tail(Queue* queue)
QueueValue queue_peek_tail(Queue* queue)
bint queue_is_empty(Queue* queue)
大部分时候这种声明与头文件几乎是一样的，你可以直接拷贝过来。唯一的区别在最后一行，C函数的返回值其实是布尔值，所以用bint类型会转换成 Python的布尔值。
这里可以不关心结构体的内容，而只是用它的名字。
4 类 定义
一个类的例子:
cimport cqueue
cimport python_exc
cdef class Queue:
cdef cqueue.Queue_c_queue
def __cinit__(self):
self._c_queue=cqueue.new_queue()
这里的构造函数是 __cinit__() 而不是 __init__() 。虽然 __init__() 依然有效，但是并不确保一定会运行(比如子类忘了调用基类的构造函数)。因为未初始化的指针经常导致Python挂掉而没有任何提示，所以 __cinit__() 总是会在初始化时调用。不过其被调用时，对象尚未构造完成，所以除了cdef字段以外，避免其他操作。如果要给__cinit__() 构造和函数加参数，必须与 __init__() 的匹配。
构造函数初始化资源时记得看看返回的资源是否是有效的。如果无效可以抛出错误。Cython提供了内存不足异常，如下:
def __cinit__(self):
self._c_queue=cqueue.new_queue()
if self._c_queue is NULL:
python_exc.PyErr_NoMemory()
Cython提供的析构函数，仅在建立成功内部对象时释放内部对象:
def __dealloc__(self):
if self._c_queue is not NULL:
cqueue.queue_free(self._c_queue)
将数据以通用指针方式进入，和返回时的强制类型转换:
cdef append(self,int value):
cqueue.queue_push_tail(self._c_queue,<void*>value)
cdef int pop(self):
return <int>cqueue.queue_pop_head(self._c_queue)
Cython除了支持普通Python类以外，还支持扩展类型，使用"cdef class"定义。在内存占用和效率上更好。因为使用C结构体存储字段和方法，而不是Python字典。所以可以存储任意C字段类型，而不是其 Python包装。访问时也是直接访问C的值，而不是通过字典查找。
普通的Python类可以继承自cdef类，但是反之则不行。Cython需要知道完整的继承层次来定义C结构体，并且严格限制单继承。不过普通 Python类可以继承任一数量的Python类和扩展类型，无论在Python中还是在Cython代码中。
5 与 Python交互
如果Cython调用Python函数失败，则直接返回NULL，而不是异常对象。
如果一个函数既有可能返回NULL，也有可能返回0，则处理起来就比较麻烦。Python C API的做法是PyErr_Occurred() 函数。不过这种方式有性能损耗。在Cython中你可以自己指定哪个返回值代表错误，所以环境只要检查这个返回值即可。其他所有值都回无损耗的被接受。
在函数定义时指定except子句，则仅在函数返回该值时检查是否需要抛出异常。这样同一个函数返回0和返回0同时返回错误就可以区分开。例子:
cdef int pop(self) except? 0:
#...
类中的 cdef 定义C方法，而 cpdef 可以同时定义C方法和Python方法。