How to use filter map and reduce in Python 3

Question

filter  map  and reduce work perfectly in Python 2  Here is an example    gt  gt  gt  def f x           return x   2    0 and x   3    0  gt  gt  gt  filter f  range 2  25    5  7  11  13  17  19  23    gt  gt  gt  def cube x           return x x x  gt  gt  gt  map cube  range 1  11    1  8  27  64  125  216  343  512  729  1000    gt  gt  gt  def add x y           return x y  gt  gt  gt  reduce add  range 1  11   55   But in Python 3  I receive the following outputs    gt  gt  gt  filter f  range 2  25    lt filter object at 0x0000000002C14908 gt    gt  gt  gt  map cube  range 1  11    lt map object at 0x0000000002C82B70 gt    gt  gt  gt  reduce add  range 1  11   Traceback  most recent call last     File   lt pyshell 8 gt    line 1  in  lt module gt      reduce add  range 1  11   NameError  name  reduce  is not defined   I would appreciate if someone could explain to me why this is   Screenshot of code for further clarity

User · Answer

Lambda

Try to understand the difference between a normal def defined function and lambda function. This is a program that returns the cube of a given value:

# Python code to illustrate cube of a number 
# showing difference between def() and lambda(). 
def cube(y): 
    return y*y*y 
  
lambda_cube = lambda y: y*y*y 
  
# using the normally 
# defined function 
print(cube(5)) 
  
# using the lamda function 
print(lambda_cube(5))

output:

125
125

Without using Lambda:

Here, both of them return the cube of a given number. But, while using def, we needed to define a function with a name cube and needed to pass a value to it. After execution, we also needed to return the result from where the function was called using the return keyword.

Using Lambda:

Lambda definition does not include a “return” statement, it always contains an expression that is returned. We can also put a lambda definition anywhere a function is expected, and we don’t have to assign it to a variable at all. This is the simplicity of lambda functions.

Lambda functions can be used along with built-in functions like filter(), map() and reduce().

lambda() with filter()

The filter() function in Python takes in a function and a list as arguments. This offers an elegant way to filter out all the elements of a sequence “sequence”, for which the function returns True.

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

new_list = list(filter(lambda x: (x%2 == 0) , my_list))

print(new_list)


ages = [13, 90, 17, 59, 21, 60, 5]

adults = list(filter(lambda age: age>18, ages)) 
  
print(adults) # above 18 yrs

output:

[4, 6, 8, 12]
[90, 59, 21, 60]

lambda() with map()

The map() function in Python takes in a function and a list as an argument. The function is called with a lambda function and a list and a new list is returned which contains all the lambda modified items returned by that function for each item.

my_list = [1, 5, 4, 6, 8, 11, 3, 12]

new_list = list(map(lambda x: x * 2 , my_list))

print(new_list)


cities = ['novi sad', 'ljubljana', 'london', 'new york', 'paris'] 
  
# change all city names 
# to upper case and return the same 
uppered_cities = list(map(lambda city: str.upper(city), cities)) 
  
print(uppered_cities)

output:

[2, 10, 8, 12, 16, 22, 6, 24]
['NOVI SAD', 'LJUBLJANA', 'LONDON', 'NEW YORK', 'PARIS']

reduce

reduce() works differently than map() and filter(). It does not return a new list based on the function and iterable we've passed. Instead, it returns a single value.

Also, in Python 3 reduce() isn't a built-in function anymore, and it can be found in the functools module.

The syntax is:

reduce(function, sequence[, initial])

reduce() works by calling the function we passed for the first two items in the sequence. The result returned by the function is used in another call to function alongside with the next (third in this case), element.

The optional argument initial is used, when present, at the beginning of this "loop" with the first element in the first call to function. In a way, the initial element is the 0th element, before the first one, when provided.

lambda() with reduce()

The reduce() function in Python takes in a function and a list as an argument. The function is called with a lambda function and an iterable and a new reduced result is returned. This performs a repetitive operation over the pairs of the iterable.

from functools import reduce

my_list = [1, 1, 2, 3, 5, 8, 13, 21, 34] 

sum = reduce((lambda x, y: x + y), my_list) 

print(sum) # sum of a list
print("With an initial value: " + str(reduce(lambda x, y: x + y, my_list, 100)))

88
With an initial value: 188

These functions are convenience functions. They are there so you can avoid writing more cumbersome code, but avoid using both them and lambda expressions too much, because "you can", as it can often lead to illegible code that's hard to maintain. Use them only when it's absolutely clear what's going on as soon as you look at the function or lambda expression.

User · Answer

