Reputation: 18219
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
?
Upvotes: 8
Views: 3687
Reputation: 1122342
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.
Upvotes: 18
Reputation: 531345
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)
Upvotes: 1