map() and list comprehension are roughly equivalent:
map(function, list1)
[function(i) for i in list1]
What if the function we want to use is a method?
[i.function() for i in list1]
map(.function, list1) # error!
map(run_method(function), list1) # error!
How could I perform this kind of manipulation with map?
You'd use operator.methodcaller():
from operator import methodcaller
map(methodcaller('function'), list1)
methodcaller() accepts additional arguments that are then passed into the called method; methodcaller('foo', 'bar', spam='eggs')(object) is the equivalent of object.foo('bar', spam='eggs').
If all objects in list1 are the same type or subclasses of that type, and the method you want to call doesn't take any arguments, you can pass in the unbound method to map as the function to call. For example, to lowercase all strings in a list, you can use:
map(str.lower, list_of_strings)
where str.lower is the unbound method on the str type.
Note that a list comprehension is not really the equivalent of a map() here. map() can only do one loop, entirely in C. map() will zip() multiple iterable arguments, and map() in Python 3 is itself an iterator.
A list comprehension on the other hand can do multiple (nested) loops and add in filtering, and the left-hand expression can be any valid Python expression including nested list comprehensions.
You could invoke the method directly using the type of the object.
map(lambda x: type(x).function(), list1)
which is not much more exciting than the more straightforward
map(lambda x: x.function(), list1)
However, it does point out that it would be nice if Python had a function composition operator, something like f**g(x) == f(g(x)). Then you could write
map(type**function, list1)
type() call in a lambda is rather pointless as it just means your are mapping objects to dereference just the method. It only becomes interesting if all objects in the list are the same type and you use a direct reference to the unbound method in the