深入探索Cython：Python程序员指南

需积分: 44 17 浏览量更新于2024-07-18 1 收藏 3.64MB PDF 举报

"Cython: A Guide for Python Programmers 是一本由 Kurt W. Smith 编写的书籍，旨在向读者介绍Cython编程语言和Python到C的编译器。这本书适合对Cython感兴趣或正在使用Cython并希望深入学习的Python程序员。Cython不仅是一个实验性的语言转换项目，也不局限于一个仅在研究领域内使用的项目，而是已经成为Python世界中的基础项目的一部分，被广泛应用于实际环境中，并不断优化以提供更好的性能、更易用性和对新Python特性的更好支持。" Cython是Python的一个扩展，它允许开发者使用几乎与Python相同的语法编写代码，但能够编译成C代码，从而获得接近原生C的执行速度。Cython结合了静态类型检查和动态语言的灵活性，使得Python程序员可以更高效地利用计算资源，特别是对于计算密集型任务。本书中，Kurt W. Smith将引导读者了解Cython的基本概念，包括如何导入和使用C库，以及如何优化Python代码以提高性能。读者将学习如何编写Cython模块，使用类型声明来提升效率，以及如何调用C和C++代码。此外，书中可能还涵盖了Cython对Python新特性的支持，如生成器、协程等。书中的内容可能包括以下几个方面： 1. **入门指导**：介绍Cython的安装、配置和基本使用方法，让读者快速上手。 2. **类型声明**：解释如何通过类型声明提升代码的效率，以及静态类型和动态类型的差异。 3. **与Python的交互**：说明如何在Cython代码中调用Python函数和对象，以及反之。 4. **内存管理**：探讨Cython中的内存管理机制，如Numpy数组和C数据结构的使用。 5. **C/C++集成**：介绍如何编写Cython代码来直接调用C或C++库，包括封装C库的技巧。 6. **性能优化**：分享如何通过Cython进行性能分析和优化，以达到最佳运行速度。 7. **高级特性**：涵盖Cython的高级特性，如协程、生成器表达式和线程支持。 8. **案例研究**：通过实际示例展示Cython在科学计算、数据分析和其他领域的应用。 Cython的目标是为Python程序员提供一个平滑的学习曲线，使他们能够在保持Python的可读性和简洁性的同时，享受到接近C语言的性能。通过阅读本书，读者不仅可以理解Cython的工作原理，还能掌握如何将其有效地应用于自己的项目中，从而提升代码的运行效率。

CHAPTER 1

Cython Essentials

The test of a first-rate intelligence is the ability to hold two opposed

ideas in mind at the same time and still retain the ability to function.

— F. Scott Fitzgerald

Cython is two closely related things:

•

Cython is a programming language that blends Python with the static type system

of C and C++.

• cython is a compiler that translates Cython source code into efficient C or C++

source code. This source can then be compiled into a Python extension module or

a standalone executable.

Cython’s power comes from the way it combines Python and C: it feels like Python while

providing easy access to C. Cython is situated between high-level Python and low-level

C; one might call it a creole programming language.

But Python and C-like languages are so different—why combine them? Precisely because

their differences are complementary. Python is high-level, dynamic, easy to learn, and

flexible. These positives come with a cost, however—because Python is dynamic and

interpreted, it can be several orders of magnitude slower than statically typed compiled

languages.

C, on the other hand, is one of the oldest statically typed compiled languages in wide‐

spread use, so compilers have had nearly half a century to optimize its performance. C

is very low level and very powerful. Unlike Python, it does not have many safeguards

in place and can be difficult to use.

1. To follow along with the examples in this chapter, please see https://github.com/cythonbook/examples.

Both languages are mainstream, but they are typically used in different domains, given

their differences. Cython’s beauty is this: it combines Python’s expressiveness and dy‐

namism with C’s bare-metal performance while still feeling like Python.

With very few exceptions, Python code (both versions 2.x and 3.x) is already valid

Cython code. Cython adds a small number of keywords to the Python language to tap

into C’s type system, allowing the cython compiler to generate efficient C code. If you

already know Python and have a basic understanding of C or C++, you will be able to

quickly learn Cython. You do not have to learn yet another interface language.

We can think of Cython as two projects in one. If compiling Python to C is Cython’s

yin, then interfacing C or C++ with Python is its yang. We can start with Python code

that needs better performance, or we can start with C (or C++) code that needs an

optimized Python interface. To speed up Python code, Cython compiles Python source

with optional static type declarations to achieve massive performance improvements,

depending on the algorithm. To interface C or C++ libraries with Python, we can use

Cython to interface with external code and create optimized wrappers. Both

capabilities—compiling Python and interfacing with external code—are designed to

work together well, and each is an essential part of what makes Cython useful. With

Cython, we can move in either direction, coming from either starting point.

Cython and CPython

Cython is often confused with CPython (mind the P), but the two are very different.

CPython is the name of the standard and most widely used Python implementation.

CPython’s core is written in the C language, and the C in CPython is meant to distinguish

it from Python the language specification and Python implementations in other lan‐

