पाइथन लिस्ट नोट्स | Class 11 Informatic Practices Hindi (Hindi Medium)

1. परिचय

लिस्ट (List) पाइथन का एक म्यूटेबल (परिवर्तनीय), क्रमबद्ध (Ordered) डेटा प्रकार है जिसमें विभिन्न प्रकार के तत्व (int, float, str, और यहाँ तक कि अन्य लिस्ट) संग्रहीत किए जा सकते हैं। लिस्ट को वर्गाकार कोष्ठक [] में लिखा जाता है और तत्वों को अल्पविराम (,) से अलग किया जाता है। लिस्ट पाइथन का सबसे लचीला डेटा प्रकार है क्योंकि इसमें तत्व जोड़े, हटाए, बदले और क्रमबद्ध किए जा सकते हैं। लिस्ट का इंडेक्सिंग 0 से प्रारंभ होता है और ऋणात्मक इंडेक्स अंत से गिनती करते हैं। इस अध्याय में हम लिस्ट के निर्माण, एक्सेस, स्लाइसिंग, विभिन्न मेथड और ट्रैवर्सल का विस्तृत अध्ययन करेंगे।

2. लिस्ट का निर्माण

लिस्ट को अनेक विधियों से बनाया जा सकता है:

L1 = [10, 20, 30, 40]
L2 = ["सेब", "आम", "केला"]
L3 = [1, "hello", 3.5, True]
L4 = []           # खाली लिस्ट
L5 = list("abc")  # list() फ़ंक्शन से
L6 = [1, 2, [3, 4]]  # नेस्टेड लिस्ट

वर्गाकार कोष्ठक [] से खाली लिस्ट बनती है।
list() फ़ंक्शन किसी भी अनुक्रम (स्ट्रिंग, tuple) को लिस्ट में बदलता है।

L = list("ABC")
print(L)

आउटपुट: ['A', 'B', 'C']

range() से लिस्ट

L = list(range(1, 6))
print(L)

आउटपुट: [1, 2, 3, 4, 5]

3. लिस्ट एक्सेस (इंडेक्सिंग और स्लाइसिंग)

लिस्ट का प्रत्येक तत्व इंडेक्स द्वारा एक्सेस किया जाता है। इंडेक्स 0 से शुरू होता है।

L = [10, 20, 30, 40, 50]
print(L[0])
print(L[3])
print(L[-1])
print(L[-2])

L[0] = 10
L[3] = 40
L[-1] = 50 (अंतिम)
L[-2] = 40

स्लाइसिंग (Slicing)

L[start:end:step] से लिस्ट का भाग प्राप्त होता है। अंतिम इंडेक्स शामिल नहीं होता।

L = [10, 20, 30, 40, 50]
print(L[1:4])
print(L[:3])
print(L[2:])
print(L[::2])
print(L[::-1])

L[1:4] = [20, 30, 40]
L[:3] = [10, 20, 30]
L[2:] = [30, 40, 50]
L[::2] = [10, 30, 50]
L[::-1] = [50, 40, 30, 20, 10] (उल्टी)

4. लिस्ट संचालन (Operations)

संयोजन और दोहराव

a = [1, 2, 3]
b = [4, 5]
print(a + b)
print(a * 2)

a + b = [1, 2, 3, 4, 5] (संयोजन)
a * 2 = [1, 2, 3, 1, 2, 3] (दोहराव)

सदस्यता जाँच

in और not in ऑपरेटर से जाँच होती है।

L = [1, 2, 3]
print(2 in L)
print(5 not in L)

len() और अन्य बिल्ट-इन फ़ंक्शन

L = [5, 2, 8, 1]
print(len(L))
print(max(L))
print(min(L))
print(sum(L))
print(sorted(L))

len() = लंबाई (4)
max() = 8, min() = 1, sum() = 16
sorted() = क्रमबद्ध नई लिस्ट [1, 2, 5, 8] (मूल लिस्ट नहीं बदलती)

5. लिस्ट मेथड (List Methods)

