The implementation differs greatly depending on which Python you're talking about. In Python 2.x it's written in C but the code is roughly equivalent to the following:

from itertools import izip 
              def map(f, lst, *lsts): 
                  result = [] 
                  for args in izip(lst, *lsts): 
                      result.append(f(*args)) 
                  return result

In Python 3.x the implementation is also written in C, but it returns an iterable instead of a list, so the work doesn't happen eagerly. It is equivalent to the following (since zip is also lazy in Python 3, this is a pretty good approximation of what goes on under the hood):

def map(f, lst, *lsts): 
                  for args in zip(lst, *lsts): 
                      yield f(*args)

To get the Python 3 behavior in Python 2, you can use  itertools.imap. To get Python 2 behavior in Python 3, you could use  list(map(…)).

From the official Python documentation:

map(function, iterable, ...)

Apply 

function to every item of 

iterable and return a list of the results.

If a function definition makes anything clear, it would look something like this:

def map(my_function, my_list): 
                  result = [] 
                  for i in my_list: 
                      result.append(my_function(i)) 
                  return result

But this is just simplifying since the map() function can process more than one iterable.

If additional 

iterable arguments are passed, 

function must take that many arguments and is applied to the items from all iterables in parallel. If one iterable is shorter than another it is assumed to be extended with None items. If

function is None, the identity function is assumed; if there are multiple arguments, 

 returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The 

iterable arguments may be a sequence or any iterable object; the result is always a list.

I'd just like to add that using the map() function seems obsolete because list comprehensions do the same work in a more comprehensible (ha!) and faster manner. my_list = [ my_function(x) for x in my_list]

---