Python performance optimization

Performance optimization – making a program run faster – is closely related to refactoring. Refactoring makes existing source code more readable and less complex on the inside without changing its behavior on the outside. Refactoring is a costly operation. Typically, an 80/20 rule applies. A 20% effort is needed to implement the bulk of the program. Then another 80% effort (and budget) is needed to optimize, refactor, extend and/or document the program.

Do not worry about performance during development. You first need the program to produce correct results (with correct input) before you know what is making it slow. 

Not all parts of the source code will be optimizable. In Python, many operations such as dictionary lookups and regular expressions are as efficient as they can be. Some operations in your code simply need to happen to make the program work. In this case, micro-optimizations (e.g., making a function 1% faster) are a waste of time. 

 


Profiling

Typically, the top 20% slow parts of the program may benefit from optimization. To find the slow parts you need to profile the source code. The profile() function below uses Python's cProfile module to return a string of performance statistics. To use it you can simply copy it into a test script:

def profile(function, *args, **kwargs):
    """ Returns performance statistics (as a string) for the given function.
    """
    def _run():
        function(*args, **kwargs)
    import cProfile as profile
    import pstats
    import os
    import sys; sys.modules['__main__'].__profile_run__ = _run
    id = function.__name__ + '()'
    profile.run('__profile_run__()', id)
    p = pstats.Stats(id)
    p.stream = open(id, 'w')
    p.sort_stats('time').print_stats(20)
    p.stream.close()
    s = open(id).read()
    os.remove(id)
    return s

The following example profiles Pattern's parse() command. Parameters of parse() are instead passed to profile(). Make sure that the program is busy for a few seconds to get a reliable profile. You could execute it several times in a loop or pass lots of data to it, for example.

>>> from pattern.en import parse
>>> txt = open('paper.txt').read()
>>> print profile(parse, txt, lemmata=True)

369318 function calls (369315 primitive calls) in 0.685 CPU seconds
  
ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    67    0.164    0.002    0.170    0.003 /pattern/en/brill.py:104(apply)
     1    0.098    0.098    0.265    0.265 /pattern/en/brill.py:171(load)
 93694    0.088    0.000    0.149    0.000 /pattern/en/brill.py:175(<genexpr>)
102762    0.081    0.000    0.081    0.000 {method 'split' of 'str' objects}
... 

Assessment of the output:

  • brill.py has a heavy apply() that needs closer inspection.
  • brill.py has a heavy load(), it probably loads a lexicon file. Not much we can do about that.
  • There appears to be a lambda function (<genexpr>) in brill.py that is called x 100,000.
  • The split() method of Python's str object is called often, but we probably can't optimize that.

Once we have isolated the slow parts, we can try to make them faster. To do this, we time them one by one. Below is an example setup that executes the apply() in brill.py multiple times and outputs the elapsed time. We can tinker with the source code and verify if the elapsed time increases or decreases.

>>> from time import time
>>> from pattern.en.parser.brill import Lexicon
>>> lexicon = Lexicon()
>>> t = time()
>>> for i in range(1000):
>>>     lexicon.apply(...)
>>> print time() - t

 


Dictionaries

Membership testing is faster in dict than in list. Python dictionaries use hash tables, this means that a lookup operation (e.g., if x in y) is O(1). A lookup operation in a list means that the entire list needs to be iterated, resulting in O(n) for a list of length n

Assume we have a list of stop words we want to filter from a given text:

>>> stopwords = [
>>>     'a', 'an', 'and', 'are', 'as', 'at', 'be', 'by', 
>>>     'for', 'from', 'has', 'he', 'in', 'is', 'it', 'its',
>>>     'of', 'on', 'that', 'the', 'to', 'was', 'were', 'will', 'with'
>>> ]
>>> 
>>> for i in range(1000000): # Do it many times to test performance.
>>>     filtered = []
>>>     for w in ['Mr.', 'Hat', 'is', 'feeding', 'the', 'black', 'cat', '.']:
>>>         if w not in stopwords:
>>>             filtered.append(w)