तत्व जोड़ना

append(element) - अंत में एक तत्व जोड़ता है।
extend(list) - अंत में अनेक तत्व जोड़ता है।
insert(index, element) - निर्दिष्ट स्थान पर तत्व जोड़ता है।

L = [1, 2, 3]
L.append(4)
print(L)
L.extend([5, 6])
print(L)
L.insert(0, 0)
print(L)

append के बाद: [1, 2, 3, 4]
extend के बाद: [1, 2, 3, 4, 5, 6]
insert के बाद: [0, 1, 2, 3, 4, 5, 6]

तत्व हटाना

remove(element) - दिए गए मान का पहला उदाहरण हटाता है।
pop(index) - निर्दिष्ट इंडेक्स का तत्व हटाकर लौटाता है (डिफ़ॉल्ट अंतिम)।
clear() - सभी तत्व हटा देता है।

L = [10, 20, 30, 20, 40]
L.remove(20)
print(L)
x = L.pop()
print(x, L)

remove(20) के बाद: [10, 30, 20, 40]
pop() = 40, लिस्ट: [10, 30, 20]

क्रमबद्ध और उल्टा

sort() - लिस्ट को क्रमबद्ध करता है (मूल लिस्ट बदलती है)।
reverse() - तत्वों का क्रम उल्टा करता है।

L = [3, 1, 2]
L.sort()
print(L)
L.reverse()
print(L)

sort() के बाद: [1, 2, 3]
reverse() के बाद: [3, 2, 1]

खोज और गिनती

index(element) - तत्व का पहला इंडेक्स देता है।
count(element) - तत्व की संख्या देता है।

L = [1, 2, 3, 2, 2]
print(L.index(2))
print(L.count(2))

index(2) = 1, count(2) = 3

copy() मेथड

copy() लिस्ट की प्रतिलिपि बनाता है। सावधान रहें कि = से दो वेरिएबल एक ही लिस्ट को संदर्भित करते हैं।

a = [1, 2, 3]
b = a
c = a.copy()
b.append(4)
print(a)
print(c)

a = [1, 2, 3, 4] (b ने भी a को बदला)
c = [1, 2, 3] (स्वतंत्र प्रतिलिपि)

6. लिस्ट ट्रैवर्सल (Traversal)

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

L = [10, 20, 30]
for x in L:
    print(x)

for i in range(len(L)):
    print(i, L[i])

पहला लूप तत्वों को और दूसरा इंडेक्स के साथ तत्वों को प्रिंट करता है। जब हमें तत्व के साथ-साथ उसकी स्थिति (इंडेक्स) भी चाहिए, तो दूसरे रूप का उपयोग किया जाता है। जब केवल मान की आवश्यकता होती है, तो पहला रूप अधिक सरल होता है।

योग और औसत

marks = [80, 90, 75, 60]
total = 0
for m in marks:
    total = total + m
avg = total / len(marks)
print("योग:", total, "औसत:", avg)

