Spoiler alert: You can make your Python faster

Going through a couple of misconceptions on why python is slow and how to make it faster.

Given as a talk to Theoretical Systems Biology group at Imperial College.

Please see the accompanying demo: http://lukauskas.co.uk/article/2014/02/12/how-to-make-python-faster-without-trying-that-much/

Transcript

1. Spoiler alert: You can make Python run faster Saulius Lukauskas 2014-02-04
2. Outline • Why is Python Slower than C • Implementations of Python • Idioms are important • Demo: minimal-effort-required optimisations of sample code
3. Why is Python Slower than C?
4. You code differently in Python
5. point = {'x': 0, 'y': 0}
6. struct Point { int x; int y; };
7. struct Point { int x; int y; }; point = { 'x': 0, 'y': 0 } !=
8. Hash Tables in C++ std::hash_set<std::string, int> point; point[“x”] = x point[“y”] = y
9. Structs in python ? class Point(object): x, y = None, None def __init__(self, x, y): self.x, self.y = x, y
10. Why we do not use them?
11. Objects are slower in standard Python def sum_(points): sum_x, sum_y = 0, 0 for point in points: sum_x += point['x'] sum_y += point['y'] return sum_x, sum_y ! def sum_(points): sum_x, sum_y = 0, 0 for point in points: sum_x += point.x sum_y += point.y return sum_x, sum_y
12. Objects are slower in standard Python def sum_(points): sum_x, sum_y = 0, 0 for point in points: sum_x += point['x'] sum_y += point['y'] return sum_x, sum_y ! def sum_(points): sum_x, sum_y = 0, 0 for point in points: sum_x += point.x sum_y += point.y return sum_x, sum_y 186 µs 201 µs
13. Implementation is the key def sum_(points): sum_x, sum_y = 0, 0 for point in points: sum_x += point.x sum_y += point.y return sum_x, sum_y In standard python, this is equivalent to dict(point)[‘x’] not a struct
14. Luckily, there is more than one implementation
15. Standard Python implementation: CPython • Most commonly used implementation of Python • “C” stands for, well, C. • Can run native C code from python. • Designed to be reference rather than an optimised implementation
16. Smart python interpreters: PyPy • http://pypy.org/ • Fast, compliant alternative implementation of the Python language (2.7.3 and 3.2.3). • Just-in-time (JIT) compilation • On (geometric) average of all benchmarks 6.2 times faster than CPython • Cannot run C code natively • Does not support numpy, yet
17. Objects are slower in standard Python def sum_(points): sum_x, sum_y = 0, 0 for point in points: sum_x += point['x'] sum_y += point['y'] return sum_x, sum_y ! def sum_(points): sum_x, sum_y = 0, 0 for point in points: sum_x += point.x sum_y += point.y return sum_x, sum_y 186 µs 201 µs
18. Under PyPy def sum_(points): sum_x, sum_y = 0, 0 for point in points: sum_x += point['x'] sum_y += point['y'] return sum_x, sum_y ! def sum_(points): sum_x, sum_y = 0, 0 for point in points: sum_x += point.x sum_y += point.y return sum_x, sum_y 186 µs 201 µs 21.6 µs 3.75 µs
19. Appropriate Data Structures make your code easier to optimise
20. Idioms can make interpreters job easier similarly,
21. Idiom #1: Loops int ans[N]; for (int i=0; i < N; i++) { int datapoint = data[i]; ans[i] = do_something_with(datapoint); }
22. Naive Pythonic implementation ans = [] for i in range(N): datapoint = data[i] ans.append(do_something_with(datapoint)) Takes 335 µs to run in my test
23. Naive Pythonic implementation ans = [] for i in range(N): datapoint = data[i] ans.append(do_something_with(datapoint)) Allocates a list [0, 1, 2, … , N-1] to loop through
24. Naive Pythonic implementation ans = [] for i in range(N): datapoint = data[i] ans.append(do_something_with(datapoint)) Allocates a list [0, 1, 2, … , N-1] to loop through just to access i-th data point
25. Idiom for looping through lists ans = [] for datapoint in data: ans.append(do_something_with(datapoint)) Takes 290 µs to run in my test (13.4% faster)
26. Idiom for applying function to lists map(do_something_with, data) Takes 189 µs to run in my test (35% faster than previous)
27. Parallelisation in Python import multiprocessing p = multiprocessing.Pool() p.map(do_something_with, data)
28. Light Reading: 10 Main Idioms of Python • Safe Hammad has recently compiled a list of ten main python idioms. • It is a very short read of best practices. • Have a look: • http://safehammad.com/downloads/python- idioms-2014-01-16.pdf
29. Other optimising implementations of python
30. Another JIT implementation: Numba • http://numba.pydata.org/ • Unlike PyPy, it is not a separate implementation of python • Supports numpy
31. Another JIT implementation: Numba from numba import autojit ! @autojit def sum2d(arr): M, N = arr.shape result = 0.0 for i in range(M): for j in range(N): result += arr[i,j] return result
32. Cython - Python Compiler • http://cython.org/ • Compiles your python code to C • Allows you to put static type checking into python • Relatively easy to produce C speeds for simple problems • Loots of cooperation with numpy, can run numpy’s C backend natively
33. Demo: Optimisation without effort
34. Further Reading Watching • Alex Gaynor “Why Python, Ruby and Javascript are Slow” in Waza 2013 • http://vimeo.com/61044810 • Great talk about the same issues covered here, a bit in more detail. • Some of my material is heavily inspired by this talk.