发布于 由admin

NumPy 与 Cython：编写高性能 C 扩展

好的，各位观众老爷，各位技术大拿，今天咱们就来聊聊如何用NumPy和Cython这对黄金搭档，写出高性能的C扩展，让你的Python代码像吃了大力丸一样，嗖嗖地快起来！🚀

开场白：Python的甜蜜烦恼

Python这门语言，就像一位温柔漂亮的女朋友，上手容易，写起来优雅，库多得像天上的星星，简直是程序员的梦中情人。😍

但，甜蜜的爱情总有烦恼。Python是解释型语言，执行效率相对较低。尤其是在处理大规模数值计算时，那速度，简直让人抓狂。想象一下，你要用Python计算几百万行数据的平均值，电脑风扇呼呼地响，你却只能默默地等待，等待，再等待… 🤯

这时候，你就需要我们的救星——NumPy和Cython！

第一幕：NumPy——数组运算的王者

NumPy，全称Numerical Python，是Python科学计算的核心库。它提供了强大的N维数组对象（ndarray），以及用于处理这些数组的各种函数。

  • ndarray：速度的基石

    NumPy的ndarray，可不是Python自带的list那么简单。它在内存中是连续存储的，这意味着CPU可以更高效地访问数据。这就像你把东西整整齐齐地放在柜子里，而不是随意地扔在地上，找起来当然更快啦！ 整理房间和整理数据，都是好习惯！👍

  • 向量化运算：告别for循环

    NumPy提供了强大的向量化运算功能。这意味着你可以直接对整个数组进行操作，而不需要写丑陋的for循环。这不仅代码更简洁，而且速度更快！为什么呢？因为NumPy底层是用C语言实现的，它把很多循环操作都优化到了C代码中。

    举个例子，你想计算两个数组对应元素的和，用Python原生的方式，你得这样写：

    a = [1, 2, 3]
b = [4, 5, 6]
result = []
for i in range(len(a)):
    result.append(a[i] + b[i])
print(result)  # Output: [5, 7, 9]

    但用NumPy，只需要一行代码：

    import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
result = a + b
print(result)  # Output: [5 7 9]

    简洁明了，速度飞快！简直是程序员的福音！😇

  • 广播机制：灵活的运算

    NumPy还提供了广播机制，允许你在不同形状的数组之间进行运算。这就像变魔术一样，NumPy会自动把较小的数组扩展成与较大数组兼容的形状，然后进行运算。 🧙‍♂️

第二幕：Cython——Python与C的桥梁

NumPy已经很快了，但有时候，我们还需要更极致的性能。这时候，Cython就该登场了。

Cython是一种编程语言，它是Python的超集，允许你编写同时包含Python和C代码的程序。Cython编译器会将你的代码编译成C扩展，然后你就可以像使用普通的Python模块一样使用它了。

  • 静态类型：性能的钥匙

    Python是动态类型语言，这意味着变量的类型是在运行时确定的。这很灵活，但也很慢。Cython允许你为变量指定类型，这样编译器就可以生成更高效的C代码。

    例如，在Python中：

    def add(a, b):
    return a + b

    编译器不知道a和b是什么类型，所以它必须在运行时进行类型检查，然后才能进行加法运算。

    但在Cython中，你可以这样写：

    def add(int a, int b):
    return a + b

    现在，编译器知道a和b都是整数，它可以直接生成C代码进行加法运算，避免了运行时的类型检查，速度自然就快多了。

  • 直接调用C代码：无限可能

    Cython不仅可以让你编写C代码，还可以让你直接调用C库。这意味着你可以利用现有的C库来加速你的Python代码。

    比如，你想用C语言的qsort函数来排序一个数组，你可以这样写：

    # distutils: sources = example.c

cdef extern from "stdlib.h":
    void qsort(void *base, size_t nmemb, size_t size,
               int (*compar)(const void*, const void*))

cdef int int_compare(const void *a, const void *b):
    return (<int*>a)[0] - (<int*>b)[0]

def sort(int[:] arr):
    qsort(&arr[0], arr.shape[0], sizeof(int), int_compare)

    这段代码首先声明了C语言的qsort函数，然后定义了一个比较函数int_compare，最后定义了一个Python函数sort，它调用qsort函数来排序一个NumPy数组。

  • Cython的魔法注释

    Cython还提供了一些特殊的注释，可以帮助你优化代码。比如，@cython.boundscheck(False)可以关闭数组的边界检查，@cython.wraparound(False)可以关闭数组的负索引访问。这些注释可以让你在保证代码安全性的前提下，进一步提高性能。

第三幕：NumPy + Cython——绝世双骄

现在，让我们把NumPy和Cython结合起来，看看能产生什么样的化学反应。

  • 加速NumPy数组运算

    我们可以用Cython来编写NumPy数组的运算函数，这样可以充分利用C语言的性能优势，同时又可以享受到NumPy的便利性。

    举个例子，你想计算一个NumPy数组的平方和，你可以这样写：

    import numpy as np
import pyximport
pyximport.install()
import example

a = np.arange(1000000)
result = example.sum_squares(a)
print(result)

    对应的Cython代码如下：

    # example.pyx
import numpy as np
cimport numpy as cnp
import cython

