python - नक्शा() और सूची की समझ के परिणाम अलग क्यों हैं?




closures list-comprehension (2)

निम्नलिखित परीक्षण विफल हैं:

#!/usr/bin/env python
def f(*args):
    """
    >>> t = 1, -1
    >>> f(*map(lambda i: lambda: i, t))
    [1, -1]
    >>> f(*(lambda: i for i in t)) # -> [-1, -1]
    [1, -1]
    >>> f(*[lambda: i for i in t]) # -> [-1, -1]
    [1, -1]
    """
    alist = [a() for a in args]
    print(alist)

if __name__ == '__main__':
    import doctest; doctest.testmod()

दूसरे शब्दों में:

>>> t = 1, -1
>>> args = []
>>> for i in t:
...   args.append(lambda: i)
...
>>> map(lambda a: a(), args)
[-1, -1]
>>> args = []
>>> for i in t:
...   args.append((lambda i: lambda: i)(i))
...
>>> map(lambda a: a(), args)
[1, -1]
>>> args = []
>>> for i in t:
...   args.append(lambda i=i: i)
...
>>> map(lambda a: a(), args)
[1, -1]

अभिव्यक्ति f = lambda: i इसके बराबर है:

def f():
    return i

अभिव्यक्ति g = lambda i=i: i के बराबर है:

def g(i=i):
    return i

i पहले मामले में एक स्वतंत्र चर है और यह दूसरे मामले में फ़ंक्शन पैरामीटर के लिए बाध्य है, अर्थात यह उस स्थिति में एक स्थानीय चर है। फ़ंक्शन परिभाषा के समय मूल पैरामीटर के मानों का मूल्यांकन किया जाता है।

जेनरेटर अभिव्यक्ति lambda अभिव्यक्ति में i नाम के लिए निकटतम संलग्न क्षेत्र (जहां i परिभाषित किया गया है) है, इसलिए i उस ब्लॉक में हल किया गया है:

f(*(lambda: i for i in (1, -1)) # -> [-1, -1]

i lambda i: ... ब्लॉक का एक स्थानीय चर है, इसलिए उस ऑब्जेक्ट को संदर्भित करता है जो कि ब्लॉक में परिभाषित किया गया है:

f(*map(lambda i: lambda: i, (1,-1))) # -> [1, -1]

लैम्ब्डा चर मानता है, मान नहीं, इसलिए कोड

lambda : i

हमेशा उस मान को वापस देगा जो वर्तमान में बंद होने के लिए मैं बाध्य हूं। जब तक यह कहा जाता है तब तक यह मान 1 के लिए निर्धारित किया गया है

आप जो चाहें प्राप्त करने के लिए, आपको लैम्ब्डा बनाए जाने के समय वास्तविक बाध्यकारी को पकड़ना होगा:

>>> f(*(lambda i=i: i for i in t)) # -> [-1, -1]
[1, -1]
>>> f(*[lambda i=i: i for i in t]) # -> [-1, -1]
[1, -1]




generator-expression