Python List Comprehension — एक line में list बनाना

Syntax — पढ़ने का सही क्रम

List comprehension एक ही expression में किसी iterable से नई list बनाता है। ये उस pattern की जगह लेता है जो हर beginner सबसे पहले लिखता है — खाली list बनाओ, loop चलाओ, append करो।

[ expression  for item in iterable  if condition ]
   ^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^
   क्या store   कहाँ से आ रहा है      optional filter
   करना है

इसे इसी क्रम में पढ़ो और ये हिन्दी जैसा लगता है: मुझे x * 2 दो, हर x के लिए nums में, जहाँ x > 0।

nums = [1, -2, 3, -4, 5]

# वो loop जिसकी जगह ये लेता है
result = []
for x in nums:
    if x > 0:
        result.append(x * 2)

# comprehension
result = [x * 2 for x in nums if x > 0]     # [2, 6, 10]

दो बातें अक्सर छूट जाती हैं। पहली — आखिर वाला if तय करता है कौन से items अंदर आएँगे; expression के अंदर वाला if/else हर item को बदलता है। दूसरी — loop variable बाहर leak नहीं होता, जबकि सादे for loop में वो आखिरी value के साथ बचा रहता है।

Filter और transform में फर्क

यही सबसे आम गलती है। दोनों में if है, लेकिन जगह अलग है और नतीजा बिल्कुल अलग:

[x for x in nums if x > 0]              # filter — output छोटी हो जाती है
[x if x > 0 else 0 for x in nums]       # transform — length वही रहती है

nums = [1, -2, 3]
# filter    -> [1, 3]      (दो items)
# transform -> [1, 0, 3]   (तीन items)

याद रखने का आसान तरीका: if सबसे आखिर में हो तो वो filter है। if ... else सबसे शुरू में हो तो वो transform है।

रोज़मर्रा के patterns

# transform
[x * 2 for x in nums]
[s.strip().lower() for s in names]
[str(n) for n in ids]                        # join() से पहले numbers को string बनाना

# filter
[x for x in nums if x % 2 == 0]
[line for line in lines if line.strip()]     # खाली lines हटाना
[u for u in users if u["active"]]

# दोनों साथ
[u["email"] for u in users if u["active"]]

# index के साथ
[f"{i}: {name}" for i, name in enumerate(names)]

# दो iterables से
[a + b for a, b in zip(one, two)]

# nested data से
[row["total"] for row in report["rows"]]
[order for batch in batches for order in batch]   # एक level flatten

Nested comprehension

ज़्यादा for clauses बाएँ से दाएँ लगते हैं — बाहरी loop पहले। आगे वाला expression उन सब variables को use कर सकता है जो अब तक आए हैं:

grid = [[1, 2, 3], [4, 5, 6]]

[x for row in grid for x in row]        # [1, 2, 3, 4, 5, 6] — flatten

# बराबर का loop, जो गहरी nesting पर ज़्यादा साफ पढ़ा जाता है
flat = []
for row in grid:
    for x in row:
        flat.append(x)

# structure बनाए रखना: comprehension के अंदर comprehension
[[x * 2 for x in row] for row in grid]  # [[2, 4, 6], [8, 10, 12]]

# अंदर वाले loop पर filter
[x for row in grid for x in row if x % 2 == 0]     # [2, 4, 6]

व्यवहारिक सीमा दो for clauses है। तीन होने पर, या हर एक पर if लगने पर, उसे समझने के लिए दिमाग में खोलना पड़ता है — और उस point पर nested loop ही साफ code है।

Dict, set और generator comprehension

वही grammar बाकी तीन collections भी बनाता है। सिर्फ bracket बदलता है, और dict में key/value pair जुड़ता है:

# dict comprehension — ध्यान रहे, colon है
{u["id"]: u["name"] for u in users}
{name: len(name) for name in names}
{k: v for k, v in pairs if v}                     # filtered
{v: k for k, v in mapping.items()}                # key-value उलट

# set comprehension — duplicates खुद हट जाते हैं
{w.lower() for w in words}
{n % 3 for n in nums}

# generator expression — parentheses, और ये LAZY है
gen = (x * x for x in range(10**9))               # अभी कुछ बनता ही नहीं
next(gen)                                         # 0 — एक-एक item

# सबसे ज़्यादा उपयोगी तब, जब तुरंत consume हो जाए
sum(x * x for x in nums)                          # call के अंदर parentheses ज़रूरी नहीं
max(len(n) for n in names)
"\n".join(str(r) for r in rows)
any(n < 0 for n in nums)

बड़े data के लिए generator वाली form चुनो। [x for x in huge] पहला item दिखने से पहले सारे items memory में बना लेता है; (x for x in huge) लगभग कुछ नहीं रखता और infinite sequences पर भी चलता है।

कब plain for loop ही लिखना चाहिए

Comprehension में सिर्फ expressions आ सकते हैं। जो statement है, उसके लिए loop चाहिए:

• break से जल्दी बाहर निकलना — break statement है। Loop लिखो, या "पहला match ढूँढो" के लिए next()।
• हर item पर try/except लगाना — वो statement है।
• बीच में variable assign करना — assignment statement है। Walrus operator := अकेला विकल्प है, और वो अक्सर readability नहीं बढ़ाता।
• एक से ज़्यादा output बनाना — comprehension एक ही collection देता है।
• हर step पर comment लिखना — जगह ही नहीं है। यही निशानी है कि logic loop में होना चाहिए।

# हर item पर try/except चाहिए — loop लिखो
parsed = []
for raw in lines:
    try:
        parsed.append(int(raw))
    except ValueError:
        log_skip(raw)

# "पहला match ढूँढो" — next() से, loop की ज़रूरत नहीं
first = next((u for u in users if u["id"] == target), None)

एक debugging वजह भी है। Comprehension में error आने पर traceback में एक ही line मिलती है और गलत item देखने का तरीका नहीं होता। Loop में आप जहाँ चाहो print लगा सकते हो। Logic समझते वक्त loop बेहतर औजार है — बाद में comprehension में बदल लो।

आम गलतियाँ

• Filter और transform की अदला-बदली। if को गलत जगह रख देना यहाँ सबसे आम गलती है।
• Comprehension के बाद loop variable use करना। वो exist ही नहीं करता — comprehension का अपना scope होता है।
• Multiplication से grid बनाना। [[0] * 3] * 2 दो reference बनाता है एक ही अंदरूनी list के, तो एक row बदलने पर दोनों बदल जाती हैं। [[0] * 3 for _ in range(2)] अलग-अलग rows बनाता है।
• Comprehension को generator कहना। Square bracket सारी list memory में बना देता है; lazy behaviour सिर्फ parentheses से मिलता है।
• दो level से गहरी nesting। Parse हो जाता है, पर पढ़ा नहीं जाता।

grid = [[0] * 3] * 2
grid[0][0] = 9
print(grid)      # [[9, 0, 0], [9, 0, 0]]  — दोनों rows बदल गईं!

grid = [[0] * 3 for _ in range(2)]
grid[0][0] = 9
print(grid)      # [[9, 0, 0], [0, 0, 0]]  — सही

Comprehension या loop — तीन सवाल

तीन सवाल पूछो। क्या हर item के लिए एक ही expression है? क्या ज़्यादा से ज़्यादा एक filter और दो for clauses हैं? क्या आप इसे एक ही साँस में पढ़ सकते हो? तीनों हाँ हों तो comprehension जीतता है। कोई एक भी ना हो, तो for loop बेहतर code है — style की कमी नहीं, सही औजार।

आदत उलटी बनाना ज़्यादा फायदेमंद है: पहले loop लिखो जब तक logic समझ आ रहा हो, फिर सही होने पर comprehension में समेट लो। इससे comprehension की सफाई भी मिलती है और उसके अंदर debug भी नहीं करना पड़ता।

🛠️ Practice करो (free, browser में)

पढ़ना काफी नहीं — यही bug खुद fix करके देखो। नीचे के problems browser में ही चलते हैं, कोई install नहीं, कोई login नहीं।

• Dictionary comprehension with condition — filter + dict दोनों साथ।
• Division by zero in a list comprehension — comprehension के अंदर error handle करना।

अक्सर पूछे जाने वाले सवाल

आगे पढ़ो

• Read this in English
• Dictionary comprehension Hindi में
• For loop Hindi में
• List methods Hindi में
• Hindi hub — सारे Hindi guides