Cython — When the Compile Step Is Worth It
Think of Cython as a translator who can speak both Python and C. If you give the translator a Python script and tell them to convert it to C, they will do a direct word-for-word translation (minimal speedup). But if you explicitly tell them which Python variables are actually C integers or floats, they can use much faster, native C idioms, making the compiled code significantly quicker.
The Setup
A scientific simulation package written in pure Python has a critical inner loop that performs intensive numerical computations. This loop is the primary bottleneck, and traditional Python optimizations (vectorization, algorithm changes) have reached their limit. The team is considering rewriting it in C or using Cython.
What Does This Print?
# my_module.py
import time
def compute_sum_of_squares(iterations: int) -> int:
s = 0
for i in range(iterations):
s += i * i
return s
if __name__ == '__main__':
N = 50_000_000 # A large number of iterations
start = time.perf_counter()
result = compute_sum_of_squares(N)
end = time.perf_counter()
print(f"Python compute_sum_of_squares({N}): {result}")
print(f"Execution time (Python): {end - start:.4f} seconds")The Output
Running the pure Python code will demonstrate it is CPU-bound and relatively slow for 50 million iterations, perhaps taking several seconds. If you were to simply rename this file to .pyx and compile it with Cython without adding any C type declarations, the speedup would be minimal, if any.
The Cythonized version without static typing would still perform many Python object operations for i and s, as Cython's default behavior is to infer Python object types.
Why Python Does This
The "slowness" of pure Python for numerical loops stems from several factors: the GIL, dynamic typing, and the overhead of Python object operations. Each integer i and s in the loop is a full Python int object, not a simple C integer. Operations like i * i or s += ... involve function calls to Python's internal C API, object creation, reference counting, and garbage collection checks. When Cython compiles a .pyx file, by default, it infers that variables are Python objects. To get significant speedup, you must use C type declarations (cdef int i, cdef long long s) to tell Cython to treat variables as C primitive types. This allows Cython to generate direct C arithmetic operations, bypassing the Python interpreter and its object overhead for those specific sections of code.
The Fix
# setup.py
from setuptools import setup
from Cython.Build import cythonize
setup(
ext_modules = cythonize("my_module.pyx")
)
# my_module.pyx (renamed from my_module.py and added C types)
# distutils: language_level=3
import time
cpdef long long compute_sum_of_squares(int iterations) nogil: # FIX: Add cpdef for Python accessibility and 'nogil' for GIL release
cdef long long s = 0 # FIX: Declare s as C long long
cdef int i # FIX: Declare i as C int
for i in range(iterations):
s += i * i
return s
if __name__ == '__main__':
N = 50_000_000
start = time.perf_counter()
# Call the compiled Cython function
result = compute_sum_of_squares(N)
end = time.perf_counter()
print(f"Cython compute_sum_of_squares({N}): {result}")
print(f"Execution time (Cython): {end - start:.4f} seconds")
# To run:
# 1. pip install Cython
# 2. python setup.py build_ext --inplace
# 3. Then you can import and run compute_sum_of_squares from the compiled 'my_module'Adding C type declarations (cdef) to variables, function arguments, and return types allows Cython to generate highly optimized C code that bypasses the Python object model and the GIL for those specific operations. This direct interaction with C primitives eliminates much of Python's runtime overhead.
How This Fails in Real Systems
A machine learning inference service used a custom distance calculation implemented in Python. As model complexity grew, this function became the bottleneck, increasing inference latency to unacceptable levels. The team initially just compiled the Python file with Cython, seeing no performance improvement. It took a deep dive into Cython's generated C code to realize they needed to explicitly declare C types for all loop variables and function arguments. Once typed, the function's execution time dropped from 150ms to 5ms, dramatically improving the service's throughput and latency. The previous, untyped Cython version ran for three months with minimal benefit.