The declaration of in_mandel() in the csample.pxd file has an interesting, but subtle

definition. In that file, the function is declared as returning a bint instead of an int.

This causes the function to create a proper Boolean value from the result instead of a

simple integer. So, a return value of 0 gets mapped to False and 1 to True.

``in_mandel()`` 的声明

Within the Cython wrappers, you have the option of declaring C data types in addition

to using all of the usual Python objects. The wrapper for divide() shows an example

of this as well as how to handle a pointer argument.

def divide(x,y):

cdef int rem

quot = csample.divide(x,y,&rem)

return quot, rem

Here, the rem variable is explicitly declared as a C int variable. When passed to the

underlying divide() function, &rem makes a pointer to it just as in C.

The code for the avg() function illustrates some more advanced features of Cython.

First the declaration def avg(double[:] a) declares avg() as taking a one-dimensional

memoryview of double values. The amazing part about this is that the resulting function

will accept any compatible array object, including those created by libraries such as

numpy. For example:

>>> import array

>>> a = array.array('d',[1,2,3])

>>> import numpy

>>> b = numpy.array([1., 2., 3.])

>>> import sample

>>> sample.avg(a)

>>> sample.avg(b)

>>>

In the wrapper, a.size and &a[0] refer to the number of array items and underlying

pointer, respectively. The syntax <double *> &a[0] is how you type cast pointers to a

from cpython.pycapsule cimport *

from libc.stdlib cimport malloc, free

The function del_Point() and Point() use this functionality to create a capsule object

that wraps around a Point * pointer. The declaration cdef del_Point() declares

del_Point() as a function that is only accessible from Cython and not Python. Thus,

this function will not be visible to the outside—instead, it’s used as a callback function

to clean up memory allocated by the capsule. Calls to functions such as PyCap

sule_New(), PyCapsule_GetPointer() are directly from the Python C API and are used

in the same way.

The distance() function has been written to extract pointers from the capsule objects

created by Point(). One notable thing here is that you simply don’t have to worry about

exception handling. If a bad object is passed, PyCapsule_GetPointer() raises an ex‐

ception, but Cython already knows to look for it and propagate it out of the dis

tance() function if it occurs.

A downside to the handling of Point structures is that they will be completely opaque

in this implementation. You won’t be able to peek inside or access any of their attributes.

There is an alternative approach to wrapping, which is to define an extension type, as

shown in this code:

# sample.pyx

cimport csample

from libc.stdlib cimport malloc, free

cdef class Point:

cdef csample.Point *_c_point

def __dealloc__(self):

free(self._c_point)

property x:

def __get__(self):

return self._c_point.x

def __set__(self, value):

self._c_point.x = value

property y:

def __get__(self):

return self._c_point.y

def __set__(self, value):

self._c_point.y = value

def distance(Point p1, Point p2):

return csample.distance(p1._c_point, p2._c_point)

Here, the cdef class Point is declaring Point as an extension type. The class variable

cdef csample.Point *_c_point is declaring an instance variable that holds a pointer

>>> import sample

>>> p1 = sample.Point(2,3)

>>> p2 = sample.Point(4,5)

>>> p1

>>> p2

>>> p1.x

>>> p1.y

>>> sample.distance(p1,p2)

>>>

This recipe has illustrated many of Cython’s core features that you might be able to

extrapolate to more complicated kinds of wrapping. However, you will definitely want

to read more of the official documentation to do more.

The next few recipes also illustrate a few additional Cython features.