the dam

Using Vim as a Python IDE

2013-04-15T17:53:00+02:00

About one year ago, I have switched to using Vim as my main text and code editor. Before that, I was using Emacs, but never really mastered it to the point where I could consider myself proficient. After having heard a lot about the steep learning curve of Vim, I was surprised to find myself picking it up rather quickly: I like the fact that shortcuts are structured similarly to natural languages. People often mention how combining action and motion instructions in Vim is similar to constructing a sentence in a natural language, which I find an accurate comparison.

Vim really shines when it comes to quickly editing a few files from the command line, but even though I am not a heavy coder, I found the default configuration a bit insufficient for bigger projects involving editing multiple related files. Here is how I gradually tweaked my Vim configuration to copy some behaviors commonly found in IDEs. While some of these tweaks are general and can be applied to any language, others are specific to Python, the language I use most of the time.

This article assumes that you already have a basic knowledge of Vim and its configuration. If you do not want to read my comments and prefer to stick to the bare configuration steps, you can jump straight to the Conclusion.

Forewords

First and foremost, you should make sure that you have Pathogen installed. This amazing script allows you to handle your Vim plugins separately: each plugin becomes a subdirectory of the .vim/bundle folder (this can be changed to somewhere else) in which you put all the plugin files instead of spreading them over the default directory structure. Most of the plugins I will recommend here are available on GitHub, so cloning their repositories inside your .vim/bundle folder is all you need to install them.

This is particularly useful if you use Git to handle your Vim configuration (and more generally your dotfiles), because you can treat each Vim plugin as a submodule of your main repository, allowing for easy updates.

Installing Pathogen is as easy running:

mkdir -p ~/.vim/bundle ~/.vim/autoload
curl -Sso ~/.vim/autoload/pathogen.vim \
    https://raw.github.com/tpope/vim-pathogen/master/autoload/pathogen.vim

and adding the following line at the top of your .vimrc:

execute pathogen#infect()

Also, as a general recommendation, make sure that you have a color theme that match your tastes. Because I find dark themes more easy on the eyes, I went for Molokai. Solarized is a common choice among light themes lovers.

File and project management

When working on a project involving more than one file, being able to quickly navigate through its files is key. NERDTree is a nice plugin which replaces the default Vim file browser and adds a file-tree drawer on the left of Vim's interface. I bind the <F1> key to the NERDTreeToogle function to quickly toggle the drawer on and off:

nnoremap <F1> :NERDTreeToggle<cr>

