value range and the type of the loop variable al-
low it. Similarly, when iterating over a sequence,
it is sometimes required to know the current in-
dex inside of the loop body. Python has a spe-
cial function for this, called enumerate(), which
wraps the iterable in a counter:
f = open(’a_file.txt’)
for line_no, line in enumerate(f):
# prepend line number to line
print("%d: %s" % (line_no, line))
Cython knows this pattern, too, and reduces the
wrapping of the iterable to a simple counter vari-
able, so that the loop can run over the iterable
itself, with no additional overhead. Cython’s for
loop has optimizations for the most important
built-in Python container and string types and it
can even iterate directly over low-level types, such
as C arrays of a known size or sliced pointers:
cdef char* c_string = \
get_pointer_to_chars(10)
cdef char char_val
# check if chars at offsets 3..9 are
# any of ’abcABC’
for char_val in c_string[3:10]:
print( char_val in b’abcABC’ )
Another example where high-level language id-
ioms lead to specialized low-level code is cascaded
if statements. Many languages provide a special
switch statement for testing integer(-like) values
against a set of different cases. A common Python
idiom uses the normal if statement:
if int_value == 1:
func_A()
elif int_value in (2,3,7):
func_B()
else:
func_C()
This reads well, without needing a special syntax.
However, C compilers often fold switch state-
ments into more efficient code than sequential or
nested if-else statements. If Cython knows that
the type of the int value variable is compatible
with a C integer (e.g. an enum value), it can ex-
tract an equivalent switch statement directly from
the above code.
Several of these patterns have been implemented
in the Cython compiler, and new optimizations
are easy to add. It therefore becomes reasonable
for code writers to stick to the simple and read-
able idioms of the Python language, to rely on the
compiler to transform them into well specialized
and fast C language constructs, and to only take
a closer look at the code sections, if any, that still
prove to be performance critical in benchmarks.
Apart from its powerful control flow constructs,
a high-level language feature that makes Python
so productive is its support for object oriented
programming. True to the rest of the language,
Python classes are very dynamic – methods and
attributes can be added, inspected, and modi-
fied at runtime, and new types can be dynami-
cally created on the fly. Of course this flexibil-
ity comes with a performance cost. Cython al-
lows one to statically compile classes into C-level
struct layouts (with virtual function tables) in
such a way that they integrate seamlessly into the
Python class hierarchy without any of the Python
overhead. Though much scientific data fits nicely
into arrays, sometimes it does not, and Cython’s
support for compiled classes allows one to effi-
ciently create and manipulate more complicated
data structures like trees, graphs, maps, and other
heterogeneous, hierarchal objects.