guages, such as Jython (Java), IronPython (.NET), and PyPy (Python implemented in

Python!). CPython provides a C-level interface into the Python language; the interface

is known as the Python/C API. Cython uses this C interface extensively, and therefore

Cython depends on CPython. Cython is not another implementation of Python—it

needs the CPython runtime to run the extension modules it generates.

Let’s see an example.

Comparing Python, C, and Cython

Consider a simple Python function fib that computes the nth Fibonacci number:

2 | Chapter 1: Cython Essentials

2. Timings were measured on a four-core 2.4 GHz Intel Core i5 with 8 GB of 1,067 MHz DDR3 memory, running

Mac OS X version 10.7.5.

In Table 1-1,

the second column measures the runtime for fib(0) and the third column

measures the speedup of fib(0) relative to Python. Because the argument to fib con‐

trols the number of loop iterations, fib(0) does not enter the Fibonacci loop, so its

runtime is a reasonable measure of the language-runtime and function-call overhead.

The fourth and fifth columns measure the runtime and speedup for fib(90), which

executes the loop 90 times. Both the call overhead and the loop execution runtime

contribute to its runtime.

The sixth and seventh columns measure the difference between the fib(90) runtime

and the fib(0) runtime and the relative speedup. This difference is an approximation

of the runtime for the loop alone, removing runtime and call overhead.

Table 1-1 has four rows:

Pure Python

The first row (after the header) measures the performance of the pure-Python ver‐

sion of fib, and as expected, it has the poorest performance by a significant margin

in all categories. In particular, the call overhead for fib(0) is over half a microsec‐

ond on this system. Each loop iteration in fib(90) requires nearly 150 nanosec‐

onds; Python leaves much room for improvement.

Pure C

The second row measures the performance of the pure-C version of fib. In this

version there is no interaction with the Python runtime, so there is minimal call

overhead; this also means it cannot be used from Python. This version provides a

bound for the best performance we can reasonably expect from a simple serial fib

function. The fib(0) value indicates that C function call overhead is minimal (2

nanoseconds) when compared to Python, and the fib(90) runtime (164 nanosec‐

onds) is nearly 80 times faster than Python’s on this particular system.

Hand-written C extension

The third row measures a hand-written C extension module for Python 2. This

extension module requires several dozen lines of C code, most of it boilerplate that

calls the Python/C API. When calling from Python, the extension module must

convert Python objects to C data, compute the Fibonacci number in C, and convert

the result back to a Python object. Its call overhead (the fib(0) column) is corre‐

spondingly larger than that of the pure-C version, which does not have to convert

from and to Python objects. Because it is written in C, it is about three times faster

than pure Python for fib(0). It also gives a nice factor-of-30 speedup for fib(90).

4 | Chapter 1: Cython Essentials

Cython

The last row measures the performance for the Cython version. Like the C exten‐

sion, it is usable from Python, so it must convert Python objects to C data before it

can compute the Fibonacci number, and then convert the result back to Python.

Because of this overhead, it cannot match the pure-C version for fib(0), but, no‐

tably, it has about 2.5 times less overhead than the hand-written C extension. Be‐

cause of this reduced call overhead, it is able to provide a speedup of about a factor

of 50 over pure Python for fib(90).

The takeaways from Table 1-1 are the last two columns: the loop runtime for the pure

C, C extension, and Cython versions are all about 165 nanoseconds on this system, and

the speedups relative to Python are all approximately 75×.

For the C-only parts of an algorithm—provided sufficient static type

information is available—Cython can usually generate code that is as

efficient as a pure-C equivalent.

So, when properly accounting for Python overhead, we see that Cython achieves C-level

performance. Moreover, it does better than the hand-written C extension module on

the Python-to-C conversions.

Cython generates highly optimized code that is frequently faster than

an equivalent hand-written C extension module. It is often able to

generate Python-to-C conversion code that is several factors faster

than naive calls into the Python/C API.

As we will learn in Chapter 3, we can go even further and use Cython to create Python-

like C functions that have no Python overhead. These functions can be called from other

Cython code but cannot be called directly from Python. They allow us to remove ex‐

pensive call overhead for core computations.

What is the reason for Cython’s performance improvements? For this example, the likely

causes are function call overhead, looping, math operations, and stack versus heap

allocations.

Function Call Overhead

The fib(0) runtime is mostly consumed by the time it takes to call a function in the

respective language; the time to run the function’s body is relatively small. We see in

Table 1-1 that Cython generates code that is nearly an order of magnitude faster than

calling a Python function, and more than two times faster than the hand-written

Comparing Python, C, and Cython | 5

剩余249页未读，继续阅读

nn123456789

粉丝: 14
资源: 128

深入探索Cython：Python程序员指南

[Cython] Cython 编程学习教程 (英文版)

Learning Cython Programming(2nd) 无水印pdf

Learning Cython Programming.pdf

Learning Cython Programming 无水印pdf

Cython 3.0 英文原版文档.chm

Learning_Cython_Programming_by_Philip_Herron_2013.pdf.pdf

cython: a guide for python pdf

Cython-A-guide-for-Python-programmers.pdf.pdf

Cython tutorial

cython 3.0

最新资源