A Pythonban a redukció() egy beépített függvény, amely egy adott függvényt alkalmaz egy iterálható elemre, egyetlen értékre redukálva azokat.

az oracle sql nem egyenlő

A Reduction() szintaxisa a következő:

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

• A függvény argumentum egy olyan függvény, amely két argumentumot vesz fel, és egyetlen értéket ad vissza. Az első argumentum a felhalmozott érték, a második pedig az iterálható aktuális érték.
• A iterálható Az argumentum a redukálandó értékek sorozata.
• Az opcionális inicializáló argumentum a halmozott eredmény kezdeti értékének megadására szolgál. Ha nincs megadva inicializáló, akkor az iterálható elem első eleme lesz kezdeti érték.

Íme egy példa, amely bemutatja, hogyan kell a redukció() használatával megkeresni egy számlista összegét:

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

Kimenet:

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

Ebben a példában a Reduction() függvényt használjuk egy add függvény alkalmazására, amely két érték összegét adja vissza a számlista minden elempárjához, így az összes elem összegét kapjuk.

Használjuk a lambda függvényt a redukció() függvény első argumentumaként:

 # 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 

Bontsuk fel, hogyan a csökkenti() függvény működik a megadott példában:

A redukció() függvénynek két argumentuma van: egy függvény és egy iterálható. Ebben az esetben a lambda x, y: x * y lambda függvényt használjuk függvényként, és a számlistát iterálhatóként.

java karakterlánc formázás

• A lambda függvény elfogadja az x és y változókat, megszorozza őket, és visszaadja az eredményt. A lambda függvény kezdeti futtatásakor az x és y változók a my_list első és második elemére lesznek beállítva (azaz x = 1 és y = 2). A lambda függvény ezt a két számot megszorozza, és az eredményt adja vissza (1 * 2 = 2).
• A lambda függvény második meghívásakor x az előző hívás eredményére (x = 2), y pedig a számlista harmadik elemére (azaz y = 3) lesz beállítva. Ezt a két értéket megszorozza, és az eredményt adja vissza (2 * 3 = 6).
• A lambda függvény ilyen módon ismételten meghívásra kerül a my_list minden elemére, amíg az összes elemet le nem kezelték. A redukció() függvény a lista összes elemének szorzatát adja vissza, amelyet ezután a 120-as szorzatváltozóhoz rendelünk. Ezt a szorzatot a következőképpen számítjuk ki: ((((1 * 2) * 3)* 4)* 5) = 120.
• Végül a print() függvény segítségével kiírjuk a termékváltozó értékét, amely 120-at ad ki.

Reduction() függvény operátorfüggvényekkel

Kódunkat tömörebbé és könnyebben olvashatóvá tehetjük, ha lambda függvények helyett operátorfüggvényeket használunk.

Íme egy példa, amely bemutatja az operátorfüggvények használatát a redukciós függvény első argumentumaként:

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

Kimenet:

 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 

Ez a kód megmutatja, hogyan használhatók a Reduction() függvények és az operátorfüggvények matematikai és karakterlánc-műveletek végrehajtására a Python iterálható elemein.

fordított karakterlánc java-ban

A redukció() és az collect() függvények közötti különbség megértése:

A Python functools modulja biztosítja a redukció() és az akumul() függvényeket, amelyek összehasonlítható módon működnek az iterálható elemeken.

karaktert karakterláncra alakítani

1. A csökkenteni () és felhalmozódnak () függvények abban hasonlítanak, hogy mindkettő két argumentumot fogad el: magát az iterálhatóságot és egy függvényt, amely leírja a rajta végrehajtandó műveletet. Az a mód azonban, ahogyan kezelik a művelet eredményeit, ott térnek el leginkább egymástól.
2. A csökkenteni () függvény végrehajtja a műveletet az iterálható első két elemén, mielőtt ugyanazt a műveletet futtatná az eredményre és a következő elemre. Ezt a folyamatot addig ismételjük, amíg az iterálható összes eleme fel nem készül. A művelet végső kimenete egyetlen eredményként jelenik meg.
3. Amíg a felhalmozódnak () függvény a műveletet az iterálható első két elemére is alkalmazza, mielőtt ugyanazt a műveletet végrehajtaná az eredményre és az azt követő elemekre, az akumul() függvény egy iterátort ad vissza, amely a művelet közbenső eredményeit tartalmazza. Más szavakkal, az egyes elemek kezelése után a felhalmozódnak () függvény a művelet eredményét reprezentáló értéksorozatot biztosít.

Példa az akkumulátor() és a redukció() közötti különbség megértésére:

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

Ebben a példában van egy számlistánk [1, 2, 3, 4, 5]. Használjuk csökkenti() az összes szám szorzatának kiszámításához, amely egyetlen 120-as értéket ad vissza.

Mi is használjuk felhalmoz() hogy kiszámoljuk az összes szám szorzatát. Ahelyett azonban, hogy egyetlen értéket adna vissza, felhalmoz() egy iterátort ad vissza, amely köztes eredmények sorozatát adja: [1, 2, 6, 24, 120].

Tehát a fő különbség között csökkenti() és az akumul() az, hogy a redukció() egyetlen értéket ad vissza, amely a művelet végső kimenete. Ezzel szemben azakumul() egy iterátort ad vissza, amely közbenső eredmények sorozatát adja.