ב-Python, reduce() היא פונקציה מובנית המיישמת פונקציה נתונה על האלמנטים של איטרבל, ומקטינה אותם לערך בודד.

התחביר עבור reduce() הוא כדלקמן:

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

• ה ארגומנט פונקציה היא פונקציה שלוקחת שני ארגומנטים ומחזירה ערך בודד. הארגומנט הראשון הוא הערך המצטבר, והארגומנט השני הוא הערך הנוכחי מהחזרה.
• ה ניתן לחזרה ארגומנט הוא רצף הערכים שיש להקטין.
• ארגומנט האתחול האופציונלי משמש כדי לספק ערך התחלתי עבור התוצאה המצטברת. אם לא צוין אתחול, הרכיב הראשון של האיטרבל משמש כערך ההתחלתי.

הנה דוגמה שמדגימה כיצד להשתמש ב-reduce() כדי למצוא את הסכום של רשימת מספרים:

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

תְפוּקָה:

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

בדוגמה זו, אנו משתמשים בפונקציה reduce() כדי להחיל פונקציה add שמחזירה את הסכום של שני ערכים לכל זוג אלמנטים ברשימת המספרים, וכתוצאה מכך סכום כל האלמנטים.

הבה נשתמש בפונקציית lambda כארגומנט הראשון של הפונקציה 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 

בואו נפרק כיצד לְהַפחִית() הפונקציה עובדת עבור הדוגמה שניתנה:

הפונקציה reduce() לוקחת שני ארגומנטים: פונקציה ו-Iterable. במקרה זה, אנו משתמשים בפונקציית lambda lambda x, y: x * y כפונקציה, וברשימת המספרים כחזרה.

• פונקציית lambda מקבלת את המשתנים x ו-y, מכפילה אותם ומחזירה את התוצאה. כאשר פונקציית lambda מופעלת בתחילה, המשתנים x ו-y מוגדרים לאלמנט הראשון והשני, בהתאמה, של my_list (כלומר, x = 1 ו- y = 2). פונקציית lambda מכפילה את שני המספרים הללו ומחזירה את התוצאה (1 * 2 = 2).
• בפעם השנייה שפונקציית למבדה נקראת, x מוגדר לתוצאה של הקריאה הקודמת (x = 2), ו- y מוגדר לאלמנט השלישי של רשימת המספרים (כלומר, y = 3). הוא מכפיל את שני הערכים הללו ומחזיר את התוצאה (2 * 3 = 6).
• פונקציית lambda נקראת שוב ושוב בדרך זו עבור כל רכיב ב-my_list עד שכל האלמנטים טופלו. הפונקציה reduce() מחזירה את המכפלה של כל רכיבי הרשימה, אשר מוקצה לאחר מכן למשתנה המוצר כ-120. מוצר זה מחושב באופן הבא: ((((1 * 2) * 3)* 4)* 5) = 120.
• לבסוף, אנו מדפיסים את הערך של משתנה המוצר באמצעות הפונקציה print() שמוציאה 120.

פונקציית reduce() עם פונקציות אופרטור

אנו יכולים להפוך את הקוד שלנו לתמציתי יותר וקל יותר לקריאה על ידי שימוש בפונקציות אופרטור במקום בפונקציות למבדה.

הנה דוגמה להדגמת השימוש בפונקציות אופרטור כארגומנט הראשון של פונקציית הפחת:

windows.open javascript

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

תְפוּקָה:

 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 

קוד זה מראה כיצד להשתמש בפונקציות reduce() ובפונקציות האופרטור לביצוע פעולות מתמטיות ופעולות מחרוזות על איטרבלים ב-Python.

הבנת ההבדל בין פונקציות reduce() ו-accumulate():

מודול Python functools מספק את הפונקציות reduce() ו-accumulate(), שתיהן פועלות על איטרבלים בדרכים דומות.

1. ה לְהַפחִית () ו לִצְבּוֹר פונקציות () דומות בכך ששתיהן מקבלות שני ארגומנטים: ה-Iterable עצמו ופונקציה שמתארת ​​את הפעולה שיש לבצע בו. עם זאת, הדרך שבה הם מטפלים בתוצאות הניתוח היא המקום שבו הם שונים זה מזה.
2. ה לְהַפחִית הפונקציה () עושה את הפעולה על שני האלמנטים הראשונים של ה-Iterable לפני הפעלת אותה פעולה על התוצאה ועל האלמנט הבא. תהליך זה חוזר על עצמו עד שכל הרכיבים של האיטרבל יעובדו. הפלט הסופי של הפעולה מוחזר כתוצאה בודדת.
3. בזמן ש לִצְבּוֹר הפונקציה () מחילה את הפעולה גם על שני האלמנטים הראשונים של האיטרבל לפני ביצוע אותה פעולה על התוצאה ועל האלמנטים הבאים, הפונקציה accumulate() מחזירה איטרטור המכיל את תוצאות הביניים של הפעולה. במילים אחרות, לאחר טיפול בכל רכיב, ה- לִצְבּוֹר הפונקציה () מספקת סדרה של ערכים המייצגים את תוצאת הפעולה.

דוגמה להבנת ההבדל בין לצבור() ל-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] 

בדוגמה זו, יש לנו רשימה של מספרים [1, 2, 3, 4, 5]. אנו משתמשים לְהַפחִית() כדי לחשב את המכפלה של כל המספרים, מה שמחזיר ערך בודד של 120.

אנחנו גם משתמשים לִצְבּוֹר() כדי לחשב את המכפלה של כל המספרים. עם זאת, במקום להחזיר ערך בודד, לִצְבּוֹר() מחזירה איטרטור שמניב רצף של תוצאות ביניים: [1, 2, 6, 24, 120].

אז, ההבדל העיקרי בין לְהַפחִית() ו-accumulate() הוא ש-reduce() מחזיר ערך בודד שהוא הפלט הסופי של הפעולה. לעומת זאת, accumulate() מחזיר איטרטור שמניב רצף של תוצאות ביניים.