@cython.boundscheck(False)
@cython.wraparound(False)
def sum_squares(cnp.ndarray[cnp.int64_t, ndim=1] arr):
    cdef cnp.int64_t sum = 0
    cdef int i
    for i in range(arr.shape[0]):
        sum += arr[i] * arr[i]
    return sum

    将example.pyx编译成example.so文件，然后就可以像使用普通的Python模块一样使用它了。

    这段代码首先导入了NumPy库，并声明了NumPy数组的类型。然后，它用C语言编写了一个循环，计算数组的平方和。最后，它返回计算结果。

    与纯Python代码相比，这段Cython代码的速度可以提高几十倍甚至几百倍！ 简直是脱胎换骨！ 🦋

  • 构建自定义NumPy ufunc

    NumPy的ufunc（通用函数）是一种可以对数组进行逐元素操作的函数。我们可以用Cython来构建自定义的ufunc，这样可以方便地对NumPy数组进行各种复杂的运算。

    比如，你想构建一个自定义的ufunc，计算一个数的平方根，你可以这样写：

    import numpy as np
import pyximport
pyximport.install()
import example

a = np.arange(10)
result = example.sqrt(a)
print(result)

    对应的Cython代码如下：

    # example.pyx
import numpy as np
cimport numpy as cnp
import cython
from libc.math cimport sqrt

@cython.boundscheck(False)
@cython.wraparound(False)
cpdef cnp.ndarray[cnp.float64_t, ndim=1] sqrt(cnp.ndarray[cnp.float64_t, ndim=1] arr):
    cdef cnp.ndarray[cnp.float64_t, ndim=1] out = np.empty_like(arr, dtype=np.float64)
    cdef int i
    for i in range(arr.shape[0]):
        out[i] = sqrt(arr[i])
    return out

    这段代码首先导入了NumPy库，并声明了NumPy数组的类型。然后，它导入了C语言的sqrt函数，并用C语言编写了一个循环，计算数组的平方根。最后，它返回计算结果。

    通过NumPy的frompyfunc函数，我们可以将这个Cython函数转换成NumPy的ufunc，然后就可以像使用普通的NumPy函数一样使用它了。

    这种方法可以让你充分利用C语言的性能优势，同时又可以享受到NumPy的便利性。简直是鱼与熊掌兼得！ 😋

第四幕：实战演练——图像处理

理论讲多了，不如来点实际的。我们来做一个简单的图像处理程序，用NumPy和Cython来加速图像的灰度化过程。

  • 准备工作

    首先，你需要安装NumPy、Cython和Pillow库。Pillow是Python的图像处理库，可以用来读取和保存图像。

    pip install numpy cython pillow

  • Python代码

    from PIL import Image
import numpy as np
import pyximport
pyximport.install()
import example
import time

# 读取图像
image = Image.open("example.jpg")
# 转换为NumPy数组
image_array = np.array(image)

# 灰度化
start_time = time.time()
gray_array = example.to_grayscale(image_array)
end_time = time.time()
print("灰度化耗时：", end_time - start_time)

# 转换为图像
gray_image = Image.fromarray(gray_array)
# 保存图像
gray_image.save("gray_example.jpg")

  • Cython代码

    # example.pyx
import numpy as np
cimport numpy as cnp
import cython

@cython.boundscheck(False)
@cython.wraparound(False)
def to_grayscale(cnp.ndarray[cnp.uint8_t, ndim=3] image):
    cdef int height = image.shape[0]
    cdef int width = image.shape[1]
    cdef cnp.ndarray[cnp.uint8_t, ndim=2] gray = np.empty((height, width), dtype=np.uint8)
    cdef int i, j
    for i in range(height):
        for j in range(width):
            gray[i, j] = <cnp.uint8_t>(0.299 * image[i, j, 0] +
                                       0.587 * image[i, j, 1] +
                                       0.114 * image[i, j, 2])
    return gray

    这段代码首先读取了一张彩色图像，然后用Cython编写了一个函数，将图像转换为灰度图像。最后，它保存了灰度图像。

    通过对比纯Python代码和Cython代码的执行时间，你可以看到Cython带来的性能提升是非常显著的。

第五幕：注意事项与最佳实践

  • 类型声明：越多越好

    在Cython中，尽可能多地声明变量的类型。这可以帮助编译器生成更高效的C代码。

  • 避免Python对象操作

    在Cython代码中，尽量避免对Python对象进行操作。因为Python对象的操作通常比较慢。

  • 使用NumPy的ufunc

    NumPy的ufunc是用C语言实现的，速度非常快。在Cython代码中，尽量使用NumPy的ufunc来进行数组运算。

  • 性能测试：一切用数据说话

    在优化代码时，一定要进行性能测试。只有通过数据才能知道你的优化是否有效。

  • 代码可读性：重要性不亚于性能

    在追求性能的同时，也要注意代码的可读性。清晰易懂的代码更容易维护和调试。

结尾：性能优化永无止境

NumPy和Cython是编写高性能Python代码的利器。但性能优化是一个永无止境的过程。只有不断学习和实践，才能写出更快、更高效的代码。

希望今天的分享对你有所帮助。如果你有任何问题，欢迎在评论区留言。我们下期再见！ 👋

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注