扩展类型（又名.cdef 类）

原文： http://docs.cython.org/en/latest/src/tutorial/cdef_classes.html

为了支持面向对象的编程，Cython 支持编写与 Python 完全相同的普通 Python 类：

  1. class MathFunction(object):
  2.     def __init__(self, name, operator):
  3.         self.name = name
  4.         self.operator = operator
  6.     def __call__(self, *operands):
  7.         return self.operator(*operands)

然而，基于 Python 所谓的“内置类型”，Cython 支持第二种类： 扩展类型 ，由于用于声明的关键字，有时也称为“cdef 类”。与 Python 类相比，它们受到一定限制，但通常比通用 Python 类更高效，速度更快。主要区别在于它们使用 C 结构来存储它们的字段和方法而不是 Python 字典。这允许他们在他们的字段中存储任意 C 类型，而不需要 Python 包装器，并且可以直接在 C 级访问字段和方法，而无需通过 Python 字典查找。

普通的 Python 类可以从 cdef 类继承，但不能从其他方面继承。 Cython 需要知道完整的继承层次结构，以便布局它们的 C 结构，并将其限制为单继承。另一方面，普通的 Python 类可以从 Cython 代码和纯 Python 代码中继承任意数量的 Python 类和扩展类型。

到目前为止，我们的集成示例并不是非常有用，因为它只集成了一个硬编码函数。为了解决这个问题，我们将使用 cdef 类来表示浮点数上的函数：

  1. cdef class Function:
  2.     cpdef double evaluate(self, double x) except *:
  3.         return 0

指令 cpdef 提供了两种版本的方法;一个快速使用从 Cython 和一个较慢的使用从 Python。然后：

  1. from libc.math cimport sin
  3. cdef class Function:
  4.     cpdef double evaluate(self, double x) except *:
  5.         return 0
  7. cdef class SinOfSquareFunction(Function):
  8.     cpdef double evaluate(self, double x) except *:
  9.         return sin(x ** 2)

这比为 cdef 方法提供 python 包装稍微多一点：与 cdef 方法不同，cpdef 方法可以被 Python 子类中的方法和实例属性完全覆盖。与 cdef 方法相比，它增加了一点调用开销。

为了使类定义对其他模块可见，从而允许在实现它们的模块之外进行有效的 C 级使用和继承，我们在sin_of_square.pxd文件中定义它们：

  1. cdef class Function:
  2.     cpdef double evaluate(self, double x) except *
  4. cdef class SinOfSquareFunction(Function):
  5.     cpdef double evaluate(self, double x) except *

使用它，我们现在可以更改我们的集成示例：

  1. from sin_of_square cimport Function, SinOfSquareFunction
  3. def integrate(Function f, double a, double b, int N):
  4.     cdef int i
  5.     cdef double s, dx
  6.     if f is None:
  7.         raise ValueError("f cannot be None")
  8.     s = 0
  9.     dx = (b - a) / N
  10.     for i in range(N):
  11.         s += f.evaluate(a + i * dx)
  12.     return s * dx
  14. print(integrate(SinOfSquareFunction(), 0, 1, 10000))

这几乎与前面的代码一样快，但是由于可以更改集成功能，因此它更加灵活。我们甚至可以传入 Python 空间中定义的新函数：

  1. >>> import integrate
  2. >>> class MyPolynomial(integrate.Function):
  3. ...     def evaluate(self, x):
  4. ...         return 2*x*x + 3*x - 10
  5. ...
  6. >>> integrate(MyPolynomial(), 0, 1, 10000)
  7. -7.8335833300000077

这比原始的仅使用 Python 的集成代码慢大约 20 倍，但仍然快 10 倍。这显示了当整个循环从 Python 代码移动到 Cython 模块时，加速可以很容易地变大。

关于evaluate新实施的一些注意事项：

  • 此处的快速方法调度仅起作用，因为Function中声明了evaluate。如果在SinOfSquareFunction中引入evaluate，代码仍然可以工作，但 Cython 会使用较慢的 Python 方法调度机制。
  • 以同样的方式，如果参数f没有被输入，但只是作为 Python 对象传递，那么将使用较慢的 Python 调度。
  • 由于参数是打字的，我们需要检查它是否是None。在 Python 中，当查找evaluate方法时，这会导致AttributeError，但 Cython 会尝试访问None的（不兼容的）内部结构，就像它是Function一样，导致崩溃或数据损坏。

有一个 编译器指令 nonecheck，它会以降低速度为代价启用此检查。以下是编译器指令用于动态打开或关闭nonecheck的方法：

  1. # cython: nonecheck=True
  2. #        ^^^ Turns on nonecheck globally
  4. import cython
  6. cdef class MyClass:
  7.     pass
  9. # Turn off nonecheck locally for the function
  10. @cython.nonecheck(False)
  11. def func():
  12.     cdef MyClass obj = None
  13.     try:
  14.         # Turn nonecheck on again for a block
  15.         with cython.nonecheck(True):
  16.             print(obj.myfunc())  # Raises exception
  17.     except AttributeError:
  18.         pass
  19.     print(obj.myfunc())  # Hope for a crash!

cdef 类中的属性与常规类中的属性的行为不同：

  • 所有属性必须在编译时预先声明
  • 属性默认只能从用 Cython 访问（类型化访问）
  • 属性可以声明为暴露的 Python 空间的动态属性
  1. from sin_of_square cimport Function
  3. cdef class WaveFunction(Function):
  5.     # Not available in Python-space:
  6.     cdef double offset
  8.     # Available in Python-space:
  9.     cdef public double freq
  11.     # Available in Python-space, but only for reading:
  12.     cdef readonly double scale
  14.     # Available in Python-space:
  15.     @property
  16.     def period(self):
  17.         return 1.0 / self.freq
  19.     @period.setter
  20.     def period(self, value):
  21.         self.freq = 1.0 / value