I find the NERDTree plugin very useful when discovering a project, to quickly grasp how the files are organized. However, to quickly open new files and switch to open buffers, there is a much more powerful solution, I name the CtrlP plugin. This plugin adds commands to search through files, buffers, tags, etc. in a fuzzy way. Let's say you want to open a file, pressing <Ctrl-p> followed by a few letters of this file's path (they don't need to be contiguous) will give you a list of all the files matching these letters. The list gets further filtered as you keep typing. When the file you are looking for reaches the bottom of the list, you simply press <Enter> to open it.

In addition to the default <Ctrl-p> shortcut to open new files, I like to have a shortcut to launch the buffer finding command to search through open buffers. Here I bind it to <Ctrl-b>:

nnoremap <c-b> :CtrlPBuffer<cr>

Vim has a very nice built-in session feature: you can save the current state of your Vim instance (open buffers, windows layout, cursor positions, paste registers, jumps, macros, etc.) in a session file. The sessionman plugin is a simple wrapper around this feature, and takes care of storing all your session files in the same directory. This is achieved by using the SessionSave command which asks you for a simple name to identify the session. Call the SessionOpen command with the same name to re-open the session. Also, if you are working inside a previously saved session, the plugin automatically saves the current state in the same session file when quitting Vim.

Finally, I would also recommend reading the buffers and windows sections of Vim's help. Having a good understanding of buffers and windows, splits, etc. can help you being more productive when working on multiple files.

Code writing

There are many plugins to help you writing code more efficiently. Here are some that I find particularly helpful.

TagBar: to display a list of the current file's tags (when programming, these are the functions, classes, global variables defined in the file) in a drawer on the right of Vim's interface. This allows you to have a clear view of the file content and to quickly jump to another location. I bind the <F2> key to the TagbarToggle command to toggle the drawer:
```
nnoremap <F2> :TagbarToggle<cr>
```
note that this plugin requires that you have a ctags implementation installed on your computer.
Surround: gives you new motion commands to manipulate surrounding parentheses, brackets and html tags. For example, let's say you are currently editing some HTML code, you are inside a <span> tag and realize that you want to turn it into a <div> tag. With this plugin this can be achieved by typing csttdiv, where cst means change surrounding tag, the second t means replace it with another tag, and div is simply the name of the replacing tag.
RainbowParentheses: to color parentheses, brackets, etc. according to their nesting level. This is quite helpful to quickly check the well-balancedness of a complex expression. I bind the <F3> key to toggle the rainbow colors on and off:
```
nnoremap <F3> :RainbowParenthesesToggleAll<cr>
```

Other plugins worth mentioning: NERDCommenter, Easymotion.

Python specific configuration

Python being a very popular language, there is a large ecosystem of tools to help Python developers checking, formatting, refactoring and doing static analysis of their code. If you do not want to spend too much time understanding and installing all these tools, a coherent sample of them has been bundled into the python-mode plugin.

I find the default configuration very reasonable. Here is a selected list of the features you will get by installing this plugin:

python-aware motions: M for the current method, C for the current class. For example, daM will delete the current method.
python-aware code folding. I don't like to have all my code folded when I open a file so I set the foldlevelstart to 99. I also set simpler shortcuts to toggle code-folding. Here is the related section of my .vimrc:
```
set foldlevelstart=99
nnoremap <Space> za
nnoremap <S-Space> zA
vnoremap <S-Space> zA
```
code completion/analysis/refactoring with Rope. The most useful shortcuts are described here. See :help ropevim.txt for more advanced commands.
pylint checking of your code. By default, pylint is run on your files every time you save them. I find this quite cumbersome so I disabled it with:
```
let g:pymode_lint_write = 0
```
and prefer to run it manually with the PyLint command.

Also, note that Python being a dynamic and weakly-typed language, it is hard to get good auto-completion. I have read some good things about jedi-vim auto-completion. If you want to try it out, you simply need to install this plugin after disabling rope's auto-completion:

let g:pymode_rope_vim_completion = 0

A nice thing about Python being an interpreted language is that it allows you to quickly test a snippet, update the definition of a function into an already loaded environment, etc. The python-mode plugin gives you the <Leader>r shortcut to run the current file through Python, but if you want something more fine-grained, I recommend the vim-ipython plugin. This plugin is still very rudimentary, but it already gives you the ability to send Python code to a running IPython kernel. Here is how I use it:

launch a terminal window and put it side-to-side with my Vim window
launch an IPython console in the terminal window with the ipython console command (this will also launch an IPython kernel)
run the :IPython command inside my Vim window to connect to the running IPython kernel
whenever I want to send some code (e.g. a function) and make it available to the IPython instance, I select it (e.g with vaM) and use the <Ctrl-s> shortcut.

One thing which is crucially missing is getting feedback from IPython back to Vim: for example, displaying error messages if the sent code is faulty or displaying python's output on the code execution.

Conclusion

Here are the commands to install all the plugins mentioned in this article:

# if using Pathogen, run these commands in ~/.vim/bundle

git clone https://github.com/scrooloose/nerdtree.git
git clone https://github.com/klen/python-mode.git
git clone https://github.com/kien/ctrlp.vim.git
git clone https://github.com/kien/rainbow_parentheses.vim.git
git clone https://github.com/majutsushi/tagbar.git
git clone https://github.com/vim-scripts/sessionman.vim.git
git clone https://github.com/tpope/vim-surround.git
git clone https://github.com/ivanov/vim-ipython.git
git clone https://github.com/tomasr/molokai.git

And the options to put in your .vimrc:

execute pathogen#infect()
filetype plugin indent on
syntax on

" you probably want more options here, see for example this excellent article
" http://stevelosh.com/blog/2010/09/coming-home-to-vim/

set foldlevelstart=99
nnoremap <Space> za
nnoremap <S-Space> zA
vnoremap <S-Space> zA

nnoremap <F1> :NERDTreeToggle<cr>
nnoremap <c-b> :CtrlPBuffer<cr>
nnoremap <F2> :TagbarToggle<cr>
nnoremap <F3> :RainbowParenthesesToggleAll<cr>

let g:pymode_lint_write = 0

How I solved my password problem

2013-03-05T23:00:00+01:00

Everybody knows that password reuse (using the same password on different services, websites, etc.) is a bad habit from the point of view of security. The reason is simple: if a single website where your password is used gets compromised, then somebody could get access to your password and consequently get access to your account on all the websites where you use the same password. You can get a full description of this phenomenon on XKCD.

On a less funny note, there have been countless stories of password breaches where password databases of major websites got compromised. These incidents revealed that very often, these websites do not follow even the very basic security practices to protect their user passwords.

Despite, having been well aware of this fact for years, I have never really taken the problem seriously, barely using a few different passwords depending on the level of trust I had in the websites. About one year ago, my Gmail account has been hacked and used to send spam emails to my contact list: it is a very unpleasant experience when you are being asked by one of your colleague to explain the “funny email” that was sent on your behalf... This is when I decided to have only single-purpose passwords. However, it quickly became apparent to me that I would need a proper set of tools to handle them. My requirements for this set of tools were the following:

the core of the solution had to be open-source: you can read Bruce Schneier's opinion about why open-source is good for security.
there had to be real-time synchronization of my passwords on the different machines I use.
there had to be a way to access my passwords on my phone, in the case where I need a password on a machine I do not use regularly.

The solution I found, which I have now been happily using for some time, is the combo: KeePassX + Dropbox + KeePassDroid.

KeePassX

Here is the description of KeePassX you can find on its official website:

KeePassX is an application for people with extremly high demands on secure personal data management. It has a light interface, is cross platform and published under the terms of the GNU General Public License.

KeePassX saves many different information e.g. user names, passwords, urls, attachments and comments in one single database. For a better management user-defined titles and icons can be specified for each single entry. Furthermore the entries are sorted in groups, which are customizable as well. The integrated search function allows to search in a single group or the complete database.

The idea behind KeePassX is simple: all your passwords are stored in a database which is encrypted by your master password (a password you choose when creating the database). Every time you launch KeePassX, the password has to be typed to unlock the database. Once it is unlocked, you have a nice and simple interface to add/delete/modify password, organize them in different subgroups, etc.

KeePassX interface

Let me mention here the killer-feature of KeePassX, autofill: it allows you to automatically fill your username and password in a login form by pressing a global shortcut. KeePassX decides which password to use on which website based on the window title that you associate with the password when creating it.

Dropbox

The password database being just a single file (with extension .kdb), the synchronization of my passwords across several computers was really easy to setup: I just added the database file to my Dropbox folder.

I am not fully satisfied by this part of the solution and would feel more comfortable if I were not relying on a third-party to store my passwords. However, the database file which is hosted by Dropbox is encrypted by my master password and I can live with this at the moment. Yet, I would be happy to find an open-source synchronization tool which stands comparison with Dropbox.

KeepassDroid

Finally, getting access to my passwords on my phone simply involved installting two applications found on Google Play (my phone runs Android): KeePassDroid and Dropbox.

The Dropbox app will take care of getting your password database file on your phone memory. Then, you can link the file to the KeePassDroid app by following these steps:

in the Dropbox app, navigate to your password database file and try to open it.
if you have the KeePassDroid app installed, you will have the option to open the file with it. Choose this option.
on the first screen presented to you, check the option "Use this as my default database" and type in your password.
you should now be able to navigate through your password database.

If you are an iPhone user, iKeePass should do the job.

Conclusion

I am not claiming that my solution is the perfect way to manage your passwords: this is just the solution I currently use, and it has worked well for me until now.

I know that some people have been successfully using LastPass: the approach is browser-based and very different from the one described in this article, but I would be interested to find a comparison of the two solutions from the point of view of usability.

Good practices in Python

2013-01-20T17:34:00+01:00

This post is a collection of various facts about Python:

common mistakes that I encounter frequently when reading code written by myself or other people.
specific features of the Python language that are not very well-known and that I think should be used more.
general recommendations regarding Python.

Please note that I do not consider myself a Python expert, so it is possible that the following text contains some inaccurate statements.

Also, due to its very nature, this post is rather unstructured. The table of contents should help you jumping directly to the part you are interested in.

List comprehensions
The multiples faces of in
Manipulating lists with atomic instructions
Exceptions
Values equivalent to True or False
Generators
Decorators
- A simple decorator
- Another example
Classes with two methods
PEP 8

List comprehensions

List comprehensions give Python users a very concise and powerful syntax to build a list from another list (or any iterable object). The syntax is the following:

result_list = [expression(item) for item in original_list if condition(item)]

which means that result_list will be a list containing expression(item) (an expression computed from item) for each item element of original_list for which condition(item) (a boolean expression involving item) is True. The boolean condition which allows you to filer the list is optional.

For example, to compute the list of squares of elements in a list, instead of:

l = [1, 2, 3]
result = []
for i in l:
    result.append(i*i)

which is particularly inefficient because of the repeated use of the append function, one could use a list comprehension:

l = [1, 2, 3]
result = [i*i for i in l] # result = [1, 4, 9]

In addition to being shorter, the above code is also faster (around 3x improvement) because you build the list in one instruction.

Another example to compute the list of square roots of all non-negative elements of a list (you could get in big troubles computing the square root of a negative element):

from math import sqrt

l = [4, -3, 9]
result = [sqrt(i) for i in l if i >= 0] # result = [2, 3]

The same syntax also exists for dictionaries, this is called dict comprehensions (very original, isn't it?). For example, to transform a list of (name, phone number) pairs into a dictionary, for faster lookup:

l = [("Barthes", "+33 6 29 64 91 12"), ("John", "+001 650 472 4243")]
d = {name: phone for (name, phone) in l}

You can get more details about list comprehensions on the dedicated section of the official documentation.

The multiples faces of `in`

The in keyword has many different meanings and makes Python code so easy to write that people often forget to use it.

in gives a universal syntax to iterate over iterable objects. For example, to iterate over a list, instead of:

l = [1, 2, 3]
for i in range(len(l)):
    print l[i]

you could simply write:

l = [1, 2,3]
for i in l:
    print i

similarly, to iterate over a dictionary, instead of:

d = { ... }
for key in d.keys():
    print d[key]

you could write:

d = { ... }
for key in d:
    print d[key]

in also allows you to test whether an element belongs to some structure: list, dictionary (or any iterable object), occurrence of a substring inside a string. For example:
```
l = [line for line in open("server.log") if "Connected" in line]
```
will return the list of lines from the file server.log containing Connected as a substring.

Manipulating lists with atomic instructions

More generally, it is advised to avoid iterating over a list with a for loop. for loops are slow in Python and writing an operation over a list as a single instruction allows Python to optimize the execution of the code internally.

List comprehensions often help in replacing an iteration by a single instruction. Here are a few other functions which can be helpful in this regard:

join can be useful to format a list. For example, to print the list of words whose first letter is a in a list of words. Instead of:

l = [ ... ]
result = ""
for word in l:
    if word[0] == 'a':
        result += word + " "
print result

you could do:

l = [ ... ]
print " ".join([word for word in l if word[0] == 'a'])

sum, to sum the elements of a list.

map, to apply a given function to all elements in a list. For example to reverse all the words in a list:

l = ["Adam", "Eve"]

def reverse(word):
    return word[::-1]

m = map(reverse, l) # m = ['madA', 'evE']

slices are also very useful when it comes to manipulating lists (or sublists) in blocks. Remember that if l is a list (or any iterable) l[begin:end:step] will extract all the elements from index begin (included) to index end (excluded) with a step of step (this last parameter being optional).

If the begin parameter is omitted, it is given 0 as default value. Similarly, the default value of end when unspecified is len(l) (the numbers of elements in l). A negative value for begin or end will be subtracted from the end of the list. For example, to extract all the element but the last one:

l = [1, 2, 3]
m = l[:-1] # m = [1, 2]

Using a negative value for the step parameter can be useful to walk through an iterable object in reverse order as shown in the example given above to take the mirror image of a word:

word = "dumbo"
drow = word[::-1] # drow = "obmud"

which compensates for the scandalous lack of a reverse function for strings in Python.

Exceptions

Exceptions provide a powerful tool found in many high-level programming languages which is often under-used. They allow for a less defensive programming style by handling errors as they appear instead of making test beforehand to prevent them from happening.

In Python, every time you are trying to execute an illegal operation (e. g. trying to access an element outside a list's boundaries, dividing by zero, etc.) instead of simply crashing the program, Python raises an exception which can be caught, giving the programmer a last chance to fix the problem before the program ultimately crashes.

The syntax to catch exceptions in Python is the following:

try:
    .... # piece of code potentially raising the exception named Kaboum
except Kaboum:
    .... # piece of code to be executed if the above code raises Kaboum

For example, if a line of code contains a division by a number which could seldom be equal to zero, instead of systematically checking that the number is non zero, it is much more efficient to encapsulate the line within a try ... except ZeroDivisionError: to handle specifically the rare cases when the number will be zero. This is the well-known principle: better ask for absolution than permission.

Another example, when trying to access an unbound key in a dictionary, Python raises the KeyError exception. This exception can be used to initialize the value associated with the unbound key. For example, to compute a dictionary of word counts in a text, you can often find:

text = "..."
result = {}
for word in text.split():
    if word in result:
        result[word] += 1
    else:
        result[word] = 1

You could instead use the KeyError exception to your advantage to avoid the systematic if test:

test = "..."
result = {}
for word in text.split():
    try:
        result[word] += 1
    except KeyError:
        result[word] = 1

The difference with the previous code is that most of the time, this code will behave exactly as if the body of the for loop only contained the instruction result[word] += 1. This gives a significant speedup compared to the first code where a test was computed for each iteration of the loop.

See the dedicated page in the official documentation.

Values equivalent to `True` or `False`

If test is a boolean variable (equal to True or False), we know that it is redundant to write:

if test == True:
    ...

instead of:

if test:
    ...

More generally, Python has automatic conversion rules from standard types to booleans. This can be used to shorten the syntax in conditional tests:

as in the vast majority of programming languages, a positive integer is converted to True and zero is converted to False.
a string is converted to False if and only if it is empty. For example, to test whether a string title is empty, you can simply write:
```
if title:
    ...
```
instead of:
```
if len(title) > 0:
     ...
```
the None value, a constant used to initialize unspecified variables, is converted to False. To test that a variable var is not equal to None, you can write:
```
if not var:
    ...
```
Beware, the above code will not allow you to distinguish the case where var is None from the case where var has a value which is converted to False by Python (for example, an empty string or list). You need to be careful that this is really what you are trying to test.

Generators

Generators provide an easy way to create iterator objects (objects over which you can iterate) and can be created in several ways.

Generator expressions

Generators expressions are exactly similar to list comprehensions except that the brackets are replaced by parenthesis. Thus, the following code:

l = [1, 2, 3]
m = (i*i for i in l)
print '\n'.join(m)

would produce the exact same result had the second line been replaced by:

m = [i*i for i in l]

The difference between the two codes is that in the case where m is defined by a list comprehension the list is integrally computed and stored in memory when the variable m is defined. On the contrary, when m is defined by a generator expression, the elements in m are generated on the go when needed: only when trying to iterate over the variable m (as induced by the call to the join function in the above example) are the elements generated.

From the speed of execution point of view, both solutions are equivalent: in the end, each element in m will be computed once and only once. From the memory usage point of view however, generators present a clear advantage: because the elements are generated dynamically, one at a time, never more than one element is stored in memory at the same time. In cases when the list is too big to fit into memory, generators could be the solution.

When using a generator expression as the argument of a function, Python allows to drop one pair of parenthesis to make the code more readable. For example, in the following code:

l = [1, 2, 3]
total = sum((i*i for i in l))

the second line can be replaced by:

total = sum(i*i for i in l)

Generator functions

A second way to define a generator is by writing a function using the special keyword yield. When called, this function will return an iterable object whose behavior is the following: on each iteration step, the function is executed until a yield instruction is hit. The value following the yield keyword is returned and can be used during the iteration step. The execution of the function is frozen until the next iteration step.

For example, let us define the following function:

def min_max(filename):
    with open(filename) as f:
        for line in f:
            l = map(int, line.split())
            yield min(l), max(l)

When called, this function will produce an iterable object. When iterating over this object, at each iteration, one line of filename will be read, and the minimum and maximum values of this line will be returned when the yield keyword is reached, freezing the execution of the function until the next iteration.

Hence, the following code:

for (inf, sup) in min_max(filename):
    print (inf + sup)/2.

is exactly equivalent to:

with open(filename) as f:
    for line in f:
        l = map(int, line.split())
        inf, sup = min(l), max(l)
        print (inf + sup)/2.

but allows you to define separately the code which will generate the list of minimum and maximum values, and the code which makes use of the generated elements.

Built-in functions

Finally, some built-in functions in Python return generator objects. This is the case of the xrange function which behaves exactly as the range function. The difference is that range computes a list of integers whereas xrange defines a generator object generating the elements on the go, one at a time. A call to range(1000000000) might induce a memory error on your machine (depending on your memory capacity), but you will be fine using xrange, both calls being equivalent for iteration purposes. It is almost always more suitable to use xrange instead of range and in Python 3.x xrange has even been renamed to range.

Read more about generators on the official documentation.

Decorators

Decorators provide a very powerful way to alter the behavior of a function without redifining it. The syntax is the following:

@logging
def f(x):
    return x + 1

In the above example, we say that f has been decorated with logging. logging must be a function taking another function as an argument. The result of this decoration is equivalent to this piece of code:

def f(x):
    return x + 1

f = logging(f)

which means that by decorating f with logging, f now behaves as the composite function logging(f).

A simple decorator

Imagine that we want the logging decorator to log the calls made to the function it decorates, by printing them to the standard output. Such a decorator could be written like this

def logging(fun):
    def aux(*args, **kwargs):
        print "Calling", fun.__name__
        fun(*args, **kwargs)
    return aux

Because logging could be used to decorate any function, with an arbitrary number of arguments and keyword arguments, it is necessary to use the generic syntax aux(*args, **kwargs). This syntax stores all the arguments passed to aux in a list named args and all the keyword arguments in a dictionary named kwargs. Note that the exact same arguments are passed to fun, meaning that from the argument passing perspective, aux and fun will behave similarly. The difference being that aux logs the call to the standard output prior to doing the computation made in fun: this is how we expected the decorator to behave.

To be perfectly rigorous, the previous decorator should have been written like this:

from functools import wraps

def logging(fun):
    @wraps(fun)
    def aux(*args, **kwargs):
        print "Calling", fun.__name__
        fun(*args, **kwargs)
    return aux

aux is now itself decorated by the wraps decorator provided by the functools module. This decorators does some magic to ensure that aux behaves as closely as possible to fun. Without this decorator, the following code:

@logging
def f(x):
    return x + 1

print f.__name__

would print aux to the standard output, instead of the expected f. The wraps decorator ensures among other things that the __name__ attribute is preserved throughout a decoration.

Let us further assume that you want to extend the logging decorator to not only log the calls, but also keep track of how many times the function has been called.

You could be tempted to write something like:

from functools import wraps

def logging(fun):
    a = 0
    @wraps(fun)
    def aux(*args, **kwargs):
        a = a + 1
        print "{0} has been called {1} times".format(fun.__name__, a)
        fun(*args, **kwargs)
    return aux

However, if you apply this decorator to some function and then call it, you will get an angry face from Python complaining that the variable a is unbound. The problem comes from this line:

a = a + 1

Here, Python thinks you are redefining the variable a and forgets about its previous definition. As a consequence, when reaching the a + 1 part, a is no longer defined, causing the error. This is a current limitation of Python 2: local variables that have been defined outside the current scope are read-only.

A standard way to circumvent this limitation is to use a mutable structure for a: a itself cannot be redefined, but the structure it is pointed to can. Using this, the previous example can be rewritten as:

from functools import wraps

def logging(fun):
    a = [0]
    @wraps(fun)
    def aux(*args, **kwargs):
        a[0] = a[0] + 1
        print "{0} has been called {1} times".format(fun.__name__, a[0])
        fun(*args, **kwargs)
    return aux

where a points to a list of length 1 storing the number of calls at its first position.

Another example

A common example which is often used to illustrate decorators in Python is memoization: when a function is computation-heavy but often called using the same arguments, you can save a lot of time by caching past results returned by the function.

This idea can be nicely implemented in Python using a decorator. The decorator will store past results in a dictionary: when the decorated function will be called, the decorator will perform a lookup in its dictionary to check whether the function has already been called with the same argument. If the dictionary already contains an entry for this argument, the associated value is returned.

Here is how you could write such a decorator for a single argument function:

from functools import wraps

def memoize(fun):
    cache = {}
    @wraps(fun)
    def aux(x):
        if x in cache:
            return cache[x]
        else:
            a = fun(x)
            cache[x] = a
            return a
    return aux

Then if f is defined like this:

@memoize
def f(x):
    ... # very long and heavy computation

when calling f twice with the same argument, you will incur the computation cost only during the first call, the second call being almost instantaneous.

Classes with two methods

Let us briefly recall how classes work in Python. A class is defined like this:

class Cipher:

    def __init__(self, key):
        self.key = key

    def decrypt(self, message):
        return (message & self.key)

all the methods of a class take as their first argument the instance on which the method is being called. By convention, this first arguments is always named self. If a is an instance of Cipher, the instruction a.decrypt(message) is equivalent to decrypt(a, message).

The special function __init__ is the class constructor and is called every time an instance of the class is created. Its typical use is to initialize some attributes of the instance. An instance of Cipher class can be created like this:

d = Cipher(key)

A flaw commonly found in code written by people coming from object-oriented programing languages is to create classes for everything. This often leads to classes containing only two methods, one being the __init__ function. This is the case in the class written above as an example. By looking to this example a bit closer, you can see that it is possible to completely get rid of the class definition: a decrypt function taking the key as an additional argument is sufficient:

def decrypt(key, message):
    return (message & key)

Some people could object that it still makes sense to use a class in the example above, if we plan to extend the Cypher class in the future, for example by adding an encrypt function. In my opinion, it is better to start by writing your code as simply as possible. If you really need to extend the code, then you can start restructuring it and group several related functions in a class.

PEP 8

When writing about good practices in Python, it is impossible not to mention the PEP8. It is a set of recommendations on coding style in Python. These recommendations are of course not absolute rules and should be taken as advice. However, I noticed that following these recommendations generally leads to greater code readability. Moreover, as many people who code in Python also follow these recommendations, adopting them reduces the gap between your code and code written by others: this will save you some time when reading code.

Here are a few points extracted from the PEP8:

you should follow English typographic rules: no space before a colon, no space before a comma, but a space after, etc.
you should put spaces around operators like the equal sign, plus sign, etc.
you should try to limit the length of the lines of code to a maximum of 80 characters.

More details on the PEP8 page.