I Python er reduce() en innebygd funksjon som bruker en gitt funksjon på elementene i en iterabel, og reduserer dem til en enkelt verdi.

hva er awt

Syntaksen for reduce() er som følger:

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

• De funksjonsargument er en funksjon som tar to argumenter og returnerer en enkelt verdi. Det første argumentet er den akkumulerte verdien, og det andre argumentet er den nåværende verdien fra den iterable.
• De gjentakelig argument er sekvensen av verdier som skal reduseres.
• Det valgfrie initialiseringsargumentet brukes til å gi en startverdi for det akkumulerte resultatet. Hvis ingen initializer er spesifisert, brukes det første elementet i iterablen som startverdi.

Her er et eksempel som viser hvordan du bruker reduce() for å finne summen av en liste med tall:

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

Produksjon:

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

I dette eksemplet bruker vi redusere()-funksjonen til å bruke en add-funksjon som returnerer summen av to verdier til hvert par av elementer i talllisten, noe som resulterer i summen av alle elementene.

La oss bruke lambda-funksjonen som det første argumentet til redusere()-funksjonen:

 # 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 

La oss bryte ned hvordan redusere() funksjonen fungerer for eksemplet gitt:

Reduser()-funksjonen tar to argumenter: en funksjon og en iterabel. I dette tilfellet bruker vi en lambda-funksjon lambda x, y: x * y som funksjon, og talllisten som iterable.

• Lambda-funksjonen aksepterer variablene x og y, multipliserer dem og returnerer resultatet. Når lambda-funksjonen startes, settes variablene x og y til henholdsvis det første og andre elementet i my_list (dvs. x = 1 og y = 2). Lambda-funksjonen multipliserer disse to tallene og returnerer resultatet (1 * 2 = 2).
• Den andre gangen lambdafunksjonen kalles opp, settes x til resultatet av forrige samtale (x = 2), og y settes til det tredje elementet i talllisten (dvs. y = 3). Den multipliserer disse to verdiene og returnerer resultatet (2 * 3 = 6).
• Lambda-funksjonen kalles gjentatte ganger på denne måten for hvert element i my_list til alle elementene er håndtert. Reduser()-funksjonen returnerer produktet av alle listens elementer, som deretter tilordnes produktvariabelen som 120. Dette produktet beregnes som følger: ((((1 * 2) * 3)* 4)* 5) = 120.
• Til slutt skriver vi ut verdien til produktvariabelen ved å bruke print()-funksjonen, som gir ut 120.

reduce() funksjon med operatørfunksjoner

Vi kan gjøre koden vår mer kortfattet og lettere å lese ved å bruke operatørfunksjoner i stedet for lambdafunksjoner.

Her er et eksempel for å demonstrere bruken av operatørfunksjoner som det første argumentet for reduseringsfunksjon:

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

Produksjon:

 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 

Denne koden viser hvordan du bruker reduce()-funksjonen og operatorfunksjonene for å utføre matematiske operasjoner og strengoperasjoner på iterables i Python.

Java-opplæringer

Forstå forskjellen mellom redusere() og akkumulere() funksjoner:

Python functools-modulen gir funksjonene reduce() og accumulate(), som begge opererer på iterables på måter som er sammenlignbare.

1. De redusere () og akkumulere ()-funksjoner er like ved at de begge godtar to argumenter: selve den iterable og en funksjon som beskriver operasjonen som skal utføres på den. Måten de håndterer operasjonens utfall på er imidlertid der de avviker mest fra hverandre.
2. De redusere ()-funksjonen utfører operasjonen på iterables to første elementer før den kjører den samme operasjonen på resultatet og det neste elementet. Denne prosessen gjentas til alle elementene i iterablen er behandlet. Operasjonens endelige utgang returneres som et enkelt resultat.
3. Mens akkumulere ()-funksjonen bruker også operasjonen til iterablens to første elementer før den samme operasjonen utføres på resultatet og påfølgende elementer, accumulate()-funksjonen returnerer en iterator som inneholder operasjonens mellomresultater. Med andre ord, etter at hvert element har blitt håndtert, vil akkumulere ()-funksjonen gir en serie verdier som representerer operasjonens utfall.

Et eksempel for å forstå forskjellen mellom akkumulere() og redusere():

 # 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 dette eksemplet har vi en liste med tall [1, 2, 3, 4, 5]. Vi bruker redusere() for å beregne produktet av alle tallene, som returnerer én enkelt verdi på 120.

Vi bruker også akkumulere() å beregne produktet av alle tallene. Men i stedet for å returnere en enkelt verdi, akkumulere() returnerer en iterator som gir en sekvens med mellomresultater: [1, 2, 6, 24, 120].

Så, hovedforskjellen mellom redusere() og akkumulere() er at reduce() returnerer en enkelt verdi som er den endelige utgangen av operasjonen. Derimot returnerer accumulate() en iterator som gir en sekvens av mellomresultater.