The algorithm takes 11.6 seconds to run. Adding stop words makes it even slower. However, the list is easily converted to a dictionary. With dict performance is constant, regardless of dictionary size:

>>> stopwords = dict.fromkeys(stopwords, True)

The dict.fromkeys() method takes a list of keys + a default value for all keys, and returns a new dictionary. Using this approach the algorithm takes 4.7 seconds to run, a x2.5 speedup.

 


Dictionaries + caching

Here is a comparison of four implementations of the cosine distance algorithm, which measures similarity between vectors of features (words) with feature weights (word relevance). The first implementation represents vectors as ordered, equal-length lists of feature weights. The second represents vectors as sparse dictionaries of feature → weight items, where features with weight = 0 are omitted. The third subclasses a dictionary and uses caching for l2(). The fourth adds a distance cache.

 The first implementation takes 1.5 seconds to run (and more for longer vectors):

def distance(v1, v2):
    return sum(w1 * w2 for w1, w2 in zip(v1, v2)) / (l2(v1) * l2(v2) or 1)
def l2(v):
    return sum(w**2 for w in v) ** 0.5 
>>> for i in range(100000):
>>>     d = distance([2,1,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,3,1])

To make it faster we can get leave out the zeros (which means less iterations), using dict.get() with a default value for missing features. The second implementation then takes 1.1 seconds, a x1.4 speedup:

def distance(v1, v2): 
    return sum(v1[f] * v2.get(f,0) for f in v1) / (l2(v1) * l2(v2) or 1)
def l2(v):
    return sum(w**2 for w in v.values()) ** 0.5
>>> for i in range(100000):
>>>     d = distance({0:2, 1:1, 2:1}, {0:1, 8:3, 9:1})

To make it faster we can cache the costly L2-norm math, since it always yields the same result for a given vector. The third implementation then takes 0.6 seconds, a x2.5 speedup:

class Vector(dict):
    def __init__(self, *args, **kwargs):
        dict.__init__(self, *args, **kwargs)
        self.l2 = sum(w**2 for w in self.values()) ** 0.5
def distance(v1, v2):
    return sum(v1[f] * v2.get(f,0) for f in v1) / (v1.l2 * v2.l2 or 1)
>>> for i in range(100000):
>>>     d = distance(Vector({0:2, 1:1, 2:1}), Vector({0:1, 8:3, 9:1}))

Finally, we cache the distances. Python's id() function returns a unique id for each object. When we calculate the distance between v1 and v2, we can store the result in a global CACHE dictionary, under CACHE[(id(v1),id(v2))] – since keys must be hashable we can't use (v1,v2) directly.

Next time, we can check if the result is already in the cache – a dictionary lookup is faster than the math.

CACHE = {}
def distance(v1, v2):
    k = id(v1), id(v2)
    if k not in CACHE:
        d = sum(v1[f] * v2.get(f,0) for f in v1) / (v1.l2 * v2.l2 or 1)
        CACHE[k] = d
        CACHE[id(v2), id(v1)] = d # symmetric
    return CACHE[k]

This ensures that calculating distance is never more than O(n*n) for n vectors. 

 


Sets

Set operations (union, intersection, difference) are faster than iterating over lists:

Syntax Operation Description
set(list1) | set(list2) union New set with values from both list1 and list2.
set(list1) & set(list2) intersection New set with values common to list1 and list2.
set(list1) - set(list2) difference New set with values in list1 but not in list2.

You can use them to merge two lists, or to make a list of unique values for example. 

>>> print list(set([1, 2, 2, 3]))
>>> print list(set([1, 2]) | set([2, 3]))
>>> print list(set([1, 2]) & set([2, 3]))

[1, 2, 3]
[1, 2, 3]
[2]

 


Inner for-loops

If your code has nested for-loops, all optimizations inside the inner loop count. Consider the following:

