# python map()

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()!