扩展类的成员函数

我们之前介绍了定义函数的三个关键字，分别是 def, cdef 和 cpdef。def 定义的就是纯 Python 函数，可以被外界访问，但是性能不足；cdef 定义的是高性能的 C 函数，但是无法被外界访问。

而 cpdef 定义的函数既可以在 Cython 内部访问，也可以被外界访问，因为它相当于定义了两个版本的函数：一个是高性能的纯 C 版本，另一个是 Python 包装器（相当于我们手动定义的 Python 函数）。所以这就要求使用 cpdef 定义的函数的参数和返回值类型必须是 Python 可以表示的，像 char * 之外的指针就不行。

同理，def, cdef 和 cpdef 也可以定义扩展类的成员函数，其表现和定义普通函数是一样的。但是注意：cdef 和 cpdef 修饰的成员函数必须位于 cdef class 定义的扩展类里面，如果是 class 定义的动态类，那么成员函数只能用 def 定义。

cdef class A:
    cdef public:
        Py_ssize_t a, b
    def __init__(self, a, b):
        self.a = a
        self.b = b
    
    # cdef 修饰
    cdef Py_ssize_t f1(self):
        return self.a * self.b
    
    # cpdef 修饰
    cpdef Py_ssize_t f2(self):
        return self.a * self.b

文件名为 cython_test.pyx，我们编译测试一下：

import pyximport
pyximport.install(language_level=3)
import cython_test
a = cython_test.A(3, 5)
print(a.f2()) 
"""
15
"""
try:
    a.f1()
except AttributeError as e:
    print(e)
"""
'cython_test.A' object has no attribute 'f1'
"""

f1 是 cdef 定义的，所以它无法被外界访问，cdef 和 cpdef 之间在函数上的差异，在方法中得到了同样的体现。

此外，这个类的实例也可以作为函数的参数，这是肯定的。

cdef class A:
    cdef public:
        Py_ssize_t a, b
    def __init__(self, a, b):
        self.a = a
        self.b = b
    cpdef Py_ssize_t f2(self):
        return self.a * self.b
    
def traverse(ins_lst):
    s = 0
    for ins in ins_lst:
        s += ins.f2()
    return s

测试一下：

import pyximport
pyximport.install(language_level=3)
import cython_test
a1 = cython_test.A(1, 2)
a2 = cython_test.A(2, 4)
a3 = cython_test.A(2, 3)
print(
    cython_test.traverse([a1, a2, a3])
)  # 16

这就是是 Python 的特性，一切都是对象，尽管没有指明 ins_lst 指向什么类型，但只要它可以被 for 循环即可。尽管没有指明 ins_lst 里面的元素指向什么类型，只要它有 f2 方法即可。

并且这里的 traverse 函数可以在 Cython 中定义，同样也可以在 Python 中定义，这两者是没有差别的，因为都是 Python 中的函数。另外在遍历的时候仍然需要确定 ins_lst 里面的元素，意味着里面的元素仍然是 PyObject *，它需要获取类型、转化、属性查找，因为 Cython 不知道类型是什么、导致其无法优化。但如果我们规定了类型，那么再调用 f2 的时候，会直接指向 C 一级的数据结构，因此不需要那些无用的检测。

# 规定接收一个 list，返回一个 Py_ssize_t
# 它们都是静态的，总之静态类型越多，速度会越快
cpdef Py_ssize_t traverse(list ins_lst):
    # 声明 Py_ssize_t 类型的 s，A 类型的 ins
    cdef Py_ssize_t s = 0
    cdef A ins
    for ins in ins_lst:
        s += ins.f2()
    return s

调用得到的结果是一样的，可以自己尝试一下。这样的话速度会变快很多，因为我们在循环的时候，规定了变量类型，并且求和也是一个只使用 C 的操作，因为 s 是一个 Py_ssize_t。

这个版本的速度比之前快了 10 倍，这表明类型化比非类型化要快了 10 倍。如果我们删除了 cdef A self，也就是不规定类型，而还是按照 Python 的语义来调用，那么速度仍然和之前一样，即便使用 cpdef 定义。

所以重点在于指定类型为静态类型，只要规定好类型，让变量具体指向 C 一级的数据结构，那么就可以提升速度。如果是 int 和 float，那么 Cython 会自动采用 C 的 int 和 float，这样速度能进一步提升，当然怕溢出的话就使用 size_t, Py_ssize_t, double 等类型。

因此重点是一定要静态定义类型，只要类型明确，那么就能进行大量的优化。

前面说过 Python 慢主要有两个原因，一个是它无法对类型进行优化，另一个是对象分配在堆上。

1）无法基于类型进行优化，就意味着每次都要进行大量的检测，如果规定好类型，那么就不用兜那么大圈子了；

2）对象分配在堆上这是无法避免的，只要你用 Python 的对象，都是分配在堆上。当然你可以用 C++ 中的结构进行替换，但这会增加代码的复杂度，而且也不像是写 Python 了。但是对于整型和浮点型，我们可以通过 cdef 将其声明为 C 的类型，使对象分配在栈上，进一步提升效率。

总之记住一句话：Cython 加速的关键就在于，类型的静态声明，以及将整型和浮点型换成 C 的类型。

成员函数中的参数类型

无论是 def、cdef、cpdef 定义的是普通函数，还是类的成员函数，它们的表现都是一致的，都是函数。所以在定义的时候，都可以给参数规定类型，如果类型传递的不对就会报错。

比如上面的 traverse 函数，如果不规定参数类型，那么参数只要能够被 for 循环即可，所以它可以是列表、元组、集合。但是我们上面规定了是 list 类型，那么参数只能传递 list 对象或者其子类的实例对象，如果传递 tuple 对象就会报错。

这里我们来看一下 __init__。

cdef class A:
    cdef public:
        Py_ssize_t a, b
    def __init__(self, float a, float b):
        self.a = a
        self.b = b

这里我们规定了类型，但是有没有发现什么问题呢？这里的参数 a 和 b 必须是一个 float，如果传递的是其它类型会报错，但是赋值的时候 self.a 和 self.b 又需要接收一个 Py_ssize_t，所以这是一个自相矛盾的死结，在编译的时候就会报错。因此给 __init__ 参数传递的值的类型，要和类中使用 cdef 声明的类型保持一致。

即使在类里面，cpdef 仍然不支持闭包。

以上就是类的成员函数，和普通函数的表现是一致的。但是扩展类的内容还没有结束，为了更好地解释 Cython 带来的性能改进，后续我们将了解关于继承、子类化、和扩展类型的多态性相关的知识。