Python Language
कम करना

वाक्य - विन्यास

• कम करें (कार्य, iterable [, initializer])

पैरामीटर

टिप्पणियों

अवलोकन

# No import needed


# No import required...
from functools import reduce # ... but it can be loaded from the functools module


from functools import reduce # mandatory

reduce एक के अगले तत्व पर बार-बार एक समारोह लगाने से एक iterable कम कर देता है iterable और संचयी परिणाम अब तक।

def add(s1, s2):
    return s1 + s2

asequence = [1, 2, 3]

reduce(add, asequence)  # equivalent to: add(add(1,2),3)
# Out: 6

इस उदाहरण में, हमने अपने स्वयं के add फंक्शन को परिभाषित किया। हालांकि, पायथन operator मॉड्यूल में एक मानक समकक्ष फ़ंक्शन के साथ आता है:

import operator
reduce(operator.add, asequence)
# Out: 6

reduce भी एक प्रारंभिक मूल्य पारित किया जा सकता है:

reduce(add, asequence, 10)
# Out: 16

कम का उपयोग करना

def multiply(s1, s2):
    print('{arg1} * {arg2} = {res}'.format(arg1=s1, 
                                           arg2=s2, 
                                           res=s1*s2))
    return s1 * s2

asequence = [1, 2, 3]

एक initializer को देखते हुए फंक्शन को इनिशियलाइज़र और पहले चलने योग्य तत्व में लागू करके शुरू किया जाता है:

cumprod = reduce(multiply, asequence, 5)
# Out: 5 * 1 = 5
#      5 * 2 = 10
#      10 * 3 = 30
print(cumprod)
# Out: 30

initializer पैरामीटर के बिना फ़ंक्शन को पहले दो सूची तत्वों पर लागू करने से reduce शुरू होता है:

cumprod = reduce(multiply, asequence)
# Out: 1 * 2 = 2
#      2 * 3 = 6
print(cumprod)
# Out: 6

संचयी उत्पाद

import operator
reduce(operator.mul, [10, 5, -3])
# Out: -150

किसी भी / सभी के गैर शॉर्ट-सर्किट संस्करण

reduce यात्रा समाप्त नहीं होगा पहले iterable को पूरी तरह से खत्म हो गया दोहराया गया है, ताकि यह एक गैर शॉर्ट सर्किट बनाने के लिए इस्तेमाल किया जा सकता है any() या all() समारोह:

import operator
# non short-circuit "all"
reduce(operator.and_, [False, True, True, True]) # = False

# non short-circuit "any"
reduce(operator.or_, [True, False, False, False]) # = True

अनुक्रम का पहला सत्य / मिथ्या तत्व (या यदि कोई नहीं है तो अंतिम तत्व)

# First falsy element or last element if all are truthy:
reduce(lambda i, j: i and j, [100, [], 20, 10])    # = []
reduce(lambda i, j: i and j, [100, 50, 20, 10])    # = 10

# First truthy element or last element if all falsy:
reduce(lambda i, j: i or j, [100, [], 20, 0])     # = 100
reduce(lambda i, j: i or j, ['', {}, [], None])   # = None

इसके बजाय एक बनाने की lambda समारोह यह आम तौर पर एक नामित समारोह बनाने के लिए सिफारिश की है:

def do_or(i, j):
    return i or j

def do_and(i, j):
    return i and j

reduce(do_or, [100, [], 20, 0])                   # = 100
reduce(do_and, [100, [], 20, 0])                  # = []