A taste of Cython

最近尝试自己实现决策树，实现结果与sklearn的实现相比，速度上明显差一截。我用的sklearn.datasets中的load_digits作为训练数据。sklearn一秒左右就完成了训练，而我自己的实现则是花费了十几秒。所以就尝试阅读sklearn的源代码，看看是什么原因造成了差距，当然现在只是关注速度上的。

在阅读sklearn的源码过程中发现，sklearn不是纯python的实现。其中夹杂了一些.pyx和.pxd为后缀的文件，搜索后知道这些文件是cython语言编写的。

什么是cython呢？刚开始我把cython和CPython给搞混了，CPython是用C语言实现的python解释器，而cython是python语言的一个超集，就和cpp和c的关系有些类似。作为python语言的超集，cython支持python的所有语法。但是既然已经有python了，为什么要搞一个cython呢？因为python太慢了。

举个例子，在python中，变量使用前不需要声明变量的类型，同一个变量名可以用不同的数据类型赋值，非常的灵活，这也是我喜欢python的原因之一，不需要程序员对变量的类型进行指定。既然程序员不指定变量的类型，那么python的解释器就自己检查，每次在对变量进行引用前，都对变量的类型做相应的检查，较少访问的变量还好，但是像for循环这种语句，可想而知这个效率会有多低。所以针对这一点，cython就在python的基础上扩展了类似C的语法，程序员可以为变量指定类型。一旦指定了变量类型，cython中的变量就不能像python中的那样赋予随意类型的数据了，但是随之而来的是效率上的提升。以上只是cython改进python的静态化改进的一方面。其实cython代码经过cython编译器编译后，会产生等价的C语言，但是实现同样一段功能，C语言要复杂得多，当然速度也快得多。当然还可以指定cython编译器产生相应平台的动态链接库，以供python调用。

说白了，cython就是为了利用C语言的优势，加速python的运行，但是又简化了C语言和python的复杂接口（正常情况下，编写能被python调用的C库，需要用C语言实现特定的python接口，非常复杂，查看cython编译产生的C文件就知道了），使得熟悉python但不熟悉C语言的程序员也可以比较轻松地利用C来加速python的执行。

原来sklearn的决策树实现利用了cython来加速，难怪比自己的纯python实现要快。不光是sklearn，其他常用的科学计算库比如numpy和pandas等都用了cython来加速。下面就通过几个例子来简单介绍一下如果用cython来加速代码的运行。

例子1 say hello

本case展示如何在python里调用cython编写的库函数，当然cython编写的功能函数是通过动态链接库的形式对python开放的。

步骤一：用cython编写功能。新建文件hello.pyx，实现say hello的功能

def say_hello_to(name):
    print("hello {}！".format(name))

步骤二：编译cython文件。（默认已经安装好了cython，pip install就行），命令行里输入一下命令

cythonize -b hello.pyx

其中cythonize的参数可以自行探究，这里的-b选项是在生成C语言的基础上，编译链接库。
命令执行的结果会在文件夹下生成一些文件，其中最重要的就是一下两个文件（以python3为例）

hello.cpython-36m-darwin.so
hello.c

这里的.so文件就包含了刚刚我们实现的say hello的功能。

步骤三：调用cython编写的库函数。新建文件test.py，注意，这是个普通的python文件。import会查找当前文件夹以hello开头的函数库，所以就会引入上面编译的结果

import hello

hello.say_hello_to("world")

终端输出：

hello world!

例子2 加速斐波那契数列生成

之前吹了cython能利用C语言的优势加速python的运行，本例就演示同样是生成斐波那契数列，python和cython的速度差异。

步骤一：新建文件fib.py，实现的功能就是生成斐波那契数列的第n位

def fib(n):
    a,b=1,1
    for i in range(n):
        a,b=a+b,a
    return a

步骤二：新建文件cy_fib.pyx。这里的语法就用了cython的扩展，而不是纯粹的python了。这里指定了几个变量的类型（具体的语法比如cdef、cpdef这些就感兴趣的人去补吧，我就不介绍了，本文就做简单的演示，文末有推荐的学习视频）

def fib(int n):
    cdef int i, a, b
    a,b=1,1
    for i in range(n):
        a,b=a+b,a
    return a

同样这个.pyx文件需要编译成链接库。在终端输入

cythonize -b cy_fib.pyx

就会生成cy_fib.cpython-36m-darwin.so

步骤三：对比。新建文件test.py

