Comprehensive theory, key formulas, diagrams, and memory aids for लिस्ट्स.
लिस्ट (List) पाइथन का एक कम्पोज़िट डेटा प्रकार है जो कई मानों को एक साथ संग्रहीत करता है। लिस्ट वर्गाकार कोष्ठक [] में लिखी जाती है और उसके तत्व कॉमा से अलग होते हैं। लिस्ट परिवर्तनीय (Mutable) होती है, अर्थात लिस्ट बनने के बाद भी उसके तत्वों को बदला, जोड़ा या हटाया जा सकता है। लिस्ट में विभिन्न डेटा प्रकारों के तत्व हो सकते हैं। इस अध्याय में हम लिस्ट का निर्माण, इंडेक्सिंग, स्लाइसिंग, संचालन, मेथड और लिस्ट कम्प्रिहेंशन का अध्ययन करेंगे।
list1 = [1, 2, 3, 4, 5]
list2 = ["सेब", "आम", "केला"]
list3 = [1, "दो", 3.5, True]
list4 = []
list5 = [1, 2, [3, 4], 5]
empty = []
print(type(list1)) # <class 'list'>
print(len(list2)) # 3
लिस्ट में किसी भी प्रकार के तत्व (int, float, str, bool, यहाँ तक कि दूसरी लिस्ट) रखे जा सकते हैं। खाली लिस्ट [] के द्वारा बनती है।
लिस्ट की इंडेक्सिंग स्ट्रिंग की तरह 0 से शुरू होती है। धनात्मक इंडेक्सिंग बाएँ से और ऋणात्मक इंडेक्सिंग दाएँ से (-1 से) होती है।
marks = [45, 67, 89, 34, 78]
print(marks[0]) # 45
print(marks[3]) # 34
print(marks[-1]) # 78
print(marks[-2]) # 34
स्लाइसिंग से लिस्ट का उप-भाग प्राप्त किया जा सकता है। परिणाम हमेशा एक नई लिस्ट होती है।
marks = [10, 20, 30, 40, 50]
print(marks[1:3]) # [20, 30]
print(marks[:3]) # [10, 20, 30]
print(marks[2:]) # [30, 40, 50]
print(marks[-3:]) # [30, 40, 50]
print(marks[::2]) # [10, 30, 50]
a = [1, 2, 3]
b = [4, 5]
print(a + b) # [1, 2, 3, 4, 5]
print(a * 2) # [1, 2, 3, 1, 2, 3]
print(2 in [1, 2, 3]) # True
print(9 not in [1, 2, 3]) # True
print([1, 2] == [1, 2]) # True
print([1, 2] < [1, 3]) # True
fruits = ["सेब"]
fruits.append("आम") # अंत में जोड़ना
fruits.extend(["केला", "अंगूर"]) # कई तत्व जोड़ना
fruits.insert(1, "नाशपाती") # निर्दिष्ट स्थान पर जोड़ना
print(fruits)
nums = [5, 10, 15, 10, 20]
nums.remove(10) # पहला 10 हटाएगा
print(nums) # [5, 15, 10, 20]
popped = nums.pop() # अंतिम तत्व हटाकर लौटाता है
print(popped) # 20
nums.pop(0) # इंडेक्स 0 हटाना
del nums[0] # इंडेक्स 0 हटाना
nums = [3, 1, 4, 1, 5]
nums.sort() # आरोही क्रम
nums.sort(reverse=True) # अवरोही क्रम
nums.reverse() # क्रम उल्टा
print(nums.index(4)) # तत्व की स्थिति
print(nums.count(1)) # गिनती
print(len(nums)) # लंबाई
print(max(nums), min(nums), sum(nums)) # अधिकतम, न्यूनतम, योग
स्ट्रिंग के विपरीत, लिस्ट परिवर्तनीय (Mutable) है। इसका अर्थ है कि हम इंडेक्स के द्वारा तत्वों को बदल सकते हैं।
marks = [10, 20, 30]
marks[1] = 25
print(marks) # [10, 25, 30]
marks[0:2] = [5, 6]
print(marks) # [5, 6, 30]
marks = [10, 20, 30]
for m in marks:
print(m)
marks = [10, 20, 30]
for i in range(len(marks)):
print(i, marks[i])
लिस्ट कम्प्रिहेंशन नई लिस्ट बनाने का संक्षिप्त तरीका है।
squares = [x ** 2 for x in range(1, 6)]
print(squares) # [1, 4, 9, 16, 25]
even = [x for x in range(1, 11) if x % 2 == 0]
print(even) # [2, 4, 6, 8, 10]
marks = [45, 67, 89, 34, 78]
avg = sum(marks) / len(marks)
print("औसत:", avg)
nums = [12, 45, 8, 90, 23]
maximum = nums[0]
for n in nums:
if n > maximum:
maximum = n
print("अधिकतम:", maximum)
names = []
n = int(input("कितने नाम दर्ज करने हैं? "))
for i in range(n):
name = input("नाम: ")
names.append(name)
print("सूची:", names)
लिस्ट के अंदर दूसरी लिस्ट हो सकती है, जिसे नेस्टेड लिस्ट कहते हैं। नेस्टेड लिस्ट का उपयोग मैट्रिक्स जैसी सारणीबद्ध डेटा संरचनाओं को प्रदर्शित करने के लिए होता है। उदाहरण के लिए, दो कक्षाओं के विद्यार्थियों के अंकों को नेस्टेड लिस्ट में रखा जा सकता है।
marks = [
[45, 67, 89],
[78, 56, 90]
]
print(marks[0]) # पहली पंक्ति: [45, 67, 89]
print(marks[1][2]) # दूसरी पंक्ति का तीसरा मान: 90
for row in marks:
for m in row:
print(m, end=" ")
print()
rows = 3
cols = 3
matrix = []
for i in range(rows):
row = []
for j in range(cols):
row.append(i * 3 + j + 1)
matrix.append(row)
print(matrix)
नेस्टेड लिस्ट के साथ इंडेक्सिंग में पहला इंडेक्स बाहरी लिस्ट की स्थिति और दूसरा इंडेक्स आंतरिक लिस्ट की स्थिति निर्धारित करता है। इस प्रकार की संरचना टेबल, स्प्रेडशीट और ग्रिड आधारित समस्याओं (जैसे टिक-टैक-टो खेल) को हल करने में अत्यंत उपयोगी है।
किसी लिस्ट में तत्वों को क्रमबद्ध करने के लिए sort() मेथड और खोजने के लिए index() या in ऑपरेटर का उपयोग होता है। अधिकतम या न्यूनतम तत्व ज्ञात करने के लिए max() और min() फ़ंक्शन सुविधाजनक हैं।
data = [56, 23, 78, 12, 90, 34]
data.sort()
print("आरोही क्रम:", data)
data.sort(reverse=True)
print("अवरोही क्रम:", data)
print("अधिकतम:", max(data), "न्यूनतम:", min(data), "योग:", sum(data))
print("78 सूची में है:", 78 in data)
इन सभी अवधारणाओं के अभ्यास से विद्यार्थी लिस्ट पर आधारित वास्तविक समस्याओं (जैसे विद्यार्थियों के अंकों की गणना, नामों की सूची प्रबंधन और सारणीबद्ध डेटा संग्रहण) को आसानी से हल कर सकता है।
लिस्ट के साथ कार्य करते समय कुछ महत्वपूर्ण बातों का ध्यान रखना चाहिए। सबसे पहले, किसी लिस्ट को दूसरे चर में इस प्रकार निर्दिष्ट करना कि वे दोनों एक ही मेमोरी स्थान की ओर संकेत करें, अक्सर अप्रत्याशित परिणाम देता है। उदाहरण के लिए, यदि हम list2 = list1 लिखते हैं, तो list1 में किया गया परिवर्तन list2 में भी दिखाई देगा, क्योंकि दोनों एक ही वस्तु को संदर्भित करते हैं। स्वतंत्र प्रतिलिपि के लिए copy() या स्लाइसिंग (list1[:]) का उपयोग करना चाहिए।
list1 = [1, 2, 3]
list2 = list1
list2.append(4)
print(list1) # [1, 2, 3, 4] - अप्रत्याशित परिवर्तन
list3 = [1, 2, 3]
list4 = list3.copy()
list4.append(9)
print(list3) # [1, 2, 3] - मूल लिस्ट सुरक्षित
इसके अतिरिक्त, remove() में वह मान जो लिस्ट में मौजूद नहीं है, देने पर ValueError उत्पन्न होती है; index() में भी ऐसा ही होता है। इसलिए हटाने या खोजने से पहले मेंबरशिप ऑपरेटर (in) से जाँच करना बेहतर अभ्यास है। लिस्ट में कई प्रकार के तत्वों को मिलाकर रखा जा सकता है, परंतु तुलना और क्रमबद्ध करते समय समान प्रकार के तत्व ही रखने चाहिए, अन्यथा प्रकार संबंधी त्रुटियाँ आ सकती हैं। इन सावधानियों का पालन करके विद्यार्थी लिस्ट आधारित प्रोग्रामों में गंभीर त्रुटियों से बच सकता है।
| मेथड | कार्य | उदाहरण |
|---|---|---|
| append(x) | अंत में जोड़ना | a.append(5) |
| extend(L) | कई तत्व जोड़ना | a.extend([5,6]) |
| insert(i, x) | स्थान पर जोड़ना | a.insert(1, 5) |
| remove(x) | पहला x हटाना | a.remove(5) |
| pop(i) | इंडेक्स i हटाना | a.pop(2) |
| del a[i] | इंडेक्स i हटाना | del a[0] |
| clear() | सारे तत्व हटाना | a.clear() |
| विशेषता | लिस्ट | स्ट्रिंग |
|---|---|---|
| कोष्ठक | [ ] | ' ' या " " |
| परिवर्तनीयता | Mutable | Immutable |
| तत्व | कोई भी प्रकार | केवल वर्ण |
| तत्व बदलना | संभव | असंभव |
| मेथड | कार्य |
|---|---|
| sort() | आरोही क्रम |
| reverse() | उल्टा क्रम |
| index(x) | तत्व की स्थिति |
| count(x) | तत्व की गिनती |
| copy() | लिस्ट की प्रतिलिपि |
graph TD
A["लिस्ट्स"] --> B["निर्माण"]
A --> C["इंडेक्सिंग/स्लाइसिंग"]
A --> D["संचालन"]
A --> E["मेथड"]
A --> F["कम्प्रिहेंशन"]
B --> G["[ ] में कॉमा से अलग"]
C --> H["0 से धनात्मक, -1 से ऋणात्मक"]
D --> I["+ संयोजन, * पुनरावृत्ति"]
E --> J["append, extend, insert"]
E --> K["remove, pop, del, sort"]
F --> L["[expr for x in seq if cond]"]
b = a लिखना; यह नई लिस्ट नहीं बल्कि संदर्भ बनाता है, इसके लिए copy() या a[:] उपयोग करें।लिस्ट पाइथन का सबसे अधिक प्रयुक्त कम्पोज़िट डेटा प्रकार है। इसकी परिवर्तनीयता (Mutable) इसे डेटा को गतिशील रूप से प्रबंधित करने में सक्षम बनाती है। append, insert, remove, pop, sort जैसे मेथड लिस्ट को प्रबंधित करना सरल बनाते हैं। लिस्ट कम्प्रिहेंशन संक्षिप्त और प्रभावी कोड लिखने में सहायक है। स्लाइसिंग और इंडेक्सिंग की समझ से लिस्ट के तत्वों तक सटीक पहुँच संभव होती है। यह अध्याय अगले अध्याय (टपल्स और डिक्शनरी) के लिए आधार है, जहाँ हम अपरिवर्तनीय अनुक्रम और कुंजी-मान संरचनाओं का अध्ययन करेंगे।