python map reduce filter

map

1. map(function, iterable, …)

   1. apply function to every item of iterable and return a list of the result

   2. if additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel

   3. if one iterable is shorter than another it is assumed to be extended with none items

   4. if function is none, the identity function is assumed

   5. if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation)

   6. the iterable arguments may be a sequence or any iterable object

   7. the result is always a list

reduce

1. reduce(function, iterable[, initializer])

   1. apply function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value

   2. e.g., reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5)

   3. the left argument, x, is the accumulated value and the right argument, y, is the update value from the iterable

   4. if the optional initializer is present, it is placed before the items of the iterable in the calculation, and serves as a default when the iterable is empty

   5. if initializer is not given and iterable contains only one item, the first item is returned.

2. demos

   1. make python list unique in functional way map reduce filter

       [1, 2, 2, 3, 3, 3, 4] => [1, 2, 3, 4]
      
       your_list = [1, 2, 2, 3, 3, 3, 4]
       print reduce(lambda x, y: x+[y] if x == [] or x[-1] != y else x, your_list, [])
       print reduce(lambda x, y: x+[y] if y not in x else x, your_list, [])
      
       [1, 2, 3, 4]
       [1, 2, 3, 4]
      
       your_list = [1, 3, 3, 2, 2, 3, 3, 3, 4]
       print reduce(lambda x, y: x+[y] if x == [] or x[-1] != y else x, your_list, [])
       print reduce(lambda x, y: x+[y] if y not in x else x, your_list, [])
      
       [1, 3, 2, 3, 4]
       [1, 3, 2, 4]
      

filter

1. filter(function, iterable)

   1. construct a list from those elements of iterable for which function returns true

   2. iterable may be either a sequence, a container which supports iteration, or an iterator

   3. if iterable is a string or a tuple, the result also has that type; otherwise it is always a list

   4. if function is none, the identity function is assumed, that is, all elements of iterable that are false are removed.

       note that
       filter(function, iterable) is equivalent to
       [item for item in iterable if function(item)] if function is not none and
       [item for item in iterable if item] if function is none.
      

fixed

1. how to use filter map and reduce in python 3 3 0

   1. map() and filter() return iterators

       use list comprehension
       correct transformation is to use a regular `for` loop
      
       [i for i in range(2, 25) if f(i)]
      
       [cube(i) for i in range(1, 11)]
      

   2. reduce() removed use functools.reduce()

       explicit use `for` loop