In Python, reduce() è una funzione incorporata che applica una determinata funzione agli elementi di un iterabile, riducendoli a un singolo valore.

La sintassi per reduce() è la seguente:

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

• IL argomento della funzione è una funzione che accetta due argomenti e restituisce un singolo valore. Il primo argomento è il valore accumulato e il secondo argomento è il valore corrente dell'iterabile.
• IL iterabile argomento è la sequenza di valori da ridurre.
• L'argomento inizializzatore facoltativo viene utilizzato per fornire un valore iniziale per il risultato accumulato. Se non viene specificato alcun inizializzatore, il primo elemento dell'iterabile viene utilizzato come valore iniziale.

Ecco un esempio che dimostra come utilizzare reduce() per trovare la somma di un elenco di numeri:

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

Produzione:

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

In questo esempio utilizziamo la funzione reduce() per applicare una funzione add che restituisce la somma di due valori a ciascuna coppia di elementi nell'elenco dei numeri, ottenendo la somma di tutti gli elementi.

convertire nfa in dfa

Usiamo la funzione lambda come primo argomento della funzione reduce():

 # 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 

Analizziamo come ridurre() la funzione funziona per l'esempio fornito:

La funzione reduce() accetta due argomenti: una funzione e un iterabile. In questo caso, utilizziamo una funzione lambda lambda x, y: x * y come funzione e l'elenco dei numeri come iterabile.

• La funzione lambda accetta le variabili xey, le moltiplica e restituisce il risultato. Quando la funzione lambda viene inizialmente eseguita, le variabili x e y vengono impostate rispettivamente sul primo e sul secondo elemento di my_list (ovvero x = 1 e y = 2). La funzione lambda moltiplica questi due numeri e restituisce il risultato (1 * 2 = 2).
• La seconda volta che viene chiamata la funzione lambda, x viene impostato sul risultato della chiamata precedente (x = 2) e y viene impostato sul terzo elemento dell'elenco di numeri (ovvero, y = 3). Moltiplica questi due valori e restituisce il risultato (2 * 3 = 6).
• La funzione lambda viene chiamata ripetutamente in questo modo per ciascun elemento in my_list finché tutti gli elementi non sono stati gestiti. La funzione reduce() restituisce il prodotto di tutti gli elementi dell'elenco, che viene quindi assegnato alla variabile prodotto come 120. Questo prodotto viene calcolato come segue: ((((1 * 2) * 3)* 4)* 5) = 120.
• Infine, stampiamo il valore della variabile product utilizzando la funzione print(), che restituisce 120.

funzione reduce() con funzioni operatore

Possiamo rendere il nostro codice più conciso e più facile da leggere utilizzando le funzioni operatore invece delle funzioni lambda.

Ecco un esempio per dimostrare l'uso delle funzioni dell'operatore come primo argomento della funzione reduce:

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

Produzione:

 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 

Questo codice mostra come utilizzare la funzione reduce() e le funzioni dell'operatore per eseguire operazioni matematiche e su stringhe su elementi iterabili in Python.

eredità Java

Comprendere la differenza tra le funzioni reduce() e accumulate():

Il modulo functools di Python fornisce le funzioni reduce() e accumulate(), che operano entrambe sugli iterabili in modi comparabili.

1. IL ridurre () E accumulare () sono simili in quanto accettano entrambe due argomenti: l'iterabile stesso e una funzione che descrive l'operazione da eseguire su di esso. Il modo in cui gestiscono i risultati dell'operazione, tuttavia, è quello in cui divergono maggiormente l'uno dall'altro.
2. IL ridurre () esegue l'operazione sui primi due elementi dell'iterabile prima di eseguire la stessa operazione sul risultato e sull'elemento successivo. Questo processo viene ripetuto finché tutti gli elementi dell'iterabile non sono stati elaborati. L'output finale dell'operazione viene restituito come un unico risultato.
3. Mentre il accumulare () applica anche l'operazione ai primi due elementi dell'iterabile prima di eseguire la stessa operazione sul risultato e sugli elementi successivi, la funzione accumulate() restituisce un iteratore contenente i risultati intermedi dell'operazione. In altre parole, dopo che ogni elemento è stato gestito, il file accumulare () fornisce una serie di valori che rappresentano il risultato dell'operazione.

Un esempio per comprendere la differenza tra accumulate() e reduce():

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

In questo esempio, abbiamo un elenco di numeri [1, 2, 3, 4, 5]. Noi usiamo ridurre() per calcolare il prodotto di tutti i numeri, che restituisce un singolo valore di 120.

Usiamo anche accumulare() per calcolare il prodotto di tutti i numeri. Tuttavia, invece di restituire un singolo valore, accumulare() restituisce un iteratore che produce una sequenza di risultati intermedi: [1, 2, 6, 24, 120].

Quindi, la differenza principale tra ridurre() e accumulate() è che reduce() restituisce un singolo valore che è l'output finale dell'operazione. Al contrario, accumulate() restituisce un iteratore che produce una sequenza di risultati intermedi.