A map is used to :

Apply function to every item of iterable and return a list of the results. [...] The iterable arguments may be a sequence or any iterable object; the result is always a list.

Let’s create a function that simply adds 1 to any number:

def addone(x): return x+1 |

Let’s define a list of numbers. If we call the function addone() on every item of “numbers”, we get the following:

numbers = [0,1,2,3,4] print map(addone, numbers) >>> [1, 2, 3, 4, 5] |

If we wanted, we could actually do this with a list comprehension – it’s just a little longer – something like this:

print [addone(x) for x in numbers] >>> [1, 2, 3, 4, 5] |

So map() is actually just an efficient shortcut for a loop that calls the function on every item:

added_numbers = [] for number in numbers: added_numbers.append(addone(number)) print added_numbers >>> [1, 2, 3, 4, 5] |

But now our code is getting out of hand…Let’s try something else. We can pass multiple arguments to a map(), which have to all be of the same size. Otherwise they will be defaulted to None.

Let’s say we have a multiplier function:

def multiply(x, y): return x*y |

Now let’s create two lists of numbers to be multiplied together, and use map() to do so:

numbers = [0,1,2,3,4] multipliers = [10, 20, 30, 40, 50] print map(multiply, numbers, multipliers) >>> [0, 20, 60, 120, 200] |

Same result, with a list comprehension (slightly longer) :

print [multiply(numbers[x], multipliers[x]) for x in xrange(len(numbers))] >>> [0, 20, 60, 120, 200] |

And just to be fully ridiculous, with the complete loop :

multiplied_numbers = [] for number_index in xrange(len(numbers)): multiplied_numbers.append(multiply(numbers[number_index], multipliers[number_index])) print multiplied_numbers >>> [0, 20, 60, 120, 200] |

But really, don’t do this. Just use map()!