Python Language
सूची की समझ

परिचय

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

• [x + 1 में x के लिए (1, 2, 3)] # सूची समझ, देता है [2, 3, 4]
• (x + 1 में x के लिए (1, 2, 3)) # जनरेटर अभिव्यक्ति, 2 उपज होगी, फिर 3, फिर 4
• [x के लिए x में (1, 2, 3) यदि x% 2 == 0] # सूची फ़िल्टर के साथ समझ में आती है, तो 2 2 देता है]
• [x + १ यदि x% २ == ० x के लिए x में (१, २, ३)] # सूची त्रैमासिक पर
• [x + १ यदि x% २ == ० रेंज में x के लिए x (-३,४) अगर x> ०] # सूची टर्नररी और फ़िल्टरिंग के साथ समझ
• {x के लिए x (1, 2, 2, 3)} # सेट की समझ, {1, 2, 3} देता है
• {k: v for k, v में [('a', 1), ('b', 2)]} # तानाशाही की समझ, {'a': 1, 'b': 2} (अजगर 2.7+) केवल 3.0+)
• [x + y में x के लिए [1, 2] में y के लिए [10, 20]] # नेस्टेड लूप्स, [11, 21, 12, 22] देता है।
• [x + y में x के लिए [१, २, ३] अगर x> २ में y के लिए [३, ४, ५]] # हालत 1 पर लूप के लिए जाँच की
• [x + y में x के लिए [1, 2, 3] में y के लिए [3, 4, 5] यदि x> 2] # स्थिति 2 लूप के लिए जाँच की
• [x x में x के लिए x (10) यदि x% 2 == 0] # स्थिति की जाँच की जाती है यदि लूप किए गए अंक विषम संख्याएँ हैं

टिप्पणियों

सूची की समझ

एक सूची की समझ एक चलने वाले के प्रत्येक तत्व के लिए एक अभिव्यक्ति लागू करके एक नई list है। सबसे बुनियादी रूप है:

[ <expression> for <element> in <iterable> ]

एक वैकल्पिक 'अगर' स्थिति है:

[ <expression> for <element> in <iterable> if <condition> ]

प्रत्येक <element> में <iterable> को <expression> में प्लग किया जाता है यदि (वैकल्पिक) <condition> सही का मूल्यांकन करता है । नई सूची में एक बार में सभी परिणाम वापस कर दिए जाते हैं। जेनरेटर के भावों का मूल्यांकन आलसी तरीके से किया जाता है, लेकिन सूची की समझ पूरे इटेरेटर का तुरंत मूल्यांकन करती है - इटोमर की लंबाई के लिए आनुपातिक खपत।

चुकता पूर्णांक की list बनाने के list :

squares = [x * x for x in (1, 2, 3, 4)]
# squares: [1, 4, 9, 16]

for अभिव्यक्ति सेट x से बदले में प्रत्येक मान से (1, 2, 3, 4) । एक्सप्रेशन x * x का परिणाम आंतरिक list जोड़ा जाता है। आंतरिक list पूर्ण होने पर चर squares जाती है।

गति में वृद्धि (जैसा कि यहां बताया गया है ) के अलावा, एक सूची समझ मोटे तौर पर निम्न-लूप के बराबर है:

squares = []
for x in (1, 2, 3, 4):
    squares.append(x * x)
# squares: [1, 4, 9, 16]

प्रत्येक तत्व पर लागू अभिव्यक्ति आवश्यकतानुसार जटिल हो सकती है:

# Get a list of uppercase characters from a string
[s.upper() for s in "Hello World"]
# ['H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']

# Strip off any commas from the end of strings in a list
[w.strip(',') for w in ['these,', 'words,,', 'mostly', 'have,commas,']]
# ['these', 'words', 'mostly', 'have,commas']

# Organize letters in words more reasonably - in an alphabetical order
sentence = "Beautiful is better than ugly"
["".join(sorted(word, key = lambda x: x.lower())) for word in sentence.split()]
# ['aBefiltuu', 'is', 'beertt', 'ahnt', 'gluy']

अन्य

else सूची बोध निर्माण में इस्तेमाल किया जा सकता है, लेकिन वाक्यविन्यास के बारे में सावधान रहना चाहिए। यदि / अन्यथा क्लॉस का उपयोग लूप के for पहले किया जाना चाहिए, उसके बाद नहीं:

# create a list of characters in apple, replacing non vowels with '*'
# Ex - 'apple' --> ['a', '*', '*', '*' ,'e']

[x for x in 'apple' if x in 'aeiou' else '*']
#SyntaxError: invalid syntax

# When using if/else together use them before the loop
[x if x in 'aeiou' else '*' for x in 'apple']
#['a', '*', '*', '*', 'e']

ध्यान दें कि यह एक अलग भाषा निर्माण, एक सशर्त अभिव्यक्ति का उपयोग करता है, जो खुद समझ के वाक्य रचना का हिस्सा नहीं है। जबकि if के for…in बाद for…in सूची समझ का एक हिस्सा है और स्रोत से तत्वों को फिल्टर करने के लिए इस्तेमाल किया।

डबल इटरेशन

दोहरे पुनरावृत्ति का क्रम [... for x in ... for y in ...] या तो प्राकृतिक या प्रति-सहज ज्ञान युक्त है। अंगूठे का नियम लूप के for एक समकक्ष का पालन करना है:

def foo(i):
    return i, i + 0.5

for i in range(3):
    for x in foo(i):
        yield str(x)

यह बन जाता है:

[str(x)
    for i in range(3)
        for x in foo(i)
]

इसे एक पंक्ति में [str(x) for i in range(3) for x in foo(i)] में संकुचित किया जा सकता है

इन-प्लेस म्यूटेशन और अन्य साइड इफेक्ट्स

सूची समझ का उपयोग करने से पहले, उनके दुष्प्रभावों ( उत्परिवर्तन , या इन-प्लेस फ़ंक्शंस) के लिए कहे जाने वाले फ़ंक्शंस के अंतर को समझें, जो आमतौर पर None लौटता है, और फ़ंक्शंस जो एक दिलचस्प मूल्य लौटाते हैं।

कई कार्य (विशेष रूप से शुद्ध कार्य) बस एक वस्तु लेते हैं और कुछ वस्तु वापस करते हैं। एक इन-प्लेस फ़ंक्शन मौजूदा ऑब्जेक्ट को संशोधित करता है, जिसे साइड इफेक्ट कहा जाता है। अन्य उदाहरणों में इनपुट और आउटपुट ऑपरेशन जैसे मुद्रण शामिल हैं।