import timeit

cy_t=timeit.timeit("fib(1000)",setup="from cy_fib import fib",number=10000)
py_t=timeit.timeit("fib(1000)",setup="from py_fib import fib",number=10000)

print("cython is {}x time faster than python".format(py_t/cy_t))

运行test.py文件，结果显示cython要比python快200倍！真是令人激动的效率提升！

cython is 203.8898624599757x time faster than python

例子3 汉明距离

上一个例子已经显示出cython的强大，这个例子要说明的是，同一段cython代码，静态化的部分不同，造成的效果存在差异。这里举的例子是计算两个字符串的汉明距离。

步骤一：老套路，纯python的实现，新建hamming.py。hamming_sum和hamming_loop两个函数实现的功能相同，但是hamming_sum利用了python的zip，从语法角度上看，这很pythonic。但是从结果上看，越python，效率越低。

def hamming_sum(s0,s1):
    if len(s0) != len(s1):
        raise ValueError()
    return sum(c0!=c1 for (c0,c1) in zip(s0,s1))

def hamming_loop(s0,s1):
    if len(s0) != len(s1):
        raise ValueError()
    count =0
    for i in range(len(s0)):
        count+=(s0[i]!=s1[i])
    return count

步骤二：cython的实现，新建cy_hamming.py。这里纯粹是对纯python实现的copy，但是从结果可以看到，编译后的还是可以加速。

def hamming_sum(s0,s1):
    if len(s0) != len(s1):
        raise ValueError()
    return sum(c0!=c1 for (c0,c1) in zip(s0,s1))

def hamming_loop(s0,s1):
    if len(s0) != len(s1):
        raise ValueError()
    count =0
    for i in range(len(s0)):
        count+=(s0[i]!=s1[i])
    return count

步骤三：优化的cython实现，新建cy_hamming_solution.py。这里静态化了变量类型，但其实起主要作用的是函数入口的字符串静态化，也就是char*。

def hamming_sum(char* s0, char* s1):
    if len(s0) != len(s1):
        raise ValueError()
    return sum(c0!=c1 for (c0,c1) in zip(s0,s1))

def hamming_loop(char* s0,char* s1):
    if len(s0) != len(s1):
        raise ValueError()
    cdef:
        int count =0
        int i
        int N = len(s0)
    for i in range(N):
        count+=(s0[i]!=s1[i])
    return count

步骤四：对比。cythonize好上面的两个pyx文件后，新建test.py文件。

from timeit import timeit

print("*"*80)
print("python hamming_sum: %.2f" % timeit('hamming_sum("qwertyuio","asdfghjkl")','from hamming import hamming_sum'))
print("cython hamming_sum: %.2f" % timeit('hamming_sum("qwertyuio","asdfghjkl")','from cy_hamming import hamming_sum'))
print("solution hamming_sum: %.2f" % timeit('hamming_sum(b"qwertyuio",b"asdfghjkl")','from cy_hamming_solution import hamming_sum'))

print("-"*80)
print("python hamming_loop: %.2f" % timeit('hamming_loop("qwertyuio","asdfghjkl")','from hamming import hamming_loop'))
print("cython hamming_loop: %.2f" % timeit('hamming_loop("qwertyuio","asdfghjkl")','from cy_hamming import hamming_loop'))
print("solution hamming_loop: %.2f" % timeit('hamming_loop(b"qwertyuio",b"asdfghjkl")','from cy_hamming_solution import hamming_loop'))
print("*"*80)

结果

********************************************************************************
python hamming_sum: 2.11
cython hamming_sum: 1.50
solution hamming_sum: 1.30
--------------------------------------------------------------------------------
python hamming_loop: 1.99
cython hamming_loop: 0.55
solution hamming_loop: 0.11
********************************************************************************

对比分析：
- python hamming_sum和cython hamming_sum对比可以看出，就算不用cython的语法扩展，简单地将python代码放入cython中编译，还是可以对python进行加速
- cython hamming_sum和cython hamming_loop对比可以看出，越是pythonic的语法，效率越低。
- cython hamming_loop和solution hamming_loop对比可以看出，同样是cython，静态化的程度越高，加速越多。

好了，cython的初体验就到这吧。最后推荐一个关于cython的视频https://www.youtube.com/watch?v=gMvkiQ-gOW8，打不开可以去b站看https://www.bilibili.com/video/av23275467/，本文的例子就是出自这个视频，视频有点长，但是干货满满。