Comment utiliser les fonctions filter, map et reduce en Python 3 ?

Question

filter , map y reduce fonctionnent parfaitement dans Python 2. Voici un exemple :

>>> def f(x):
        return x % 2 != 0 and x % 3 != 0
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]

>>> def cube(x):
        return x*x*x
>>> 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

Mais dans Python 3, je reçois les sorties suivantes :

>>> filter(f, range(2, 25))
<filter object at 0x0000000002C14908>

>>> map(cube, range(1, 11))
<map object at 0x0000000002C82B70>

>>> reduce(add, range(1, 11))
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    reduce(add, range(1, 11))
NameError: name 'reduce' is not defined

J'apprécierais que quelqu'un puisse m'expliquer pourquoi.

Capture d'écran du code pour plus de clarté :

Answer 1

Voici les exemples de fonctions Filter, map et reduce.

nombres = [10,11,12,22,34,43,54,34,67,87,88,98,99,87,44,66]

//Filtre

oddNumbers = list(filter(lambda x : x%2 != 0, numbers))

print(nombres impairs)

//Map

multiplyOf2 = list(map(lambda x : x*2, numbers))

print(multiplyOf2)

//Réduire

La fonction reduce, étant donné qu'elle n'est pas couramment utilisée, a été retirée des fonctions intégrées dans Python 3. Elle est toujours disponible dans le module functools, ce qui vous permet de faire :

from functools import reduce

sumOfNumbers = reduce(lambda x,y : x+y, numbers)

print(sumOfNumbers)

Answer 2

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

Il fonctionne tel quel. Pour obtenir la sortie de map, utilisez * ou list.

Answer 3

Lambda

Essayez de comprendre la différence entre une fonction normale définie par def et une fonction lambda. Voici un programme qui renvoie le cube d'une valeur donnée :

# 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)) 

sortie :

125
125

Sans utiliser Lambda :

• Ici, les deux renvoient le cube d'un nombre donné. Mais, en utilisant def, nous devions définir une fonction avec un nom cube et nous devions lui passer une valeur. Après l'exécution, nous devions également retourner le résultat de l'endroit où la fonction a été appelée en utilisant le mot-clé return.

Utilisation de Lambda :

• La définition lambda ne comprend pas d'instruction "return", elle contient toujours une expression qui est retournée. Nous pouvons également placer une définition lambda partout où une fonction est attendue, et nous n'avons pas à l'assigner à une variable du tout. C'est la simplicité des fonctions lambda.

---

Les fonctions lambda peuvent être utilisées avec des fonctions intégrées telles que filter() , map() y reduce() .

lambda() avec filter()

El filter() en Python prend une fonction et une liste comme arguments. Cela offre un moyen élégant de filtrer tous les éléments d'une séquence "séquence", pour laquelle la fonction renvoie 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 

sortie :

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

lambda() avec map()

El map() en Python prend en argument une fonction et une liste. La fonction est appelée avec une fonction lambda et une liste et une nouvelle liste est retournée qui contient tous les éléments modifiés par lambda retournés par cette fonction pour chaque élément.

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)

sortie :

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

réduire le site

reduce() fonctionne différemment de map() y filter() . Elle ne renvoie pas une nouvelle liste basée sur la liste function et l'itérable que nous avons passé. Au lieu de cela, il renvoie une seule valeur.

De même, dans Python 3 reduce() n'est plus une fonction intégrée, et elle peut être trouvée dans l'application functools module.

La syntaxe est la suivante :

reduce(function, sequence[, initial])

reduce() fonctionne en appelant le function que nous avons passé pour les deux premiers éléments de la séquence. Le résultat renvoyé par la méthode function est utilisé dans un autre appel à function à côté de l'élément suivant (le troisième dans ce cas).

L'argument facultatif initial est utilisé, lorsqu'il est présent, au début de cette "boucle" avec le premier élément du premier appel à function . D'une certaine manière, le initial est le 0e élément, avant le premier, lorsqu'il est fourni.

lambda() avec reduce()

La fonction reduce() en Python prend en argument une fonction et une liste. La fonction est appelée avec une fonction lambda et un itérable et un nouveau résultat réduit est retourné. Cette fonction effectue une opération répétitive sur les paires de l'itérable.

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

---

Ces fonctions sont des fonctions de commodité. Elles sont là pour vous éviter d'écrire un code plus lourd, mais évitez de trop les utiliser, ainsi que les expressions lambda, parce que "vous pouvez", car cela peut souvent conduire à un code illisible et difficile à maintenir. Ne les utilisez que lorsqu'il est absolument clair de savoir ce qui se passe dès que vous regardez la fonction ou l'expression lambda.