Optimize your Python code with C

Cython is a compiler for the Python programming language meant to optimize efficiency and type an prolonged Cython programming language. As an extension of Python, Cython can be a superset of the Python language, and it helps calling C capabilities and declaring C varieties on variables and sophistication attributes. This makes it straightforward to wrap exterior C libraries, embed C into present purposes, or write C extensions for Python in syntax as straightforward as Python itself.

Cython is often used to create C modules that velocity up Python code execution. This is necessary in advanced purposes the place an interpreted language is not environment friendly.

Install Cython

You can set up Cython on Linux, BSD, Windows, or macOS utilizing Python:

$ python -m pip set up Cython

Once put in, it is prepared to make use of.

Transform Python into C

A great way to start out with Cython is with a easy “hello world” software. It’s not the perfect demonstration of Cython’s benefits, but it surely reveals what occurs once you’re utilizing Cython.

First, create this easy Python script in a file referred to as howdy.pyx (the .pyx extension is not magical and it might technically be something, but it surely’s Cython’s default extension):

print("hello world")

Next, create a Python setup script. A setup.py file is like Python’s model of a makefile, and Cython can use it to course of your Python code:

from setuptools import setup
from Cython.Build import cythonize
setup(
    ext_modules = cythonize("hello.pyx")
)

Finally, use Cython to rework your Python script into C code:

$ python setup.py build_ext --inplace

You can see the ends in your undertaking listing. Cython’s cythonize module transforms howdy.pyx right into a howdy.c file and a .so library. The C code is 2,648 strains, so it is fairly much more textual content than the only line of howdy.pyx supply. The .so library can be over 2,000 instances bigger than its supply (54,000 in comparison with 20 bytes). Then once more, Python is required to run a single Python script, so there’s loads of code propping up that single-line howdy.pyx file.

To use the C code model of your Python “hello world” script, open a Python immediate and import the brand new howdy module you created:

>>> import howdy
howdy world

Integrate C code into Python

An excellent generic take a look at of computational energy is calculating prime numbers. A first-rate quantity is a constructive quantity higher than 1 that produces a constructive integer solely when divided by 1 or itself. It’s easy in principle, however as numbers get bigger, the calculation necessities additionally improve. In pure Python, it may be completed in beneath 10 strains of code:

import sys
quantity = int(sys.argv[1])
if not quantity <= 1:
    for i in vary(2, quantity):
        if (quantity % i) == zero:
            print("Not prime")
            break
else:
    print("Integer must be greater than 1")

This script is silent upon success and returns a message if the quantity isn’t prime:

$ ./prime.py three
$ ./prime.py four
Not prime.

Converting this to Cython requires just a little work, partly to make the code applicable to be used as a library and partly for efficiency.

Scripts and libraries

Many customers be taught Python as a scripting language: you inform Python the steps you need it to carry out, and it does the work. As you be taught extra about Python (and open supply programming usually), you be taught that a lot of essentially the most highly effective code out there’s within the libraries that different purposes can harness. The much less particular your code is, the extra seemingly it may be repurposed by a programmer (you included) for different purposes. It could be a little extra work to decouple computation from workflow, however ultimately, it is often definitely worth the effort.

In the case of this easy prime quantity calculator, changing it to Cython begins with a setup script:

from setuptools import setup
from Cython.Build import cythonize
setup(
    ext_modules = cythonize("prime.py")
)

Transform your script into C:

$ python setup.py build_ext --inplace

Everything seems to be working effectively thus far, however once you try and import and use your new module, you get an error:

>>> import prime
Traceback (most up-to-date name final):
  File "<stdin>", line 1, in <module>
  File "prime.py", line 2, in init prime
    quantity = sys.argv[1]
IndexError: checklist index out of vary

The drawback is Python script expects to be run from a terminal, the place arguments (on this case, an integer to check as a chief quantity) are widespread. You want to change your script in order that it may be used as a library as an alternative.

Write a library

Libraries do not use system arguments and as an alternative settle for arguments from different code. Instead of utilizing sys.argv to usher in consumer enter, make your code a operate that accepts an argument referred to as quantity (or num or no matter variable title you like):

def calculate(quantity):
    if not quantity <= 1:
        for i in vary(2, quantity):
            if (quantity % i) == zero:
                print("Not prime")
                break
    else:
        print("Integer must be greater than 1")

This admittedly makes your script considerably tough to check as a result of once you run the code in Python, the calculate operate is rarely executed. However, Python programmers have devised a standard, if not intuitive, workaround for this drawback. When the Python interpreter executes a Python script, there is a particular variable referred to as __name__ that will get set to __main__, however when it is imported as a module, __name__ is ready to the module’s title. By leveraging this, you may write a library that’s each a Python module and a legitimate Python script:

import sys
def calculate(quantity):
    if not quantity <= 1:
        for i in vary(2, quantity):
            if (quantity % i) == zero:
                print("Not prime")
                break
    else:
        print("Integer must be greater than 1")
if __name__ == "__main__":
    quantity = sys.argv[1]    
    calculate( int(quantity) )

Now you may run the code as a command:

$ python ./prime.py four
Not a chief

And you may convert it to Cython to be used as a module:

>>> import prime
>>> prime.calculate(four)
Not prime

C Python

Converting code from pure Python to C with Cython may be helpful. This article demonstrates how to do this half, but there are Cython options that can assist you optimize your code earlier than conversion, choices to research your code to seek out when Cython interacts with C, and way more. If you are utilizing Python, however you are seeking to improve your code with C code or additional your understanding of how libraries present higher extensibility than scripts, or if you happen to’re simply interested in how Python and C can work collectively, then begin experimenting with Cython.