W Pythonie redukcja() jest wbudowaną funkcją, która stosuje daną funkcję do elementów iterowalnych, redukując je do pojedynczej wartości.

Składnia funkcji redukcji() jest następująca:

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

• The argument funkcji to funkcja, która przyjmuje dwa argumenty i zwraca jedną wartość. Pierwszy argument to wartość skumulowana, a drugi argument to bieżąca wartość z iterowalnej.
• The iterowalne argument jest sekwencją wartości, które mają zostać zredukowane.
• Opcjonalny argument inicjatora służy do podania wartości początkowej dla skumulowanego wyniku. Jeśli nie określono inicjatora, pierwszy element iterowalnego jest używany jako wartość początkowa.

Oto przykład ilustrujący sposób użycia funkcji redukcji() w celu znalezienia sumy listy liczb:

który stworzył szkołę

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

Wyjście:

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

W tym przykładzie używamy funkcji redukcji(), aby zastosować funkcję dodawania, która zwraca sumę dwóch wartości dla każdej pary elementów na liście liczb, co daje sumę wszystkich elementów.

Użyjmy funkcji lambda jako pierwszego argumentu funkcji redukcji():

pyton __dict__

 # 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 

Rozważmy, jak zmniejszyć() funkcja działa dla podanego przykładu:

Funkcja redukcji() przyjmuje dwa argumenty: funkcję i wartość iterowalną. W tym przypadku używamy funkcji lambda lambda x, y: x * y jako funkcji i listy liczb jako iterowalnej.

• Funkcja lambda akceptuje zmienne x i y, mnoży je i zwraca wynik. Kiedy funkcja lambda jest początkowo uruchamiana, zmienne x i y są ustawiane odpowiednio na pierwszy i drugi element my_list (tj. x = 1 i y = 2). Funkcja lambda mnoży te dwie liczby i zwraca wynik (1 * 2 = 2).
• Przy drugim wywołaniu funkcji lambda x jest ustawiane na wynik poprzedniego wywołania (x = 2), a y na trzeci element listy liczb (tzn. y = 3). Mnoży te dwie wartości i zwraca wynik (2 * 3 = 6).
• Funkcja lambda jest wywoływana w ten sposób wielokrotnie dla każdego elementu na my_list, dopóki nie zostaną obsłużone wszystkie elementy. Funkcja redukcji() zwraca iloczyn wszystkich elementów listy, który następnie przypisywany jest do zmiennej iloczynu jako 120. Iloczyn ten jest obliczany w następujący sposób: ((((1 * 2) * 3)* 4)* 5) = 120.
• Na koniec drukujemy wartość zmiennej produktu za pomocą funkcji print(), która zwraca 120.

Funkcja redukcji() z funkcjami operatorowymi

Możemy sprawić, że nasz kod będzie bardziej zwięzły i łatwiejszy do odczytania, używając funkcji operatorskich zamiast funkcji lambda.

Oto przykład ilustrujący użycie funkcji operatorowych jako pierwszego argumentu funkcji redukcji:

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

Wyjście:

 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 

Ten kod pokazuje, jak używać funkcji redukcji() i funkcji operatora do wykonywania operacji matematycznych i operacji na ciągach znaków na obiektach iteracyjnych w Pythonie.

Zrozumienie różnicy między funkcjami redukcji() i akumulacji():

Moduł functools języka Python udostępnia funkcje redukcji() i akumulacji(), które działają na obiektach iteracyjnych w porównywalny sposób.

1. The zmniejszyć () I gromadzić () są podobne w tym sensie, że przyjmują dwa argumenty: samą iterację i funkcję opisującą operację, która ma zostać na niej wykonana. Jednak sposób, w jaki radzą sobie z wynikami operacji, jest tym, w czym najbardziej się od siebie różnią.
2. The zmniejszyć () wykonuje operację na pierwszych dwóch elementach iterowalności, a następnie uruchamia tę samą operację na wyniku i następnym elemencie. Proces ten jest powtarzany, aż wszystkie elementy iteracji zostaną przetworzone. Końcowy wynik operacji jest zwracany jako pojedynczy wynik.
3. Podczas gromadzić () stosuje również operację do pierwszych dwóch elementów iteracji przed wykonaniem tej samej operacji na wyniku i kolejnych elementach, funkcja akumuluj() zwraca iterator zawierający pośrednie wyniki operacji. Innymi słowy, po obsłużeniu każdego elementu, plik gromadzić () udostępnia serię wartości reprezentujących wynik operacji.

Przykład zrozumienia różnicy między akumulacją() a redukcją():

Java konwertuje znak na ciąg

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

W tym przykładzie mamy listę liczb [1, 2, 3, 4, 5]. Używamy zmniejszyć() obliczyć iloczyn wszystkich liczb, co zwróci pojedynczą wartość 120.

Używamy również gromadzić() obliczyć iloczyn wszystkich liczb. Jednak zamiast zwracać pojedynczą wartość, gromadzić() zwraca iterator, który daje sekwencję wyników pośrednich: [1, 2, 6, 24, 120].

A więc główna różnica między zmniejszyć() i akumuluj() polega na tym, że redukcja() zwraca pojedynczą wartość, która jest końcowym wynikiem operacji. W przeciwieństwie do metody akumuluj() zwraca iterator, który daje sekwencję wyników pośrednich.