# Python में लिस्ट (list): मेथड, स्लाइस, सॉर्टिंग, append, टपल और सेट

URL: https://skillaria.top/hi/guides/python/spiski-python

Python की लिस्ट (list) वर्गाकार ब्रैकेट में लिखे गए मानों का क्रमबद्ध और बदले जा सकने वाला संग्रह है, जैसे [250, 1200, 99]: तत्व append से जोड़े जाते हैं, बीच में डाले, हटाए, स्लाइस से काटे और सॉर्ट किए जा सकते हैं। sort सूची को उसी जगह पर सॉर्ट करता है और None लौटाता है, जबकि sorted नई सॉर्ट की गई सूची लौटाता है।

Python की लिस्ट (`list`) वर्गाकार ब्रैकेट में लिखे किसी भी मानों का क्रमबद्ध संग्रह है, जिसे बदला जा सकता है: अंत में तत्व जोड़ना, बीच में डालना, हटाना, सॉर्ट करना। यह भाषा का सबसे ज़्यादा इस्तेमाल होने वाला संग्रह है: फ़ाइल की पंक्तियाँ, महीने भर के ख़र्च, API के जवाब — लगभग हर चीज़ लिस्ट से शुरू होती है। यहाँ python list को पूरा समझते हैं: बनाना, मेथड, स्लाइस, सॉर्टिंग, कॉम्प्रिहेंशन, कॉपी करना, और अंत में टपल और सेट।

## Python में लिस्ट क्या है

लिस्ट तत्वों को उसी क्रम में रखती है जिसमें आप उन्हें देते हैं, और शून्य से शुरू होने वाले इंडेक्स से उन तक पहुँचा जाता है। एक ही लिस्ट में अलग-अलग प्रकार के मान हो सकते हैं, हालाँकि व्यवहार में आम तौर पर एक जैसे डेटा रखे जाते हैं।

```
amounts = [250, 1200, 99]
print(amounts[0])     # 250 — पहला तत्व
print(amounts[-1])    # 99 — आख़िरी तत्व
amounts[1] = 1300     # लिस्ट बदली जा सकती है
print(len(amounts))   # 3 — लिस्ट की लंबाई
```

लिस्ट का आकार `len()` फ़ंक्शन बताता है। मौजूद न होने वाले इंडेक्स पर जाने से `IndexError: list index out of range` आता है।

## लिस्ट बनाना

```
empty = []                       # खाली लिस्ट
also_empty = list()              # वही, list फ़ंक्शन से
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]
```

`list()` किसी भी इटरेबल चीज़ को लिस्ट में बदल देता है: स्ट्रिंग, `range`, सेट, डिक्शनरी की कुंजियाँ।

## append और अन्य लिस्ट मेथड

`append` एक तत्व को अंत में जोड़ता है — Python का सबसे आम मेथड। यह लिस्ट को उसी जगह बदलता है और `None` लौटाता है।

```
amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # पहला मान 1200 हटाएँ
last = amounts.pop()         # 20 — हटाकर लौटाएँ, आख़िरी तत्व
```

आम गलती: `a.append([10, 20])` एक ही तत्व जोड़ेगा — यानी एक नेस्टेड लिस्ट, दो संख्याएँ नहीं। कई तत्वों के लिए `extend` चाहिए।

| मेथड | क्या करता है |
| --- | --- |

| `append(x)` | x को अंत में जोड़ना |

| `extend(iter)` | क्रम के सारे तत्व जोड़ना |

| `insert(i, x)` | इंडेक्स i से पहले x डालना |

| `remove(x)` | x की पहली घटना हटाना (न मिले तो ValueError) |

| `pop(i=-1)` | इंडेक्स का तत्व हटाकर लौटाना |

| `index(x)` | x की पहली घटना का इंडेक्स |

| `count(x)` | x कितनी बार आया |

| `sort()` | उसी जगह सॉर्ट करना |

| `reverse()` | उसी जगह उल्टा करना |

| `copy()` | सतही प्रतिलिपि |

| `clear()` | लिस्ट खाली करना |