list.sort() एक सूची को इन-प्लेस (जिसका अर्थ है कि यह मूल सूची को संशोधित करता है list.sort() सॉर्ट करता है और None मान None । इसलिए, यह सूची बोध में अपेक्षित के रूप में काम नहीं करेगा:

[x.sort() for x in [[2, 1], [4, 3], [0, 1]]]
# [None, None, None]

इसके बजाय, sorted() जगह में छँटाई के बजाय एक क्रमबद्ध list देता है:

[sorted(x) for x in [[2, 1], [4, 3], [0, 1]]]
# [[1, 2], [3, 4], [0, 1]]

साइड-इफेक्ट्स के लिए समझ का उपयोग करना संभव है, जैसे कि I / O या इन-प्लेस फ़ंक्शंस। फिर भी एक लूप के लिए आमतौर पर अधिक पठनीय है। जबकि यह पायथन 3 में काम करता है:

[print(x) for x in (1, 2, 3)]

इसके बजाय उपयोग करें:

for x in (1, 2, 3):
    print(x)

कुछ स्थितियों में, साइड इफेक्ट फ़ंक्शन सूची की समझ के लिए उपयुक्त हैं । random.randrange() में यादृच्छिक संख्या जनरेटर की स्थिति को बदलने का दुष्प्रभाव है, लेकिन यह एक दिलचस्प मूल्य भी देता है। इसके अतिरिक्त, next() एक पुनरावृत्ति पर बुलाया जा सकता है।

निम्नलिखित यादृच्छिक मूल्य जनरेटर शुद्ध नहीं है, फिर भी समझ में आता है क्योंकि यादृच्छिक जनरेटर को रीसेट किया जाता है हर बार अभिव्यक्ति का मूल्यांकन किया जाता है:

from random import randrange
[randrange(1, 7) for _ in range(10)]
# [2, 3, 2, 1, 1, 5, 2, 4, 3, 5]

सूची बोध में व्हॉट्सएप

अधिक जटिल सूची समझ अवांछित लंबाई तक पहुँच सकती है, या कम पठनीय बन सकती है। हालांकि उदाहरणों में कम आम है, एक सूची को कई लाइनों में तोड़ना संभव है जैसे:

[
    x for x
    in 'foo'
    if x not in 'bar'
]

शब्दकोश की समझ

डिक्शनरी कॉम्प्रिहेंशन एक लिस्ट कॉम्प्रिहेंशन के समान है सिवाय इसके कि यह एक लिस्ट के बजाय डिक्शनरी ऑब्जेक्ट बनाता है।

एक मूल उदाहरण:

{x: x * x for x in (1, 2, 3, 4)}
# Out: {1: 1, 2: 4, 3: 9, 4: 16}

जो लिखने का एक और तरीका है:

dict((x, x * x) for x in (1, 2, 3, 4))
# Out: {1: 1, 2: 4, 3: 9, 4: 16}

जैसा कि एक सूची की समझ के साथ, हम कुछ हद तक मिलने वाले तानाशाह तत्वों का उत्पादन करने के लिए तानाशाही के अंदर एक सशर्त बयान का उपयोग कर सकते हैं।

{name: len(name) for name in ('Stack', 'Overflow', 'Exchange') if len(name) > 6}  
# Out: {'Exchange': 8, 'Overflow': 8}

या, एक जनरेटर अभिव्यक्ति का उपयोग करके फिर से लिखा गया।

dict((name, len(name)) for name in ('Stack', 'Overflow', 'Exchange') if len(name) > 6)
# Out: {'Exchange': 8, 'Overflow': 8}

एक शब्दकोश से शुरू करना और कुंजी-मूल्य जोड़ी फ़िल्टर के रूप में शब्दकोश की समझ का उपयोग करना

initial_dict = {'x': 1, 'y': 2}
{key: value for key, value in initial_dict.items() if key == 'x'}
# Out: {'x': 1}

शब्दकोश की कुंजी और मान बदलना (उल्टा शब्दकोष)

यदि आपके पास एक सरल हैशनेबल मूल्य हैं (डुप्लिकेट मान के अप्रत्याशित परिणाम हो सकते हैं):

my_dict = {1: 'a', 2: 'b', 3: 'c'}

और आप अपनी कोडिंग शैली के आधार पर उन कुंजियों और मूल्यों की अदला-बदली करना चाहते हैं जिन्हें आप कई तरीकों से ले सकते हैं:

• swapped = {v: k for k, v in my_dict.items()}
• swapped = dict((v, k) for k, v in my_dict.iteritems())
• swapped = dict(zip(my_dict.values(), my_dict))
• swapped = dict(zip(my_dict.values(), my_dict.keys()))
• swapped = dict(map(reversed, my_dict.items()))

print(swapped)
# Out: {a: 1, b: 2, c: 3}

शब्दकोश विलय

शब्दकोश को मिलाएं और एक नेस्टेड शब्दकोश समझ के साथ वैकल्पिक रूप से पुराने मूल्यों को ओवरराइड करें।

dict1 = {'w': 1, 'x': 1}
dict2 = {'x': 2, 'y': 2, 'z': 2}

{k: v for d in [dict1, dict2] for k, v in d.items()}
# Out: {'w': 1, 'x': 2, 'y': 2, 'z': 2}

हालाँकि, शब्दकोश अनपैकिंग ( PEP 448 ) एक पसंदीदा हो सकता है।

{**dict1, **dict2}
# Out: {'w': 1, 'x': 2, 'y': 2, 'z': 2}

नोट : शब्द समझ को पायथन 3.0 में जोड़ा गया और सूची समझ के विपरीत 2.7+ पर वापस भेज दिया गया, जिसे 2.0 में जोड़ा गया था। संस्करण <2.7 dict() अभिव्यक्तियों के व्यवहार को अनुकरण करने के लिए जनरेटर अभिव्यक्तियों और dict() बिलिन का उपयोग कर सकते हैं।

जेनरेटर एक्सप्रेशन

जेनरेटर अभिव्यक्तियाँ सूची बोध के समान हैं। मुख्य अंतर यह है कि यह एक बार में परिणामों का पूरा सेट नहीं बनाता है; यह एक जेनरेटर ऑब्जेक्ट बनाता है जिसे फिर से iterated किया जा सकता है।

उदाहरण के लिए, निम्नलिखित कोड में अंतर देखें:

# list comprehension
[x**2 for x in range(10)]
# Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# generator comprehension
(x**2 for x in xrange(10))
# Output: <generator object <genexpr> at 0x11b4b7c80>

ये दो बहुत अलग वस्तुएं हैं:

• सूची की समझ एक list वस्तु देता है जबकि जनरेटर की समझ एक generator देता है।

• generator वस्तुओं को अनुक्रमित नहीं किया जा सकता है और आइटम प्राप्त करने के लिए next फ़ंक्शन का उपयोग करता है।

नोट : हम xrange उपयोग xrange क्योंकि यह एक जनरेटर ऑब्जेक्ट भी बनाता है। यदि हम रेंज का उपयोग करेंगे, तो एक सूची बनाई जाएगी। इसके अलावा, xrange केवल अजगर के बाद के संस्करण में मौजूद है। अजगर 3 में, range सिर्फ एक जनरेटर देता है। अधिक जानकारी के लिए, श्रेणी और xrange फ़ंक्शंस उदाहरण के बीच अंतर देखें।

g = (x**2 for x in xrange(10))
print(g[0])

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'generator' object has no attribute '__getitem__'

g.next()  # 0
g.next()  # 1
g.next()  # 4
...
g.next()  # 81

g.next()  # Throws StopIteration Exception

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

यद्यपि इन दोनों को एक समान तरीके से पुनरावृत्त किया जा सकता है:

for i in [x**2 for x in range(10)]:
    print(i)

"""
Out:
0
1
4
...
81
"""

for i in (x**2 for x in xrange(10)):
    print(i)

"""
Out:
0
1
4
.
.
.
81
"""

बक्सों का इस्तेमाल करें

जेनरेटर एक्सप्रेशंस का आलसी मूल्यांकन किया जाता है, जिसका अर्थ है कि वे प्रत्येक मान उत्पन्न करते हैं और केवल तभी वापस करते हैं जब जनरेटर को पुनरावृत्त किया जाता है। यह अक्सर उपयोगी होता है जब बड़े डेटासेट के माध्यम से पुनरावृत्ति होती है, जो मेमोरी में डेटासेट की डुप्लिकेट बनाने की आवश्यकता से बचती है:

for square in (x**2 for x in range(1000000)):
    #do something

एक अन्य सामान्य उपयोग का मामला यह है कि यदि आवश्यक नहीं है तो एक पूरे चलने योग्य पर पुनरावृत्ति से बचने के लिए। इस उदाहरण में, किसी आइटम को दूरस्थ एपीआई से get_objects() प्रत्येक पुनरावृत्ति के साथ पुनर्प्राप्त किया जाता है। हजारों ऑब्जेक्ट मौजूद हो सकते हैं, उन्हें एक-एक करके पुनर्प्राप्त किया जाना चाहिए, और हमें केवल यह जानना होगा कि क्या एक पैटर्न से मेल खाने वाली वस्तु मौजूद है। एक जनरेटर अभिव्यक्ति का उपयोग करके, जब हम पैटर्न से मेल खाते एक ऑब्जेक्ट का सामना करते हैं।

def get_objects():
    """Gets objects from an API one by one"""
    while True:
        yield get_next_item()

def object_matches_pattern(obj):
    # perform potentially complex calculation
    return matches_pattern

def right_item_exists():
    items = (object_matched_pattern(each) for each in get_objects())
    for item in items:
        if item.is_the_right_one:


            return True
    return False

समझ स्थापित करें

सेट समझ सूची और शब्दकोश समझ के समान है, लेकिन यह एक सेट का उत्पादन करता है, जो अद्वितीय तत्वों का एक अनियंत्रित संग्रह है।

# A set containing every value in range(5):
{x for x in range(5)}
# Out: {0, 1, 2, 3, 4}

# A set of even numbers between 1 and 10:
{x for x in range(1, 11) if x % 2 == 0}
# Out: {2, 4, 6, 8, 10}

# Unique alphabetic characters in a string of text:
text = "When in the Course of human events it becomes necessary for one people..."
{ch.lower() for ch in text if ch.isalpha()}
# Out: set(['a', 'c', 'b', 'e', 'f', 'i', 'h', 'm', 'l', 'o',
#           'n', 'p', 's', 'r', 'u', 't', 'w', 'v', 'y'])

लाइव डेमो

ध्यान रखें कि सेट अनियंत्रित हैं। इसका मतलब यह है कि सेट में परिणामों का क्रम उपरोक्त उदाहरणों में प्रस्तुत एक से भिन्न हो सकता है।

नोट : सूची बोध के विपरीत अजगर के 2.7+ के बाद से सेट कॉम्प्रिहेंशन उपलब्ध है, जिसे 2.0 में जोड़ा गया था। पाइथन 2.2 से पाइथन 2.6 में, set() फ़ंक्शन का उपयोग जनरेटर अभिव्यक्ति के साथ एक ही परिणाम उत्पन्न करने के लिए किया जा सकता है:

set(x for x in range(5))
# Out: {0, 1, 2, 3, 4}

सशर्त खंड का उपयोग करके दोहराव और महंगे संचालन से बचें

नीचे दी गई सूची की समझ पर विचार करें:

>>> def f(x):
...     import time
...     time.sleep(.1)       # Simulate expensive function
...     return x**2

>>> [f(x) for x in range(1000) if f(x) > 10]
[16, 25, 36, ...]

करने के लिए दो कॉल में यह परिणाम f(x) के 1,000 मूल्यों के लिए x मूल्य पैदा करने के लिए एक कॉल और जाँच के लिए अन्य: if हालत। यदि f(x) एक विशेष रूप से महंगा ऑपरेशन है, तो इसके महत्वपूर्ण प्रदर्शन निहितार्थ हो सकते हैं। इससे भी बदतर, अगर कॉलिंग f() के दुष्प्रभाव हैं, तो इसके आश्चर्यजनक परिणाम हो सकते हैं।

इसके बजाय, आप महंगा ऑपरेशन केवल एक बार के प्रत्येक मान के लिए मूल्यांकन करना चाहिए x एक मध्यवर्ती iterable (उत्पन्न करके जनरेटर अभिव्यक्ति ) इस प्रकार है:

>>> [v for v in (f(x) for x in range(1000)) if v > 10]
[16, 25, 36, ...]

या, बिल्टइन मैप का उपयोग करके समकक्ष:

>>> [v for v in map(f, range(1000)) if v > 10]
[16, 25, 36, ...]

एक और तरीका जो अधिक पठनीय कोड के परिणामस्वरूप हो सकता है, वह आंशिक परिणाम (पिछले उदाहरण में v ) को पुनरावृत्त (जैसे सूची या टपल) के रूप में रखना है और फिर उस पर पुनरावृति करना है। चूँकि v केवल चलने योग्य में एकमात्र तत्व होगा, परिणाम यह है कि अब हमारे पास केवल एक बार संकलित हमारे धीमे फ़ंक्शन के आउटपुट का संदर्भ है:

>>> [v for x in range(1000) for v in [f(x)] if v > 10]
[16, 25, 36, ...]

हालांकि, व्यवहार में, कोड का तर्क अधिक जटिल हो सकता है और इसे पठनीय रखना महत्वपूर्ण है। सामान्य तौर पर, एक जटिल एक-लाइनर पर एक अलग जनरेटर फ़ंक्शन की सिफारिश की जाती है:

>>> def process_prime_numbers(iterable):
...     for x in iterable:
...         if is_prime(x):
...             yield f(x)
...
>>> [x for x in process_prime_numbers(range(1000)) if x > 10]
[11, 13, 17, 19, ...]

कंप्यूटिंग को रोकने के लिए एक और तरीका है f(x) कई बार उपयोग करने के लिए है @functools.lru_cache() (अजगर 3.2+) डेकोरेटर पर f(x) । इस तरह से इनपुट x लिए f का आउटपुट पहले से ही एक बार गणना की जा चुकी है, मूल सूची समझ का दूसरा फ़ंक्शन मंगलाचरण एक शब्दकोश लुकअप जितना तेज़ होगा। यह दृष्टिकोण दक्षता में सुधार के लिए संस्मरण का उपयोग करता है, जो जनरेटर के भावों का उपयोग करने के लिए तुलनीय है।

कहो कि आपको एक सूची को समतल करना है

l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]

कुछ विधियाँ हो सकती हैं:

reduce(lambda x, y: x+y, l)

sum(l, [])

list(itertools.chain(*l))

हालांकि सूची समझ सबसे अच्छा समय जटिलता प्रदान करेगा।

[item for sublist in l for item in sublist]

+ पर आधारित शॉर्टकट (योग में निहित उपयोग सहित), आवश्यकता के होते हैं, O (L ^ 2) जब L उप-कलाकार होते हैं - जैसा कि मध्यवर्ती परिणाम सूची में लंबे समय तक रहता है, प्रत्येक चरण में एक नया मध्यवर्ती परिणाम सूची ऑब्जेक्ट प्राप्त होता है आवंटित किया गया है, और पिछले मध्यवर्ती परिणाम में सभी वस्तुओं को कॉपी किया जाना चाहिए (साथ ही कुछ नए लोगों को अंत में जोड़ा गया है)। तो (सादगी के लिए और सामान्यता के वास्तविक नुकसान के बिना) का कहना है कि आपके पास I आइटम के एल सब्लिस्ट हैं: प्रत्येक I आइटम को कॉपी किया जाता है L-1 बार, दूसरा I आइटम L-2 बार, और इसी तरह; प्रतियों की कुल संख्या I है x से x के लिए 1 से L तक x का योग है, अर्थात, I * (L ** 2) / 2।

सूची की समझ बस एक बार एक सूची उत्पन्न करती है, और प्रत्येक आइटम को उसके निवास स्थान (परिणाम सूची के मूल स्थान से) से ठीक एक बार कॉपी करती है।

वृत्तियों को सम्‍मिलित करना

for एक के खंड सूची समझ एक से अधिक चर निर्दिष्ट कर सकते हैं:

[x + y for x, y in [(1, 2), (3, 4), (5, 6)]]
# Out: [3, 7, 11]

[x + y for x, y in zip([1, 3, 5], [2, 4, 6])]
# Out: [3, 7, 11]

यह छोरों के for नियमित की तरह है:

for x, y in [(1,2), (3,4), (5,6)]:
    print(x+y)
# 3
# 7
# 11

हालांकि, ध्यान दें कि यदि अभिव्यक्ति शुरू होती है तो यह एक तुक है तो इसे संक्षिप्त किया जाना चाहिए:

[x, y for x, y in [(1, 2), (3, 4), (5, 6)]]
# SyntaxError: invalid syntax

[(x, y) for x, y in [(1, 2), (3, 4), (5, 6)]]
# Out: [(1, 2), (3, 4), (5, 6)]

गणना का उपयोग कर समझ में आता है

जब हम एक पुनरावृत्ति में वस्तुओं की संख्या की गणना करना चाहते हैं, जो कुछ स्थिति को पूरा करते हैं, हम एक मुहावरेदार वाक्यविन्यास का उत्पादन करने के लिए समझ का उपयोग कर सकते हैं:

# Count the numbers in `range(1000)` that are even and contain the digit `9`:
print (sum(
    1 for x in range(1000) 
    if x % 2 == 0 and
    '9' in str(x)
))
# Out: 95

मूल अवधारणा को संक्षेप में प्रस्तुत किया जा सकता है:

1. range(1000) में तत्वों पर फेरबदल।
2. if आवश्यक हो if सभी को सम्‍मिलित करें।
3. शर्तों को पूरा करने वाले प्रत्येक आइटम के लिए 1 लौटाने के लिए अभिव्यक्ति के रूप में 1 का उपयोग करें।
4. शर्तों को पूरा करने वाले आइटमों की संख्या निर्धारित करने के लिए सभी 1 एस को जोड़ दें।

नोट : यहां हम एक सूची में 1 एस को इकट्ठा नहीं कर रहे हैं (वर्ग कोष्ठक की अनुपस्थिति पर ध्यान दें), लेकिन हम उन्हें सीधे sum फ़ंक्शन में पास कर रहे हैं जो उन्हें समेट रहा है। इसे एक जनरेटर अभिव्यक्ति कहा जाता है, जो एक समझ के समान है।

एक सूची में प्रकार बदलना

मात्रात्मक डेटा को अक्सर स्ट्रिंग के रूप में पढ़ा जाता है जिसे प्रसंस्करण से पहले संख्यात्मक प्रकार में परिवर्तित किया जाना चाहिए। सभी सूची मदों के प्रकारों को सूची समझ या map() फ़ंक्शन के साथ परिवर्तित किया जा सकता है।

# Convert a list of strings to integers.
items = ["1","2","3","4"]
[int(item) for item in items]
# Out: [1, 2, 3, 4]

# Convert a list of strings to float.
items = ["1","2","3","4"]
map(float, items)
# Out:[1.0, 2.0, 3.0, 4.0]