One of the advantages of map  filter and reduce is how legible they become when you  chain  them together to do something complex  However  the built-in syntax isn t legible and is all  backwards   So  I suggest using the PyFunctional package  https   pypi org project PyFunctional     Here s a comparison of the two   flight destinations dict     NY     London    Rome     Berlin     NY      PyFunctional version    Very legible syntax  You can say       I have a sequence of flight destinations   Out of which I want to get   the dict key if city is in the dict values   Finally  filter out the   empty lists I created in the process     from functional import seq    PyFunctional package to allow easier syntax  def find return flights PYFUNCTIONAL SYNTAX city  flight destinations dict       return seq flight destinations dict items               map lambda x  x 0  if city in x 1  else                filter lambda x  x            Default Python version   It s all backwards  You need to say       OK  so  there s a list   I want to filter empty lists out of it   Why    Because I first got the dict key if the city was in the dict values     Oh  the list I m doing this to is flight destinations dict     def find return flights DEFAULT SYNTAX city  flight destinations dict       return list          filter lambda x  x                       map lambda x  x 0  if city in x 1  else     flight destinations dict items

User · Answer

from functools import reduce  def f x       return x   2    0 and x   3    0  print  filter f  range 2  25      5  7  11  13  17  19  23   def cube x       return x  3 print  map cube  range 1  11      1  8  27  64  125  216  343  512  729  1000   def add x y       return x y  reduce add  range 1  11    55  It works as is   To get the output of map use   or list

User · Answer

Since the reduce method has been removed from the built in function from Python3  don t forget to import the functools in your code  Please look at the code snippet below   import functools my list    10 15 20 25 35  sum numbers   functools reduce lambda x  y   x y   my list  print sum numbers

User · Answer

The functionality of map and filter was intentionally changed to return iterators  and reduce was removed from being a built-in and placed in functools reduce   So  for filter and map  you can wrap them with list   to see the results like you did before    gt  gt  gt  def f x   return x   2    0 and x   3    0      gt  gt  gt  list filter f  range 2  25     5  7  11  13  17  19  23   gt  gt  gt  def cube x   return x x x      gt  gt  gt  list map cube  range 1  11     1  8  27  64  125  216  343  512  729  1000   gt  gt  gt  import functools  gt  gt  gt  def add x y   return x y      gt  gt  gt  functools reduce add  range 1  11   55  gt  gt  gt    The recommendation now is that you replace your usage of map and filter with generators expressions or list comprehensions   Example    gt  gt  gt  def f x   return x   2    0 and x   3    0      gt  gt  gt   i for i in range 2  25  if f i    5  7  11  13  17  19  23   gt  gt  gt  def cube x   return x x x      gt  gt  gt   cube i  for i in range 1  11    1  8  27  64  125  216  343  512  729  1000   gt  gt  gt    They say that for loops are 99 percent of the time easier to read than reduce  but I d just stick with functools reduce   Edit  The 99 percent figure is pulled directly from the What   s New In Python 3 0 page authored by Guido van Rossum

User · Answer

You can read about the changes in What s New In Python 3 0  You should read it thoroughly when you move from 2 x to 3 x since a lot has been changed  The whole answer here are quotes from the documentation  Views And Iterators Instead Of Lists  Some well-known APIs no longer return lists         map   and filter   return iterators  If you really need a list  a quick fix is e g  list map        but a better fix is often to use a list comprehension  especially when the original code uses lambda   or rewriting the code so it doesn   t need a list at all  Particularly tricky is map   invoked for the side effects of the function  the correct transformation is to use a regular for loop  since creating a list would just be wasteful           Builtins         Removed reduce    Use functools reduce   if you really need it  however  99 percent of the time an explicit for loop is more readable

User · Answer

Here are the examples of Filter  map and reduce functions                  numbers    10 11 12 22 34 43 54 34 67 87 88 98 99 87 44 66              Filter                 oddNumbers   list filter lambda x  x 2    0  numbers                print oddNumbers              Map                 multiplyOf2   list map lambda x  x 2  numbers                print multiplyOf2              Reduce  The reduce function  since it is not commonly used  was removed from the built-in functions in Python 3  It is still available in the functools module  so you can do                  from functools import reduce              sumOfNumbers   reduce lambda x y  x y  numbers               print sumOfNumbers

User · Answer

As an addendum to the other answers  this sounds like a fine use-case for a context manager that will re-map the names of these functions to ones which return a list and introduce reduce in the global namespace   A quick implementation might look like this   from contextlib import contextmanager       contextmanager def noiters  funcs       if not funcs           funcs    map  filter  zip    etc     from functools import reduce     globals   reduce   name      reduce     for func in funcs          globals   func   name      lambda  ar  func   func    kwar  list func  ar    kwar       try          yield     finally          del globals   reduce   name            for func in funcs  globals   func   name      func   With a usage that looks like this   with noiters map       from operator import add     print reduce add  range 1  20        print map int    1    2       Which prints   190  1  2    Just my 2 cents  -

[python] How to use filter, map, and reduce in Python 3

Lambda

lambda() with filter()

lambda() with map()

reduce

lambda() with reduce()

Examples related to python

Examples related to python-3.x

Examples related to filter

Examples related to functional-programming

Examples related to reduce