यहाँ total को संचायक (Accumulator) कहा जाता है, क्योंकि लूप के प्रत्येक चक्र में उसमें नया मान जोड़ा जाता है। इसी प्रकार हम किसी शर्त के अनुसार गिनती भी कर सकते हैं, जैसे लिस्ट में कितनी सम संख्याएँ हैं। लिस्ट पर आधारित प्रोग्राम वास्तविक जीवन में अनेक रूपों में उपयोग होते हैं, जैसे विद्यार्थियों के अंकों की गणना, किसी दुकान की वस्तुओं की सूची, खेल में अर्जित अंकों का संग्रह और मौसम का दैनिक तापमान रिकॉर्ड। इन सभी स्थितियों में हमें डेटा को एक ही स्थान पर क्रमबद्ध रूप से संग्रहीत करना और उस पर बार-बार प्रक्रिया करनी होती है। लिस्ट का म्यूटेबल होना इस कार्य को और सरल बनाता है, क्योंकि हम चाहें तो बीच में ही तत्व बदल सकते हैं। उदाहरण के लिए, यदि किसी विद्यार्थी के अंक गलत दर्ज हो गए हैं, तो उसे सीधे इंडेक्स के माध्यम से सुधारा जा सकता है। इसके अतिरिक्त, लिस्ट में खोज के लिए in ऑपरेटर या index() मेथड का उपयोग होता है, और क्रमबद्धता के लिए sort() या sorted()। इन सभी तकनीकों के संयोजन से हम किसी भी डेटा संग्रह का पूर्ण प्रबंधन कर सकते हैं। परीक्षा में लिस्ट ट्रैवर्सल, योग-औसत, अधिकतम-न्यूनतम और खोज के प्रोग्राम बहुत सामान्य हैं, इसलिए इनका स्वयं लिखकर अभ्यास करना आवश्यक है। साथ ही, यह भी ध्यान रखना चाहिए कि ट्रैवर्सल के दौरान लिस्ट में बदलाव करने से (जैसे तत्व हटाने पर) इंडेक्स की स्थिति बदल जाती है, जिससे कुछ तत्व छूट सकते हैं। ऐसी स्थितियों से बचने के लिए या तो प्रतिलिपि पर लूप चलाना चाहिए या बदलाव के क्रम को सोच-समझकर निर्धारित करना चाहिए।

सबसे बड़ा तत्व (बिना max())

L = [10, 45, 3, 22, 67]
largest = L[0]
for x in L:
    if x > largest:
        largest = x
print("सबसे बड़ा:", largest)

7. नेस्टेड लिस्ट

लिस्ट के अंदर लिस्ट को नेस्टेड लिस्ट कहते हैं।

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[0])
print(matrix[1][2])

matrix[0] = [1, 2, 3]
matrix[1][2] = 6

8. लिस्ट कॉम्प्रिहेंशन (List Comprehension)

लिस्ट कॉम्प्रिहेंशन एक संक्षिप्त विधि है जिससे लूप और शर्त के आधार पर नई लिस्ट बनाई जाती है। इसका सामान्य रूप: [expression for item in list if condition]।

squares = [x * x for x in range(1, 6)]
print(squares)

evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)

squares = [1, 4, 9, 16, 25]
evens = [2, 4, 6, 8, 10]

9. लिस्ट के साथ सामान्य त्रुटियाँ

IndexError: अस्तित्वहीन इंडेक्स तक पहुँचने पर, जैसे L[10] छोटी लिस्ट पर।
ValueError: remove() में ऐसा तत्व जो लिस्ट में नहीं है।
TypeError: append() में अनेक तत्व देने पर - append एक ही तत्व लेता है, अनेक के लिए extend()।
= द्वारा संदर्भ: b = a दोनों एक ही लिस्ट को इंगित करते हैं; अलग प्रतिलिपि के लिए copy()।

graph TD A["लिस्ट"] --> B["निर्माण: [], list(), range()"] A --> C["एक्सेस: इंडेक्स, स्लाइसिंग"] A --> D["मेथड"] D --> E["जोड़ना: append, extend, insert"] D --> F["हटाना: remove, pop, clear"] D --> G["क्रमबद्ध: sort, reverse"] D --> H["खोज: index, count"] A --> I["ट्रैवर्सल: for लूप"] A --> J["लिस्ट कॉम्प्रिहेंशन"]

त्वरित पुनरावृत्ति तालिकाएँ

मेथड	कार्य	उदाहरण
append(x)	अंत में एक तत्व जोड़ना	L.append(4)
extend(L2)	अंत में अनेक तत्व जोड़ना	L.extend([4,5])
insert(i, x)	i स्थान पर तत्व	L.insert(0, 9)
remove(x)	पहला x हटाना	L.remove(20)
pop(i)	i सूचकांक हटाना	L.pop()
index(x)	x का इंडेक्स	L.index(30)
count(x)	x की गिनती	L.count(2)
sort()	क्रमबद्ध करना	L.sort()
reverse()	उल्टा करना	L.reverse()
clear()	सभी हटाना	L.clear()
copy()	प्रतिलिपि	L2 = L.copy()

