Python List Comprehension ट्यूटोरियल

डेटा साइंस करते समय, आपको सूचियों की सूचियाँ पढ़नी पड़ सकती हैं, कॉलम नामों को फ़िल्टर करना, किसी सूची से स्वरों को हटाना या किसी मैट्रिक्स को फ़्लैट करना पड़ सकता है। आप आसानी से एक lambda फ़ंक्शन या for लूप का उपयोग कर सकते हैं; जैसा कि आप अच्छी तरह जानते हैं, इसके कई तरीके हैं। एक और तरीका list comprehensions का उपयोग करना है।

यह ट्यूटोरियल इसी अंतिम विषय पर केंद्रित है:

• सबसे पहले, आप Python सूचियों का संक्षिप्त पुनरावलोकन करेंगे और देखेंगे कि वे अन्य Python डेटा संरचनाओं की तुलना में कैसी हैं;
• इसके बाद, आप Python list comprehensions में गहराई से जाएंगे: आप Python सूचियों के पीछे के गणित के बारे में, list comprehensions कैसे बनाते हैं, उन्हें for लूप्स या lambda फ़ंक्शनों के रूप में कैसे दोबारा लिखते हैं, आदि सीखेंगे। आप केवल पढ़ेंगे ही नहीं, बल्कि कुछ अभ्यास भी करेंगे!
• जब आप बुनियादी बातें समझ लेंगे, तो आप list comprehensions में conditionals जोड़कर उन्हें परिष्कृत करना भी सीखेंगे: आप देखेंगे कि list comprehensions में conditionals कैसे शामिल करें और एक से अधिक if conditions तथा if-else कथनों को कैसे संभालें।
• अंत में, आप nested list comprehensions के माध्यम से सूचियों पर कई बार इटरेट करना सीखेंगे।

क्या आप iterators और generators के साथ मिलकर list comprehensions भी सीखना चाहते हैं? DataCamp का Python Data Science Toolbox कोर्स देखें!

Python सूचियाँ

अब तक, आपने संभवतः कई डेटा प्रकारों वाले मानों के साथ काम किया होगा। आपने हर मान को अलग-अलग वेरिएबल में सहेजा: प्रत्येक वेरिएबल एक एकल मान को दर्शाता है। हालांकि, डेटा साइंस में आप अक्सर बहुत सारे डेटा पॉइंट्स के साथ काम करेंगे, जिससे हर मान को अलग वेरिएबल में सहेजना मुश्किल हो जाएगा। इसके बजाय, आप इन सभी मानों को Python सूची में सहेजते हैं।

सूचियाँ Python में चार बिल्ट-इन डेटा संरचनाओं में से एक हैं। अन्य डेटा संरचनाएँ जिनसे आप परिचित हो सकते हैं वे हैं tuples, dictionaries और sets। Python में सूची, उदाहरण के लिए, int या bool से अलग होती है, क्योंकि यह एक compound डेटा प्रकार है: आप मानों को सूचियों में समूहित कर सकते हैं। वास्तव में, ये मान एक ही प्रकार के होने की आवश्यकता नहीं है: वे boolean, String, integer, ... मानों का संयोजन हो सकते हैं।

यहाँ ध्यान देने योग्य बात यह है कि सूचियाँ वस्तुओं या आइटम्स का क्रमबद्ध संग्रह हैं। यही कारण है कि Python में सूचियाँ "sequence types" हैं, क्योंकि वे किसी क्रम की तरह व्यवहार करती हैं। इसका अर्थ है कि उन पर इटरेट किया जा सकता है; अनुक्रम के अन्य उदाहरण Strings, tuples या sets हैं।

टिप: यदि आप Python सूचियों के बारे में अधिक जानना, जाँचना या अभ्यास करना चाहते हैं, तो आप Python सूचियों पर सबसे आम प्रश्नों को यहाँ देख सकते हैं।

अब, व्यावहारिक रूप से: आप दो square brackets के साथ एक सूची बनाते हैं; इन ब्रैकेट्स के अंदर, आप मानों को कॉमा से अलग करते हैं। फिर आप अपनी सूची को किसी वेरिएबल को असाइन कर सकते हैं। Python सूची में डाले गए मान किसी भी डेटा प्रकार के हो सकते हैं, यहाँ तक कि सूचियाँ भी!

निम्नलिखित उदाहरण पर नज़र डालें:

# Assign integer values to `a` and `b`
a = 4
b = 9

# Create a list with the variables `a` and `b` 
count_list = [1,2,3,a,5,6,7,8,b,10]

टिप: ऊपर दिए गए DataCamp Light खंड में मौजूद IPython शेल में अपनी स्वयं की सूची बनाएं!

Python List Comprehension

Python सूचियों का पुनरावलोकन करने के बाद आप आसानी से देख सकते हैं कि Python में सूचियों को परिभाषित करना और बनाना थकाऊ हो सकता है: हर मान को अलग-अलग टाइप करना समय लेने वाला है और आप आसानी से गलतियाँ कर सकते हैं।

Python में list comprehensions इस प्रकार निर्मित किए जाते हैं:

list_variable = [x for x in iterable]
संचालित द्वारा

लेकिन आप Python में इन संरचनाओं को बनाने और उपयोग करने के इस सूत्र-जैसे तरीके तक कैसे पहुँचते हैं? आइए थोड़ा और गहराई से समझें।

Python में List Comprehension: गणित

खुशकिस्मती से, Python आपके लिए समाधान प्रस्तुत करता है: यह आपको एक गणितीय संकेत-पद्धति लागू करने का तरीका देता है: list comprehension।

याद रखें गणित में, सूचियों (या sets, tuples, या vectors) का वर्णन करने के सामान्य तरीके ये हैं:

S = {x² : x in {0 ... 9}}
V = (1, 2, 4, 8, ..., 2¹²)
M = {x | x in S and x even}
संचालित द्वारा

दूसरे शब्दों में, ऊपर दी गई परिभाषाएँ वास्तव में आपको निम्न बातें बताती हैं:

• सिक्वेंस S वास्तव में 0 से 9 (दोनों सहित) के बीच के मानों का सिक्वेंस है जिन्हें 2 की घात पर उठाया गया है।
• दूसरी ओर, सिक्वेंस V में आधार मान 2 है जिसे किसी निश्चित घात पर उठाया गया है। सिक्वेंस के पहले तत्व के लिए यह 0 है, दूसरे के लिए 1, और इसी तरह 12 तक।
• अंत में, सिक्वेंस M में सिक्वेंस S के वे तत्व शामिल हैं, लेकिन केवल सम (even) वाले।

यदि ऊपर दी गई परिभाषाएँ आपको सिरदर्द दे रही हैं, तो देखें कि ये परिभाषाएँ वास्तविक में कौन-सी सूचियाँ देंगी:

S = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
V = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096}
M = {0, 4, 16, 36, 64}
संचालित द्वारा

आप स्पष्ट रूप से प्रत्येक सूची का परिणाम और उनमें वर्णित ऑपरेशंस देख सकते हैं!

अब जब आपने सूचियों के पीछे का कुछ गणित समझ लिया है, तो आप list comprehensions का उपयोग करके Python में सूचियों के निर्माण की इस गणितीय संकेत-पद्धति को लागू कर सकते हैं! निम्नलिखित कोड पंक्तियों पर नज़र डालें:

S = [x**2 for x in range(10)]
V = [2**i for i in range(13)]
M = [x for x in S if x % 2 == 0]

यह सब कुछ बहुत हद तक अभी-अभी देखी गई गणितीय परिभाषाओं जैसा दिखता है, है न?

यदि आप यहाँ थोड़े उलझ गए हैं तो चिंता न करें; भले ही आप गणित के जीनियस न हों, यदि आप इन्हें समय देकर पढ़ें तो ये list comprehensions काफ़ी आसान हैं। ऊपर दिए गए कोड खंड में Python कोड को एक बार फिर ध्यान से देखें।

आप देखेंगे कि कोड आपको यह बताता है:

• सूची S उन square brackets से बनी है जिनके बारे में आपने पहले भाग में पढ़ा था। उन ब्रैकेट्स में, एक तत्व x है जिसे 2 की घात पर उठाया गया है। अब, आपको यह जानना है कि कितने मानों (और कौन-से मान!) को 2 की घात पर उठाना है। यह range(10) में निर्धारित है। इन सबको देखते हुए, आप निष्कर्ष निकाल सकते हैं कि आप 0 से 9 तक के सभी संख्याओं को 2 की घात पर उठाएँगे।
• सूची V में आधार मान 2 है, जिसे किसी निश्चित घात पर उठाया गया है। पहले की तरह, अब आपको जानना है कि किस घात या i का उपयोग किया जाएगा। आप देखते हैं कि इस मामले में i range(13) का हिस्सा है, जिसका मतलब है कि आप 0 से शुरू करके 12 तक जाते हैं। इसका मतलब है कि आपकी सूची में 13 मान होंगे — 2 की घात 0, 1, 2, ... 12 तक।
• अंत में, सूची M में वे तत्व होते हैं जो S का हिस्सा हैं तभी जब वे 2 से विभाज्य हों और कोई शेष न बचे। यानी modulo 0 होना चाहिए। दूसरे शब्दों में, सूची M सूची S में संग्रहीत सम मानों से बनी है।

अब जब आपने इसे विस्तार से देखा, तो यह कहीं अधिक समझ में आता है, है न?

पुनरावलोकन और अभ्यास

संक्षेप में, आप देखते हैं कि इन सभी कोड लाइनों में कुछ तत्व बार-बार आते हैं:

• square brackets, जो Python सूचियों की पहचान हैं;
• for कीवर्ड, जिसके बाद एक वेरिएबल आता है जो सूची आइटम का प्रतीक है; और
• in कीवर्ड, जिसके बाद कोई sequence (जो सूची भी हो सकती है!) आता है।

और इसका परिणाम वही कोड होता है जो आपने इस भाग की शुरुआत में देखा था:

list_variable = [x for x in iterable]
संचालित द्वारा

अब आपकी बारी है कि आप Python में list comprehensions के साथ शुरुआत करें! चलिए उन गणितीय सूचियों के क़रीब ही रहते हैं जिन्हें आपने पहले देखा था:

# Define Q
Q = _________________________

इसके विकल्प के रूप में List Comprehension...

List comprehension for लूप्स, lambda फ़ंक्शन के साथ-साथ map(), filter() और reduce() फ़ंक्शनों का पूर्ण विकल्प है। इससे भी बढ़कर, कुछ लोगों के लिए list comprehension को समझना और व्यवहार में इस्तेमाल करना और भी आसान होता है! इसके बारे में आप अगले भाग में और पढ़ेंगे!

हालाँकि, यदि आप Python में फ़ंक्शनों और lambda फ़ंक्शनों के बारे में अधिक जानना चाहते हैं, तो हमारा Python Functions Tutorial देखें।

For लूप्स

जैसा कि आप जानते हैं, आप for लूप्स का उपयोग किसी कोड ब्लॉक को निश्चित संख्या में बार दोहराने के लिए करते हैं। List comprehensions वास्तव में for लूप्स के बेहतर विकल्प हैं, क्योंकि वे अधिक संक्षिप्त हैं। निम्नलिखित उदाहरण पर विचार करें जो numbers वेरिएबल से शुरू होता है, जिसे 0 से 10 (10 शामिल नहीं) तक के रेंज के रूप में परिभाषित किया गया है।

याद रखें कि आप range() फ़ंक्शन को जो संख्या पास करते हैं, वह वास्तव में उन पूर्णांकों की संख्या है जिन्हें आप उत्पन्न करना चाहते हैं, और यह शून्य से शुरू होती है। इसका मतलब है कि range(10) [0,1,2,3,4,5,6,7,8,9] लौटाएगा।

# Initialize `numbers`
numbers = range(10)
संचालित द्वारा

यदि अब आप numbers के प्रत्येक तत्व पर कोई ऑपरेशन करना चाहते हैं, तो आप नीचे दिए गए जैसे for लूप से ऐसा कर सकते हैं:

# Initialize `new_list`
new_list = []

# Add values to `new_list`
for n in numbers:
    if n%2==0:
        new_list.append(n**2)

# Print `new_list`
print(new_list)
संचालित द्वारा

[0, 4, 16, 36, 64]
संचालित द्वारा

यह सब ठीक है, लेकिन अब निम्नलिखित list comprehension देखें, जहाँ आप मूल रूप से वही काम अधिक संक्षिप्त संकेतन से करते हैं:

# Create `new_list` 
new_list = [n**2 for n in numbers if n%2==0]

# Print `new_list`
print(new_list)
संचालित द्वारा

[0, 4, 16, 36, 64]
संचालित द्वारा

आइए एक छोटे से परीक्षण से list comprehension और for लूप के बीच प्रदर्शन का अंतर देखें: आप इसे timeit लाइब्रेरी के साथ बहुत जल्दी सेट कर सकते हैं, जिसे आप छोटे Python कोड के टुकड़ों का समय मापने के लिए सरल तरीके से उपयोग कर सकते हैं। इस मामले में, आप जिन छोटे कोड टुकड़ों का परीक्षण करेंगे वे हैं for लूप, जिसे आप सुविधा के लिए power_two() नामक फ़ंक्शन में डालेंगे, और वही list comprehension जो आपने ऊपर लिखी है।

नोट कि आप निष्पादन की संख्या भी पास करते हैं। इस मामले में, number आर्ग्यूमेंट में इसे 10000 पर सेट किया गया है।

# Import `timeit`
import timeit
संचालित द्वारा

# Print the execution time
print(timeit.timeit('[n**2 for n in range(10) if n%2==0]', number=10000))
संचालित द्वारा

0.05234622399802902
संचालित द्वारा

# Define `power_two()` 
def power_two(numbers):
    for n in numbers:
        if n%2==0:
            new_list.append(n**2)
    return new_list

# Print the execution time 
print(timeit.timeit('power_two(numbers)', globals=globals(), number=10000))
संचालित द्वारा

0.07795589299712447
संचालित द्वारा

नोट कि इस अंतिम कोड में, आप globals आर्ग्यूमेंट भी जोड़ते हैं, जो कोड को आपके वर्तमान global namespace के भीतर निष्पादित कराता है। यह तब बेहद उपयोगी है जब आपके पास power_two() जैसी User-Defined Function (UDF) हो। वैकल्पिक रूप से, आप एक setup पैरामीटर भी पास कर सकते हैं जिसमें कोई import कथन हो। इसके बारे में आप और यहाँ पढ़ सकते हैं।

टिप: Python में लूप्स पर अधिक जानकारी के लिए DataCamp का Loops in Python ट्यूटोरियल देखें।

Lambda फ़ंक्शंस map(), filter() और reduce() के साथ

Lambda फ़ंक्शंस को "anonymous functions" या "बिना नाम के फ़ंक्शंस" भी कहा जाता है। इसका मतलब है कि आप इस प्रकार के फ़ंक्शंस का उपयोग केवल तब करते हैं जब वे बनाए जाते हैं। Lambda फ़ंक्शंस को उनका नाम Python के lambda कीवर्ड से मिला है, जिसका उपयोग इन फ़ंक्शंस को घोषित करने के लिए मानक def कीवर्ड की बजाय किया जाता है।

आप आम तौर पर इन फ़ंक्शंस का उपयोग map(), filter() और reduce() फ़ंक्शंस के साथ करते हैं।

Lambda फ़ंक्शंस के साथ map() को कैसे बदलें

आप map() और एक lambda फ़ंक्शन के संयोजन को नीचे दिए गए उदाहरण की तरह फिर से लिख सकते हैं:

# Initialize the `kilometer` list 
kilometer = [39.2, 36.5, 37.3, 37.8]

# Construct `feet` with `map()`
feet = map(lambda x: float(3280.8399)*x, kilometer)

# Print `feet` as a list 
print(list(feet))
संचालित द्वारा

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]
संचालित द्वारा

अब, आप feet वेरिएबल को परिभाषित करने वाले इन फ़ंक्शंस के संयोजन को list comprehensions से आसानी से बदल सकते हैं, पिछले भाग में पढ़े गए घटकों को ध्यान में रखते हुए:

• square brackets से शुरू करें।
• फिर उन ब्रैकेट्स में lambda फ़ंक्शन का body जोड़ें: float(3280.8399)*x।
• इसके बाद, for कीवर्ड जोड़ें और sequence एलिमेंट x को दोहराएँ, जिसका आप पहले ही lambda के body में संदर्भ दे चुके हैं।
• मत भूलिए कि x कहाँ से आता है: in कीवर्ड जोड़ें, जिसके बाद वह sequence आएगा जहाँ से आप x लेंगे। इस मामले में, आप kilometer सूची के तत्वों को रूपांतरित करेंगे।

यदि आप यह सब करते हैं, तो आपको निम्न परिणाम मिलेगा:

# Convert `kilometer` to `feet` 
feet = [float(3280.8399)*x for x in kilometer]

# Print `feet`
print(feet)
संचालित द्वारा

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]
संचालित द्वारा

filter() और Lambda फ़ंक्शंस को List Comprehensions में बदलना

अब जब आपने देख लिया है कि आप कितनी आसानी से map() फ़ंक्शन को lambda फ़ंक्शन के साथ बदल सकते हैं, तो आप Python के filter() फ़ंक्शन वाले कोड को भी ले सकते हैं और उसे भी फिर से लिख सकते हैं।

निम्नलिखित उदाहरण पर विचार करें:

# Map the values of `feet` to integers 
feet = list(map(int, feet))

# Filter `feet` to only include uneven distances 
uneven = filter(lambda x: x%2, feet)

# Check the type of `uneven`
type(uneven)

# Print `uneven` as a list
print(list(uneven))
संचालित द्वारा

[122375, 124015]
संचालित द्वारा

ऊपर दिए गए उदाहरण की कोड पंक्तियों को फिर से लिखने के लिए, आप वास्तव में दो list comprehensions का उपयोग कर सकते हैं, जिन्हें feet और uneven, दोनों वेरिएबल्स में संग्रहीत करेंगे।

पहले, आप map() फ़ंक्शन को फिर से लिखते हैं, जिसका उपयोग आप feet सूची के तत्वों को integers में बदलने के लिए करते हैं। फिर, आप filter() फ़ंक्शन को लेते हैं: आप lambda फ़ंक्शन के body को लेते हैं, और for और in कीवर्ड्स का उपयोग करके x और feet को तार्किक रूप से जोड़ते हैं:

# Constructing `feet` 
feet = [int(x) for x in feet]

# Print `feet`
print(feet)

# Get all uneven distances
uneven = [x%2 for x in feet]

# Print `uneven`
print(uneven)
संचालित द्वारा

[128608, 119750, 122375, 124015]
[0, 0, 1, 1]
संचालित द्वारा

Reduce reduce() और Python में Lambda फ़ंक्शंस

अंत में, आप reduce() फ़ंक्शन के साथ उपयोग किए गए lambda फ़ंक्शंस को भी अधिक संक्षिप्त कोड में लिख सकते हैं। निम्नलिखित उदाहरण देखें:

# Import `reduce` from `functools` 
from functools import reduce

# Reduce `feet` to `reduced_feet`
reduced_feet = reduce(lambda x,y: x+y, feet)

# Print `reduced_feet`
print(reduced_feet)
संचालित द्वारा

[128608, 119750, 122375, 124015]
494748
संचालित द्वारा

नोट कि Python 3 में reduce() फ़ंक्शन को functools पैकेज में स्थानांतरित कर दिया गया है। इसलिए, आपको इसे उपयोग करने के लिए मॉड्यूल इम्पोर्ट करना होगा, जैसे कि ऊपर दिए गए कोड उदाहरण में।

ऊपर का कोड खंड काफ़ी लंबा है, है न?

आइए इस कोड को फिर से लिखें!

सावधान रहें! आपको यह ध्यान में रखना होगा कि आप y का उपयोग नहीं कर सकते। List comprehensions एक ही तत्व के साथ काम करती हैं, जैसे कि x जिसे आपने इस ट्यूटोरियल के कई उदाहरणों में देखा है।

आप इसे कैसे हल करेंगे?

खैर, ऐसे मामलों में, sum() जैसी aggregating फ़ंक्शंस उपयोगी हो सकती हैं:

# Construct `reduced_feet`
reduced_feet = sum([x for x in feet])

# Print `reduced_feet`
print(reduced_feet)
संचालित द्वारा

494748
संचालित द्वारा

नोट कि जब आप सोचते हैं, तो lambda फ़ंक्शन के साथ reduce() को फिर से लिखते समय aggregating फ़ंक्शंस का उपयोग करना तर्कसंगत है: यह SQL में उस समय के समान है जब आप अपने क्वेरी के बाद मिलने वाले रिकॉर्ड्स की संख्या सीमित करने के लिए aggregating फ़ंक्शंस का उपयोग करते हैं। इस मामले में, आप sum() फ़ंक्शन का उपयोग feet के तत्वों को जोड़कर एक अंतिम मान प्राप्त करने के लिए करते हैं!

ध्यान दें कि यद्यपि यह दृष्टिकोण SQL में उतना performant न हो, Python में काम करते समय यह निश्चित रूप से अपनाने योग्य तरीका है!

Conditionals के साथ List Comprehensions

अब जब आपने Python में list comprehensions की मूल बातें समझ ली हैं, तो अब conditionals की मदद से अपने comprehensions के control flow को समायोजित करने का समय है।

# Define `uneven`
uneven = [x/2 for x in feet if x%2==0]

# Print `uneven` 
print(uneven)
संचालित द्वारा

[64304.0, 59875.0]
संचालित द्वारा

नोट कि आप ऊपर के कोड खंड को Python for लूप से आसानी से फिर से लिख सकते हैं!

# Initialize and empty list `uneven` 
uneven = []

# Add values to `uneven` 
for x in feet:
    if x % 2 == 0:
        x = x / 2
        uneven.append(x)

# Print `uneven` 
print(uneven)
संचालित द्वारा

[64304.0, 59875.0]
संचालित द्वारा

एकाधिक If शर्तें

अब जब आपने समझ लिया है कि आप शर्तें कैसे जोड़ सकते हैं, तो नीचे दिए गए for लूप को conditionals वाली list comprehension में परिवर्तित करने का समय है।

divided = []

for x in range(100):
    if x%2 == 0 :
        if x%6 == 0:
            divided.append(x)
संचालित द्वारा

ध्यान रखें, आप देखते हैं कि निम्नलिखित for लूप में दो शर्तें हैं! सावधानी से सोचें कि आप इसे कैसे हल करेंगे।

divided = [x for x in range(100) if x % 2 == 0 if x % 6 == 0]

print(divided)
संचालित द्वारा

[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]
संचालित द्वारा

If-Else शर्तें

बेशक, अक्सर एक से अधिक शर्तों वाले conditionals के साथ काम करना अधिक सामान्य है। सही है, आप if को elif और else के संयोजन में अधिक देखेंगे। अब, यदि आप अपना कोड फिर से लिखने की योजना बनाते हैं, तो इससे कैसे निपटें?

ऐसे अधिक जटिल conditional वाले for लूप का निम्नलिखित उदाहरण देखें:

[x+1 if x >= 120000 else x+5 for x in feet]
संचालित द्वारा

[128609, 119755, 122376, 124016]
संचालित द्वारा

अब नीचे दिए गए कोड खंड पर नज़र डालें, जो ऊपर दिए गए कोड का पुनर्लेखन है:

for x in feet:  
    if x >= 120000:
        x + 1
    else: 
        x+5
संचालित द्वारा

आप देखते हैं कि यह मूल रूप से वही कोड है, लेकिन पुनर्संरचित: अंतिम for x in feet अब for लूप को आरंभ करता है। उसके बाद, आप शर्त if x >= 120000 और वह कोड लाइन जोड़ते हैं जिसे आप इस शर्त के True होने पर निष्पादित करना चाहते हैं: x + 1। यदि इसके बजाय शर्त False है, तो आपकी list comprehension का अंतिम हिस्सा निष्पादित होता है: x+5।

Nested List Comprehensions

conditionals के अलावा, आप अपनी list comprehensions को अन्य list comprehensions के भीतर nest करके भी समायोजित कर सकते हैं। जब आप सूचियों की सूचियों के साथ काम करना चाहते हैं: सूचियों की सूचियाँ बनाना, उन्हें transpose करना या उन्हें सामान्य सूचियों में flatten करना, आदि, nested list comprehensions के साथ बेहद आसान हो जाता है।

निम्नलिखित उदाहरण देखें:

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

# Flatten `list_of_list`
[y for x in list_of_list for y in x]
संचालित द्वारा

[1, 2, 3, 4, 5, 6, 7, 8]
संचालित द्वारा

आप एक साधारण सी list of lists को list_of_list वेरिएबल को असाइन करते हैं। अगली पंक्ति में, आप एक list comprehension चलाते हैं जो सामान्य सूची लौटाती है। वास्तव में होता यह है कि आप list_of_list में nested सूचियों (x) के सूची तत्वों (y) को लेते हैं और उन सूची तत्वों y की एक सूची लौटाते हैं जो x में शामिल हैं।

आप देखते हैं कि nested list comprehension के उदाहरण में उपयोग किए गए अधिकांश कीवर्ड और तत्व उन्हीं से मिलते-जुलते हैं जिन्हें आपने साधारण list comprehension उदाहरणों में इस्तेमाल किया था:

