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

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 चाहिए।

इंडेक्स या पूरे दायरे को 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 है!

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

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

निष्कर्ष

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