I Python är reduce() en inbyggd funktion som tillämpar en given funktion på elementen i en iterabel, och reducerar dem till ett enda värde.

Syntaxen för reduce() är följande:

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

• De funktionsargument är en funktion som tar två argument och returnerar ett enda värde. Det första argumentet är det ackumulerade värdet och det andra argumentet är det aktuella värdet från den iterbara.
• De iterabel argument är sekvensen av värden som ska reduceras.
• Det valfria initialiseringsargumentet används för att tillhandahålla ett initialt värde för det ackumulerade resultatet. Om ingen initialiserare är angiven, används det första elementet i iterabeln som initialvärde.

Här är ett exempel som visar hur man använder reduce() för att hitta summan av en lista med tal:

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

Produktion:

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

I det här exemplet använder vi reduce()-funktionen för att tillämpa en add-funktion som returnerar summan av två värden till varje par av element i sifferlistan, vilket resulterar i summan av alla element.

Låt oss använda lambda-funktionen som det första argumentet för reduce()-funktionen:

 # 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 

Låt oss bryta ner hur minska() funktion fungerar för exemplet som ges:

Funktionen reduce() tar två argument: en funktion och en iterabel. I det här fallet använder vi en lambdafunktion lambda x, y: x * y som funktion, och siffrornas lista som iterabel.

• Lambdafunktionen accepterar variablerna x och y, multiplicerar dem och returnerar resultatet. När lambdafunktionen körs initialt sätts variablerna x och y till de första respektive andra elementen i my_list (dvs x = 1 och y = 2). Lambdafunktionen multiplicerar dessa två tal och returnerar resultatet (1 * 2 = 2).
• Andra gången lambdafunktionen anropas sätts x till resultatet av föregående anrop (x = 2), och y sätts till det tredje elementet i nummerlistan (dvs y = 3). Den multiplicerar dessa två värden och returnerar resultatet (2 * 3 = 6).
• Lambdafunktionen anropas upprepade gånger på detta sätt för varje element i my_list tills alla element har hanterats. Funktionen reduce() returnerar produkten av alla listans element, som sedan tilldelas produktvariabeln som 120. Denna produkt beräknas enligt följande: ((((1 * 2) * 3)* 4)* 5) = 120.
• Slutligen skriver vi ut värdet på produktvariabeln med funktionen print() som ger 120.

reduce() funktion med operatorfunktioner

Vi kan göra vår kod mer kortfattad och lättare att läsa genom att använda operatörsfunktioner istället för lambdafunktioner.

skillnaden mellan en gigabyte och en megabyte

Här är ett exempel för att demonstrera användningen av operatorfunktioner som det första argumentet för reduceringsfunktionen:

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

Produktion:

 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 

Den här koden visar hur man använder reduce()-funktion och operatorfunktioner för att utföra matematiska operationer och strängoperationer på iterables i Python.

Förstå skillnaden mellan reduce() och ackumulera() funktioner:

Python functools-modulen tillhandahåller funktionerna reduce() och accumulate(), som båda fungerar på iterables på sätt som är jämförbara.

1. De minska () och ackumulera ()-funktioner liknar varandra genom att de båda accepterar två argument: den iterbara i sig och en funktion som beskriver operationen som ska utföras på den. Sättet de hanterar operationens resultat är dock där de skiljer sig mest från varandra.
2. De minska ()-funktionen gör operationen på iterablens två första element innan samma operation körs på resultatet och nästa element. Denna process upprepas tills alla iterables element har bearbetats. Operationens slutresultat returneras som ett enda resultat.
3. Medan ackumulera ()-funktionen tillämpar också operationen på iterabelns två första element innan samma operation utförs på resultatet och efterföljande element, funktionen accumulate() returnerar en iterator som innehåller operationens mellanresultat. Med andra ord, efter att varje element har hanterats, ackumulera ()-funktionen tillhandahåller en serie värden som representerar operationens resultat.

Ett exempel för att förstå skillnaden mellan ackumulera() och reducera():

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

I det här exemplet har vi en lista med siffror [1, 2, 3, 4, 5]. Vi använder minska() för att beräkna produkten av alla siffror, vilket returnerar ett enda värde på 120.

Vi använder också ackumulera() för att beräkna produkten av alla siffror. Men istället för att returnera ett enda värde, ackumulera() returnerar en iterator som ger en sekvens av mellanresultat: [1, 2, 6, 24, 120].

Så den största skillnaden mellan minska() och ackumulera() är att reduce() returnerar ett enda värde som är den slutliga utgången av operationen. Däremot returnerar accumulate() en iterator som ger en sekvens av mellanliggande resultat.