ऑपरेशन	परिणाम
[1,2] + [3]	[1, 2, 3]
[1,2] * 2	[1, 2, 1, 2]
len([1,2,3])	3
max([1,5,3])	5
min([1,5,3])	1
sum([1,2,3])	6
sorted([3,1,2])	[1, 2, 3]

माइंड मैप

flowchart TD A["पाइथन लिस्ट"] --> B["म्यूटेबल और क्रमबद्ध"] A --> C["निर्माण"] A --> D["इंडेक्सिंग/स्लाइसिंग"] A --> E["मेथड"] A --> F["लूप ट्रैवर्सल"] A --> G["कॉम्प्रिहेंशन"] E --> H["append, extend, insert"] E --> I["remove, pop, clear"] E --> J["sort, reverse"] E --> K["index, count"] F --> L["sum, max, min"] G --> M["[x*x for x in range]"]

महत्वपूर्ण आरेख (SVG)

सामान्य गलतियाँ

append() में अनेक तत्व देना: L.append(4, 5) गलत है; append एक तत्व लेता है, अनेक के लिए extend() उपयोग करें।
b = a से प्रतिलिपि समझना: b = a दोनों एक ही लिस्ट को संदर्भित करते हैं; स्वतंत्र प्रतिलिपि के लिए copy() या a[:]।
स्लाइसिंग में अंतिम इंडेक्स: L[1:4] में इंडेक्स 4 शामिल नहीं होता।
remove() में अनुपस्थित तत्व: लिस्ट में न होने वाला मान remove करने पर ValueError आता है।
sort() और sorted() का भ्रम: sort() मूल लिस्ट बदलता है, sorted() नई लिस्ट देता है।
IndexError की अनदेखी: लिस्ट की सीमा से बाहर इंडेक्स पर IndexError आता है।
list("abc") को [a,b,c] के रूप में न समझना: list("abc") = ['a', 'b', 'c'] प्रत्येक अक्षर अलग तत्व बनता है।

परीक्षा युक्तियाँ

append, extend, insert, remove, pop, sort, reverse, count, index मेथड के सिंटैक्स और प्रभाव अवश्य याद रखें।
स्लाइसिंग L[start:end:step] के मान लिखने का अभ्यास करें; अंतिम इंडेक्स शामिल नहीं है।
L[::-1] लिस्ट उलटने का संक्षिप्त तरीका है - परीक्षा में अक्सर पूछा जाता है।
लिस्ट कॉम्प्रिहेंशन [x*x for x in range(5)] लिखना और समझना सीखें।
sort() (मूल बदलता है) और sorted() (नई देता है) का अंतर स्पष्ट रखें।
नेस्टेड लिस्ट matrix[i][j] के उपयोग के प्रश्न हल करने का अभ्यास करें।
लिस्ट ट्रैवर्सल के दो रूप (for x in L और for i in range(len(L))) दोनों लिखना जानें।

निष्कर्ष

लिस्ट पाइथन का सबसे उपयोगी और लचीला डेटा प्रकार है। इसकी म्यूटेबल प्रकृति के कारण इसमें तत्व जोड़ना, हटाना और बदलना आसान है। इंडेक्सिंग, स्लाइसिंग, मेथड और ट्रैवर्सल की समझ किसी भी प्रोग्राम के लिए आधारभूत है। लिस्ट कॉम्प्रिहेंशन कोड को संक्षिप्त और सुंदर बनाता है। अगले अध्याय में हम डिक्शनरी (शब्दकोश) का अध्ययन करेंगे, जो कुंजी-मान युग्मों पर आधारित है। छात्रों को सलाह है कि वे प्रत्येक मेथड को पाइथन शेल में चलाकर उसके प्रभाव को देखें, क्योंकि लिस्ट संचालन का व्यावहारिक अभ्यास परीक्षा में उच्च अंक दिलाता है।

पाइथन लिस्ट — अध्ययन नोट्स