ਲਿਸਟ ਕਮਪ੍ਰਿਹੈਨਸ਼ਨ ਕੀ ਹਨ?

Question

Accepted Answer

ਇੱਕ **ਲਿਸਟ ਕਮਪ੍ਰਿਹੈਨਸ਼ਨ** ਇੱਕ ਸੰਖੇਪ ਅਤੇ ਪੜ੍ਹਨ ਯੋਗ ਤਰੀਕਾ ਹੈ ਜੋ ਇੱਕ iterable ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਐਕਸਪ੍ਰੈਸ਼ਨ ਵਿਚ ਟ੍ਰਾਂਸਫਾਰਮ ਅਤੇ/ਜਾਂ ਫਿਲਟਰ ਕਰ ਕੇ ਇੱਕ ਲਿਸਟ ਬਣਾਉਂਦਾ ਹੈ — Python ਦਾ `for` ਲੂਪ ਦਾ idiomatically ਬਦਲ ਜੋ ਇੱਕ ਲਿਸਟ ਵਿਚ append ਕਰਦਾ ਹੈ।

## ਮੂਲ ਸਿੰਟੈਕਸ

```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
```

ਉਹੀ ਸਿੰਟੈਕਸ sets ਅਤੇ dicts ਬਣਾਉਂਦਾ ਹੈ; ਪੈਰੈਨਥੀਸਿਜ਼ ਨਾਲ ਇਹ ਇੱਕ **generator expression** ਬਣ ਜਾਂਦਾ ਹੈ ਜੋ ਮੁੱਲ ਦੇਰੀ ਨਾਲ ਪੈਦਾ ਕਰਦਾ ਹੈ (ਮੈਮਰੀ ਵਿਚ ਪੂਰੀ ਲਿਸਟ ਨਹੀਂ — ਬਡੇ ਡੈਟਾ ਲਈ ਸ਼ਾਨਦਾਰ)।

## ਜਦੋਂ ਸਰਵਰ ਨਾ ਕਰੋ

```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" ਹਨ — ਸੰਖੇਪ, ਪੜ੍ਹਨ ਯੋਗ, ਅਤੇ ਅਕਸਰ ਬਰਾਬਰ ਲੂਪਸ ਨਾਲੋਂ ਤੇਜ਼, ਡੈਟਾ ਨੂੰ ਟ੍ਰਾਂਸਫਾਰਮ ਅਤੇ ਫਿਲਟਰ ਕਰਨ ਲਈ ਲਗਾਤਾਰ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।

ਉਹਨਾਂ ਵਿਚ ਮੁਹਾਰਤ ਪ੍ਰਾਪਤ ਕਰਨਾ (ਇਲਾਵਾ ਉਹਨਾਂ ਦੇ set/dict/generator ਵੇਰੀਐਂਟਸ, ਅਤੇ ਬਡੇ ਡੈਟਾ ਲਈ ਆਲਸੀ generator expression) Python ਲਿਖਣ ਲਈ ਜਰੂਰੀ ਹੈ।

ਇਹ ਜਾਨਣਾ ਕਿ ਉਹਨਾਂ ਨੂੰ ਕਦੋਂ ਵਰਤਣਾ ਹੈ (ਸਧਾਰਣ ਟ੍ਰਾਂਸਫਾਰਮਸ/ਫਿਲਟਰਸ) ਬਨਾਮ ਸਾਧਾਰਣ ਲੂਪ (ਗੁੰਝਲਦਾਰ ਲਾਜਿਕ) ਸਾਫ਼, ਪੜ੍ਹਨ ਯੋਗ ਕੋਡ ਦਾ ਚਿਹਨ ਹੈ।