En Python, réduire() est une fonction intégrée qui applique une fonction donnée aux éléments d'un itérable, les réduisant à une seule valeur.

La syntaxe de réduire() est la suivante :

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

• Le argument de fonction est une fonction qui prend deux arguments et renvoie une seule valeur. Le premier argument est la valeur accumulée et le deuxième argument est la valeur actuelle de l'itérable.
• Le itérable L’argument est la séquence de valeurs à réduire.
• L'argument d'initialisation facultatif est utilisé pour fournir une valeur initiale pour le résultat accumulé. Si aucun initialiseur n'est spécifié, le premier élément de l'itérable est utilisé comme valeur initiale.

Voici un exemple qui montre comment utiliser réduire() pour trouver la somme d'une liste de nombres :

qui a fait l'école

 # Examples to understand the reduce() function from functools import reduce # Function that returns the sum of two numbers def add(a, b): return a + b # Our Iterable num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # add function is passed as the first argument, and num_list is passed as the second argument sum = reduce(add, num_list) print(f'Sum of the integers of num_list : {sum}') # Passing 10 as an initial value sum = reduce(add, num_list, 10) print(f'Sum of the integers of num_list with initial value 10 : {sum}') 

Sortir:

 Sum of the integers of num_list : 55 Sum of the integers of num_list with initial value 10 : 65 

Dans cet exemple, nous utilisons la fonction réduire() pour appliquer une fonction d'ajout qui renvoie la somme de deux valeurs à chaque paire d'éléments de la liste de nombres, ce qui donne la somme de tous les éléments.

Utilisons la fonction lambda comme premier argument de la fonction réduire() :

Sanjay Dutt et

 # Importing reduce function from functools from functools import reduce # Creating a list my_list = [1, 2, 3, 4, 5] # Calculating the product of the numbers in my_list # using reduce and lambda functions together product = reduce(lambda x, y: x * y, my_list) # Printing output print(f'Product = {product}') # Output : Product = 120 

Décrivons comment le réduire() la fonction fonctionne pour l'exemple donné :

La fonction réduire() prend deux arguments : une fonction et un itérable. Dans ce cas, nous utilisons une fonction lambda lambda x, y: x * y comme fonction et la liste de nombres comme itérable.

• La fonction lambda accepte les variables x et y, les multiplie et renvoie le résultat. Lorsque la fonction lambda est initialement exécutée, les variables x et y sont définies respectivement sur le premier et le deuxième éléments de my_list (c'est-à-dire x = 1 et y = 2). La fonction lambda multiplie ces deux nombres et renvoie le résultat (1 * 2 = 2).
• La deuxième fois que la fonction lambda est appelée, x est défini sur le résultat de l'appel précédent (x = 2) et y est défini sur le troisième élément de la liste de nombres (c'est-à-dire y = 3). Il multiplie ces deux valeurs et renvoie le résultat (2 * 3 = 6).
• La fonction lambda est appelée de cette manière à plusieurs reprises pour chaque élément de my_list jusqu'à ce que tous les éléments aient été gérés. La fonction réduire() renvoie le produit de tous les éléments de la liste, qui est ensuite affecté à la variable produit comme 120. Ce produit est calculé comme suit : ((((1 * 2) * 3)* 4)* 5) = 120.
• Enfin, nous imprimons la valeur de la variable produit à l'aide de la fonction print(), qui génère 120.

Fonction réduire() avec fonctions d'opérateur

Nous pouvons rendre notre code plus concis et plus facile à lire en utilisant des fonctions d'opérateur au lieu de fonctions lambda.

Voici un exemple pour démontrer l'utilisation des fonctions d'opérateur comme premier argument de la fonction de réduction :

 # Python program to demonstrate # how to use operator functions with reduce function # Importing reduce function from functools import reduce # Importing operator import operator # Creating lists my_list1 = [1, 2, 3, 4, 5] my_list2 = ['I', 'Love', 'Javatpoint'] # Calculating the sum of the numbers of my_list1 # using reduce and operator.add sum = reduce(operator.add, my_list1) # Calculating the product of the numbers of my_list1 # using reduce and operator.mul product = reduce(operator.mul, my_list1) # Concatenating all the elements in my_list2 # using reduce and operator.concat concated_str1 = reduce(operator.concat, my_list2) # We can achieve the same output by using operator.add concated_str2 = reduce(operator.add, my_list2) # Printing result print(f'Sum of all elements in my_list1 : {sum}') print(f'Product of all elements in my_list1 : {product}') print(f'Concatenated string by using operator.concat : {concated_str1}') print(f'Concatenated string by using operator.add : {concated_str2}') 

Sortir:

 Sum of all elements in my_list1 : 15 Product of all elements in my_list1 : 120 Concatenated string by using operator.concat : ILoveJavatpoint Concatenated string by using operator.add : ILoveJavatpoint 

Ce code montre comment utiliser la fonction réduire() et les fonctions d'opérateur pour effectuer des opérations mathématiques et de chaîne sur les itérables en Python.

Comprendre la différence entre les fonctions réduire() et accumuler() :

Le module Python functools fournit les fonctions réduire() et accumuler(), qui fonctionnent toutes deux sur les itérables de manière comparable.

1. Le réduire () et accumuler () les fonctions sont similaires dans le sens où elles acceptent toutes deux deux arguments : l'itérable lui-même et une fonction qui décrit l'opération à effectuer sur celui-ci. Toutefois, c'est dans la façon dont ils gèrent les résultats de l'opération qu'ils divergent le plus les uns des autres.
2. Le réduire () effectue l'opération sur les deux premiers éléments de l'itérable avant d'exécuter la même opération sur le résultat et l'élément suivant. Ce processus est répété jusqu'à ce que tous les éléments de l'itérable aient été traités. Le résultat final de l’opération est renvoyé sous la forme d’un résultat unique.
3. Tandis que le accumuler () applique également l'opération aux deux premiers éléments de l'itérable avant d'effectuer la même opération sur le résultat et les éléments suivants, la fonction accumulate() renvoie un itérateur contenant les résultats intermédiaires de l'opération. En d'autres termes, après que chaque élément a été manipulé, le accumuler () fournit une série de valeurs représentant le résultat de l'opération.

Un exemple pour comprendre la différence entre accumuler() et réduire() :

commence avec Java

 # Python Program to demonstrate the difference # between reduce and accumulate # Importing reduce and accumulate function from functools import reduce, accumulate # Creating a list my_list = [1, 2, 3, 4, 5] # Using reduce() to calculate the product of all numbers product = reduce(lambda x, y: x * y, my_list) print(f'Product using reduce() : {product}') # Output: 120 # Using accumulate() to calculate the product of all numbers products = list(accumulate(my_list, lambda x, y: x * y)) print(f'Products using accumulate() : {products}')# Output: [1, 2, 6, 24, 120] 

Dans cet exemple, nous avons une liste de nombres [1, 2, 3, 4, 5]. Nous utilisons réduire() pour calculer le produit de tous les nombres, qui renvoie une valeur unique de 120.

Nous utilisons également accumuler() pour calculer le produit de tous les nombres. Cependant, au lieu de renvoyer une seule valeur, accumuler() renvoie un itérateur qui produit une séquence de résultats intermédiaires : [1, 2, 6, 24, 120].

Donc, la principale différence entre réduire() et accumulate() est que réduire() renvoie une valeur unique qui est le résultat final de l'opération. En revanche, accumulate() renvoie un itérateur qui produit une séquence de résultats intermédiaires.