>>> v1 = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] * 10
>>> v2 = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] * 10
>>> 
>>> for n in range(1000):
>>>     for i in range(len(v1)):
>>>         for j in range(len(v2)):
>>>             x = v1[i] + v2[j]

The algorithm takes 4.0 seconds to run. It is a hypothetical example, but the point is this: we can make it faster by moving v1[i] outside of the inner loop:

>>> for n in range(1000):
>>>     for i in range(len(v1)):
>>>         v1i = v1[i]
>>>         for j in range(len(v2)):
>>>             x = v1i + v2[j]

Now it takes 3.2 seconds to run. In the first example, v1[i] is called  100 x 100 x 100 = 1,000,000 times. In this example, we look up number i in v1 once before iterating over v2, so v1[i]  is called only 100 x 100 times, making the algorithm x1.3 faster. Move everything you can outside of the inner loop.

 


Lazy if-evaluation

As in most programming languages, Python's if is lazily evaluated. This means that in: if x and y, condition y will not be tested if x is already False. We can exploit this by checking a fast condition first before checking a slow condition.

For example, say we are looking for abbreviations in text:

>>> abbreviations = ['cf.', 'e.g.', 'ex.', 'etc.', 'fig.', 'i.e.', 'Mr.', 'vs.']
>>>
>>> for n in range(1000000):
>>>     for w in ('Mr.', 'Hat', 'is', 'chasing', 'the', 'black', 'cat', '.'):
>>>         if w in abbreviations:
>>>             pass # Process abbreviation here.

The algorithm takes 4.3 seconds to run. However, since most of the words are not abbreviations we can optimize it by first checking if a word ends with a period, which is faster than iterating the list of known abbreviations:

>>> for n in range(1000000):
>>>     for w in ('Mr.', 'Hat', 'is', 'chasing', 'the', 'black', 'cat', '.'):
>>>         if w[-1] == '.' and w in abbreviations:
>>>             pass

Now it takes 3.1 seconds to run, a x1.4 speedup.

 


String methods & regular expressions

Regular expressions in Python are fast because they are pushed back to C code. However, in many situations simple string methods are even faster. Below is a list of interesting string methods. If you do use regular expressions, remember to add source code comments what they do.

Method Description
str[-1] == 'x' True if the last character is "x" (but Exception if len(str) == 0).
str.isalpha() True if the string only contains a-z | A-Z characters.
str.isdigit() True if the string only contains 0-9 characters.
str.startswith(('x', 'yz')) True if the first characters in the string are "x" or "yz".
str.endswith(('x', 'yz')) True if the last characters in the string are "x" or "yz".

 


String concatenation

Format strings are often faster than concatenating values to strings:

>>> s = '<feature term="' + 'cat' + '" weight="' + str(1.0) + '" />' 
>>> s = '<feature term="%s" weight="%s" />' % ('cat', 1.0) # Faster format string.

If you are constructing a large string (for example, XML output), it is faster to append the different parts to a list and collapse it at the end:

>>> features = [('cat', 1.0), ('dog', 0.0)]
>>>
>>> xml = []
>>> for term, weight in features:
>>>     xml.append('<feature term="%s" weight="%s" />' % (term, weight))
>>> xml = '\n'.join(xml)

 


List comprehension

List comprehensions are faster than building a new list in a for-loop. The first example below uses a loop and takes 6.6 seconds. The second example uses list comprehension and takes 5.3 seconds, a x1.2 speedup.

>>> words = ['Mr.', 'Hat', 'is', 'feeding', 'the', 'black', 'cat', '.']
>>>
>>> for n in range(1000000):
>>>     a = []
>>>     for w in words:
>>>         if w != '.': 
>>>             a.append(w.lower()) 
>>> for n in range(1000000):
>>>     a = [w.lower() for w in words if w != '.']

 


If + None

if done is not None is faster than if done != None, which in turn is faster than if not done.
It's nitpicking but it matters inside inner loops.