इंडेक्स या पूरे दायरे को `del` स्टेटमेंट से भी हटाया जा सकता है: `del a[0]`, `del a[1:3]`। लिस्ट के लिए उपयोगी बिल्ट-इन फ़ंक्शन: `len`, `sum`, `min`, `max`, `sorted`, `reversed`, `enumerate`, `zip`।

## Python में स्लाइस

स्लाइस `a[start:stop:step]` से लिस्ट का हिस्सा लेता है: `start` से शुरू (शामिल), `stop` तक (शामिल नहीं), `step` के कदम से। कोई भी हिस्सा छोड़ा जा सकता है। स्लाइस हमेशा नई लिस्ट लौटाता है।

```
a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — पहले दो
print(a[-2:])     # [4, 5] — आख़िरी दो
print(a[::2])     # [0, 2, 4] — हर दूसरा
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — उल्टी
print(a[:])       # पूरी लिस्ट की प्रतिलिपि
```

इंडेक्स के उलट, लिस्ट की सीमा के बाहर का स्लाइस त्रुटि नहीं देता: `a[10:20]` सिर्फ़ `[]` लौटाता है। स्लाइस में मान असाइन करके लिस्ट का हिस्सा बदला भी जा सकता है: `a[1:3] = ["x", "y", "z"]`।

### स्ट्रिंग का स्लाइस

स्लाइस हर अनुक्रम पर एक जैसा काम करता है, स्ट्रिंग और टपल पर भी:

```
s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP
```

स्ट्रिंग को स्लाइस से बदला नहीं जा सकता — स्ट्रिंग बदली नहीं जाती, स्लाइस नई स्ट्रिंग बनाता है।

## लिस्ट सॉर्ट करना: sort और sorted

यहीं नए छात्र सबसे ज़्यादा उलझते हैं। `sort` मेथड सूची के भीतर ही तत्वों को क्रम में लगाता है और `None` लौटाता है। `sorted` फ़ंक्शन मूल लिस्ट को नहीं छूता और एक नई सॉर्ट की गई लिस्ट लौटाता है।

```
amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — नई प्रतिलिपि
print(amounts)             # [250, 1200, 99, 450] — मूल सुरक्षित

result = amounts.sort()    # उसी जगह सॉर्ट
print(result, amounts)     # None [99, 250, 450, 1200]
```

यहीं से मशहूर सवाल आता है «मुझे None क्यों मिल रहा है»: `a = a.sort()` लिस्ट को `None` मान से भर देता है। लिखें या तो `a.sort()`, या `a = sorted(a)`।

### कुंजी (key) और उल्टा क्रम

दोनों में `key` और `reverse` पैरामीटर होते हैं। `key` एक फ़ंक्शन है, जिसके परिणाम से तत्वों की तुलना होती है।

```
words = ["कॉफ़ी", "टैक्सी", "सदस्यता"]
print(sorted(words, key=len))               # लंबाई के अनुसार
print(sorted(words, key=str.lower))         # अक्षरों के आकार को नज़रअंदाज़ करके
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("खाना", 650), ("सिनेमा", 120), ("टैक्सी", 300)]
expenses.sort(key=lambda e: e[1])           # रकम के अनुसार
```

Python की सॉर्टिंग स्थिर (stable) है: एक जैसी कुंजी वाले तत्व अपना मूल क्रम बनाए रखते हैं। फ़र्क यह भी है कि `sorted` किसी भी अनुक्रम (स्ट्रिंग, डिक्शनरी, सेट) पर चलता है, जबकि `sort` सिर्फ़ लिस्ट का मेथड है।

## लिस्ट उल्टी करना

तीन तरीके हैं, और उनका व्यवहार अलग है:

- `a.reverse()` — उसी जगह उल्टा करता है, `None` लौटाता है;
- `a[::-1]` — उल्टी हुई नई लिस्ट;
- `reversed(a)` — आलसी (lazy) इटरेटर, लूप में सुविधाजनक: `for x in reversed(a):`।

## लिस्ट पर लूप

```
items = ["कॉफ़ी", "मेट्रो", "सिनेमा"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 कॉफ़ी, 2 मेट्रो, 3 सिनेमा

print("सिनेमा" in items)    # True — मौजूदगी की जाँच
```

जिस लिस्ट पर लूप चल रहा हो, उसमें से तत्व न हटाएँ — कुछ तत्व छूट जाएँगे। नई लिस्ट कॉम्प्रिहेंशन से बनाएँ, या लूप प्रतिलिपि `a[:]` पर चलाएँ।

## लिस्ट कॉम्प्रिहेंशन (list comprehension)

कॉम्प्रिहेंशन एक ही पंक्ति में नई लिस्ट बनाता है: एक व्यंजन, एक लूप और वैकल्पिक शर्त।

```
squares = [n * n for n in range(6)]          # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
names = [s.strip().title() for s in [" अनीता ", "रवि"]]
```

कॉम्प्रिहेंशन आम तौर पर `append` वाले लूप से तेज़ और ज़्यादा पढ़ने लायक होता है। लेकिन अगर तर्क एक साफ़ पंक्ति में न समाए, तो सामान्य लूप बेहतर है।

## लिस्ट जोड़ना, मिलाना और घटाना

```
a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — नई लिस्ट
a += b             # यह a.extend(b) जैसा है
print([*a, *b])    # अनपैकिंग से नई लिस्ट
```

लिस्ट के लिए `-` ऑपरेटर नहीं है। एक लिस्ट से दूसरी के तत्व हटाने के लिए कॉम्प्रिहेंशन लें: `[x for x in a if x not in set(b)]`। दो लिस्टों का प्रतिच्छेदन (intersection) सेट से सबसे आसानी से निकलता है: `set(a) & set(b)` (इसमें क्रम और दोहराव खो जाते हैं)।

## नेस्टेड और द्वि-आयामी लिस्ट

लिस्ट की लिस्ट तालिका या मैट्रिक्स रखने का सरल तरीका है:

```
matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # सही तरीका
bad = [[0] * 3] * 2                  # जाल: एक ही लिस्ट के दो संदर्भ
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]
```

## लिस्ट अनपैकिंग

```
first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — लिस्ट को बिना ब्रैकेट के छापना
```

अगर वेरिएबल की संख्या लिस्ट की लंबाई से मेल न खाए, तो `ValueError` आएगा — ऐसे में तारे (*) वाला वेरिएबल काम आता है।

## लिस्ट की कॉपी बनाना

`b = a` लिस्ट की कॉपी नहीं बनाता, बल्कि उसी ऑब्जेक्ट पर दूसरा नाम चिपका देता है: `b` से किया बदलाव `a` में भी दिखता है। स्वतंत्र प्रतिलिपि साफ़ तौर पर बनानी होती है: `a.copy()`, `list(a)` या `a[:]`। नेस्टेड डेटा के लिए यह काफ़ी नहीं — भीतरी लिस्ट साझा रहेंगी, इसके लिए `copy.deepcopy(a)` चाहिए।

```
import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — भीतरी लिस्ट साझा है
c = copy.deepcopy(a)     # पूरी तरह स्वतंत्र प्रतिलिपि
```

## टपल: न बदली जा सकने वाली लिस्ट

टपल (`tuple`) लिस्ट जैसा है, पर बनने के बाद उसे बदला नहीं जा सकता। यह पढ़ने वाले के लिए साफ़ संकेत है: सामने एक तय फ़ील्ड वाला रिकॉर्ड है, बढ़ता हुआ संग्रह नहीं। टपल आसानी से अनपैक होते हैं, और फ़ंक्शन कई मान लौटाने के लिए इन्हीं का इस्तेमाल करते हैं।

```
expense = (250, "कॉफ़ी")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment
```

न बदले जा सकने वाले मानों का टपल हैश किया जा सकता है, इसलिए वह डिक्शनरी की कुंजी बन सकता है। एक तत्व वाला टपल कॉमा से लिखा जाता है: `(5,)`।

