खोज…


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

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

पैरामीटर

पैरामीटर विवरण
समारोह फ़ंक्शन जो पुनरावृत्ति को कम करने के लिए उपयोग किया जाता है (दो तर्क लेना चाहिए)। ( केवल स्थिति )
iterable जो कि कम होने वाला है। ( केवल स्थिति )
प्रारंभकर्ता कमी का प्रारंभ-मूल्य। ( वैकल्पिक , स्थिति-केवल )

टिप्पणियों

reduce हमेशा सबसे कुशल कार्य नहीं हो सकता है। कुछ प्रकारों के लिए समान कार्य या विधियाँ हैं:

  • sum() योग्य तत्वों वाले अनुक्रम के योग के लिए sum() (तार नहीं):

    sum([1,2,3])                                 # = 6
    
  • str.join स्ट्रिंग्स के संयोजन के लिए:

    ''.join(['Hello', ',', ' World'])            # = 'Hello, World'
    
  • next एक जनरेटर के साथ मिलकर एक शॉर्ट सर्किट संस्करण की तुलना में हो सकता है reduce :

    # First falsy item:
    next((i for i in [100, [], 20, 0] if not i)) # = []  
    

अवलोकन

# 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])                  # = []


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow