लिस्ट कम्प्रीहेंशन क्या है?

Question

Accepted Answer

**लिस्ट कम्प्रीहेंशन** एक संक्षिप्त, पठनीय तरीका है एक सूची को एक एकल अभिव्यक्ति में एक iterable को रूपांतरित और/या फ़िल्टर करके बनाने का — Python का आदर्श विकल्प `for` लूप के बजाय जो एक सूची में जोड़ता है।

## मूल सिंटैक्स

```python
# the loop way:
squares = []
for n in range(5):
    squares.append(n ** 2)

# the comprehension way — same result, one line
squares = [n ** 2 for n in range(5)]   # [0, 1, 4, 9, 16]
#          └expr──┘ └──for clause───┘
```

इसे "n का वर्ग, range(5) में प्रत्येक n के लिए" के रूप में पढ़ें। यह मैनुअल लूप की तुलना में अधिक संक्षिप्त और अक्सर तेज़ है।

## फ़िल्टर जोड़ना (if)

```python
# keep only even numbers
evens = [n for n in range(10) if n % 2 == 0]   # [0, 2, 4, 6, 8]

# transform AND filter together
result = [n * 2 for n in range(10) if n % 2 == 0]  # [0, 4, 8, 12, 16]
```

## आउटपुट में सशर्त अभिव्यक्ति

```python
# if/else goes BEFORE the for (it's part of the expression, not a filter)
labels = ["even" if n % 2 == 0 else "odd" for n in range(4)]
# ["even", "odd", "even", "odd"]
```

## अन्य प्रकारों के लिए कम्प्रीहेंशन

```python
{x ** 2 for x in range(5)}             # set comprehension → {0, 1, 4, 9, 16}
{k: v for k, v in pairs}               # dict comprehension
(x ** 2 for x in range(5))             # generator expression — LAZY, memory-efficient
```

वही सिंटैक्स सेट और dicts बनाता है; कोष्ठक के साथ यह एक **जनरेटर अभिव्यक्ति** बन जाता है जो मूल्यों को आलसी तरीके से पैदा करता है (स्मृति में कोई पूर्ण सूची नहीं — बड़े डेटा के लिए बहुत अच्छा)।

## जब उनका उपयोग न करें

```python
# ❌ deeply nested / complex logic → a regular loop is more readable
matrix = [[row[i] for row in data] for i in range(cols)]  # OK, but don't over-nest
```

कम्प्रीहेंशन को सरल रखें; यदि उन्हें कई नेस्टेड लूप या जटिल शर्तों की आवश्यकता है, तो एक साधारण लूप स्पष्ट है।

## यह क्यों महत्वपूर्ण है

लिस्ट कम्प्रीहेंशन विशिष्ट रूप से "Pythonic" हैं — संक्षिप्त, पठनीय, और अक्सर समतुल्य लूप से तेज़, डेटा को रूपांतरित और फ़िल्टर करने के लिए लगातार उपयोग किए जाते हैं।

उन्हें महारत हासिल करना (साथ ही उनके सेट/dict/जनरेटर वेरिएंट, और बड़े डेटा के लिए आलसी जनरेटर अभिव्यक्ति) Python को आदर्श रूप से लिखने के लिए आवश्यक है।

जानना कि उनका उपयोग कब करें (सरल रूपांतरण/फ़िल्टर) बनाम नियमित लूप (जटिल तर्क) स्वच्छ, पठनीय कोड का संकेत है।