## सेट: सिर्फ़ अनूठे मान

सेट (`set`) सिर्फ़ अनूठे मान रखता है और क्रम याद नहीं रखता। दोहराव हटाने और «क्या यह तत्व मौजूद है» जाँचने का यह सबसे तेज़ तरीका है। साथ ही इससे प्रतिच्छेदन, संघ (union) और अंतर (difference) भी निकलते हैं।

```
jan = {"खाना", "टैक्सी", "सिनेमा"}
feb = {"खाना", "सदस्यता"}
print(jan & feb)    # {'खाना'}
print(feb - jan)    # {'सदस्यता'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — दोहराव नहीं, क्रम बचा
empty = set()       # {} तो खाली dict है!
```

## कौन-सा संग्रह चुनें

| काम | संग्रह |
| --- | --- |

| क्रम और बदलाव | `list` |

| तय फ़ील्ड वाला रिकॉर्ड | `tuple` |

| कुंजी से खोजना | `dict` |

| अनूठापन, «क्या यह है» की जाँच | `set` |

| न बदले जा सकने वाले सेटिंग्स | `frozendict` (Python 3.15) |

`x in list` तत्वों को एक-एक करके देखता है, जबकि `x in set` लगभग तुरंत काम करता है। अगर लूप में बड़ी लिस्ट में बार-बार मौजूदगी जाँचनी हो, तो उसे सेट में बदल लें।

## निष्कर्ष

Python की लिस्ट क्रमबद्ध और बदली जा सकने वाली संरचना है: `append` और `extend` जोड़ते हैं, `pop` और `remove` हटाते हैं, `a[start:stop:step]` के स्लाइस हिस्से काटते हैं, `sort` उसी जगह सॉर्ट करता है और `None` लौटाता है, जबकि `sorted` नई लिस्ट देता है। कॉपी साफ़ तौर पर बनाएँ, तय रिकॉर्ड के लिए टपल लें और अनूठे मानों के लिए सेट। लिस्ट, टपल, डिक्शनरी और सेट को «Python 3.15: शुरुआत से प्रो तक» कोर्स में व्यवहार में समझाया गया है।

## FAQ

**Python की लिस्ट और दूसरी भाषाओं के array में क्या फ़र्क है?**

Python में दूसरी भाषाओं वाला अलग array नहीं है, उसकी जगह लिस्ट है, जो अलग-अलग प्रकार के मान रख सकती है। कॉम्पैक्ट संख्यात्मक arrays के लिए मॉड्यूल array और लाइब्रेरी NumPy हैं।

**लिस्ट में किसी तत्व का इंडेक्स कैसे पता करें?**

मेथड a.index(x) x की पहली घटना का इंडेक्स लौटाता है, और न मिलने पर ValueError देता है। इसलिए कॉल से पहले x in a से जाँच लें।

**लिस्ट से दोहराव हटाकर क्रम कैसे बचाएँ?**

list(dict.fromkeys(a)) का उपयोग करें: डिक्शनरी कुंजियाँ अनूठी और डालने के क्रम में रखती है। list(set(a)) भी दोहराव हटाता है, पर क्रम नहीं बचाता।

**स्ट्रिंग की लिस्ट को एक स्ट्रिंग में कैसे जोड़ें?**

स्ट्रिंग के मेथड join से: ", ".join(["a", "b", "c"]) से "a, b, c" मिलेगा। सभी तत्व स्ट्रिंग होने चाहिए; संख्याओं को पहले map(str, a) से बदलें।

**क्या लिस्ट में अलग-अलग प्रकार के तत्व रखे जा सकते हैं?**

हाँ, लिस्ट में एक साथ संख्याएँ, स्ट्रिंग, दूसरी लिस्टें और कोई भी ऑब्जेक्ट हो सकते हैं। पर ऐसी लिस्ट को key के बिना सॉर्ट करना आम तौर पर संभव नहीं — संख्या की तुलना स्ट्रिंग से करने पर TypeError आएगा।


---
Source: Skillaria.Top (https://skillaria.top)