• square brackets
• दो for कीवर्ड, जिनके बाद सूचियों की सूची का एक आइटम (x) और nested सूची का एक आइटम (y) दर्शाने वाला वेरिएबल आता है; और
• दो in कीवर्ड, जिनके बाद सूचियों की सूची (list_of_list) और एक सूची आइटम (x) आता है।

अधिकांश घटक दो बार उपयोग होते हैं और आप एक स्तर ऊपर (या नीचे, जैसा भी देखें!) चले जाते हैं।

आदत पड़ने में थोड़ा समय लगता है, लेकिन यह काफ़ी सरल है, है न?

अब एक और उदाहरण पर विचार करें, जहाँ आप देखेंगे कि आप अपनी nested list comprehension की तर्क-प्रणाली को बदलने के लिए दो जोड़ी square brackets का भी उपयोग कर सकते हैं:

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

[[row[i] for row in matrix] for i in range(3)]
संचालित द्वारा

[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
संचालित द्वारा

अब अभ्यास करें: ऊपर दिए गए कोड खंड को nested for लूप में फिर से लिखें। यदि आपको इस अभ्यास को हल करने के लिए कुछ संकेत चाहिए, तो इस ट्यूटोरियल के पिछले किसी भाग पर जाएँ।

transposed = []

for i in range(3):
     transposed_row = []
     for row in matrix:
            transposed_row.append(row[i])
     transposed.append(transposed_row)
संचालित द्वारा

आप nested list comprehensions का उपयोग तब भी कर सकते हैं जब आपको किसी list of lists को बनाना हो जो वास्तव में एक मैट्रिक्स है। निम्नलिखित उदाहरण देखें:

matrix = [[0 for col in range(4)] for row in range(3)]

matrix
संचालित द्वारा

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
संचालित द्वारा

टिप: Python में अपने लूप कौशल का अभ्यास करें और ऊपर दिए गए कोड खंड को nested for लूप में फिर से लिखें!

आप नीचे समाधान पा सकते हैं।

for x in range(3):
    nested = []
    matrix.append(nested)
    for row in range(4):
        nested.append(0)
संचालित द्वारा

यदि आप कुछ और अभ्यास करना चाहते हैं, तो इस for लूप को while लूप में बदलने पर काम करें। आप नीचे समाधान पा सकते हैं:

x = 0
matrix =[]

while x < 3:
    nested = []
    y = 0
    matrix.append(nested)
    x = x+1
    while y < 4:
        nested.append(0)
        y= y+1
संचालित द्वारा

अंत में, यह जानना अच्छा है कि आप int() जैसी फ़ंक्शंस का उपयोग करके अपनी feet सूची की प्रविष्टियों को integers में भी बदल सकते हैं। [int(x) for x in feet] को किसी अन्य list comprehension के भीतर समाहित करके, आप आसानी से अपनी सूची की सूचियाँ या मैट्रिक्स बना लेते हैं:

[[int(x) for x in feet] for x in feet]
संचालित द्वारा

[[128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015]]
संचालित द्वारा

डेटा साइंस के लिए Python में महारत हासिल करें

बधाई हो! आप इस ट्यूटोरियल के अंत तक पहुँच चुके हैं, जिसमें आपने list comprehensions सीखी, जो Python में डेटा साइंस के लिए अक्सर उपयोग की जाने वाली तकनीक है। अब जब आप इस तंत्र के कामकाज को समझते हैं, तो आप dictionary, set, ... comprehensions भी सीखने के लिए तैयार हैं!

यह न भूलें कि आप DataCamp के दैनिक practice mode के साथ रोज़ाना अपने Python कौशल का अभ्यास कर सकते हैं! आप इसे अपने डैशबोर्ड पर ही पाएँगे। यदि आप अभी तक daily practice mode नहीं जानते, तो यहाँ पढ़ें! और DataCamp के पूरे Python कोर्स कैटलॉग को यहाँ एक्सप्लोर करें।

हालाँकि list comprehensions हमारा कोड अधिक संक्षिप्त बना सकती हैं, यह सुनिश्चित करना महत्त्वपूर्ण है कि हमारा अंतिम कोड यथासंभव पठनीय हो, इसलिए बहुत लंबी सिंगल-लाइन कोड से बचना चाहिए ताकि हमारा कोड उपयोगकर्ता-अनुकूल बना रहे।