लिस्ट बनाना और इंडेक्सिंग
L = [4, 7, 2, 5], E = [], M = [1, 'two', 3.0, [4, 5]], list('abc') → ['a', 'b', 'c']।
इंडेक्सिंग: L[0] = 4, L[-1] = 5। लिस्ट म्यूटेबल है: L[1] = 9 → [4, 9, 2, 5]। बाहर का इंडेक्स IndexError देता है।
लिस्ट संक्रियाएँ
- जोड़ना: [1, 2] + [3] → [1, 2, 3]
- दोहराना: [0] * 4 → [0, 0, 0, 0]
- सदस्यता: 7 in L → True
- स्लाइसिंग: L[1:3] → [7, 2]; L[::-1] → उल्टी कॉपी
- तुलना: [1, 2] == [1, 2] → True
लिस्ट का ट्रैवर्सल
for x in L:
print(x)
for i in range(len(L)):
L[i] = L[i] * 2 # इंडेक्स से बदलना
i = 0
while i < len(L):
print(L[i]); i += 1
लिस्ट फ़ंक्शन और मेथड
| मेथड | काम (L = [4, 7, 2]) |
|---|---|
| len(L) | 3 |
| L.append(6) | अंत में एक आइटम → [4, 7, 2, 6] |
| L.extend([8, 9]) | दूसरी लिस्ट का हर आइटम जोड़ता है |
| L.insert(1, 5) | इंडेक्स 1 पर 5 |
| L.count(7) | 7 कितनी बार |
| L.index(7) | 7 का पहला इंडेक्स (न मिले तो ValueError) |
| L.remove(7) | पहला 7 हटाता है |
| L.pop(i) / L.pop() | i वाला / आख़िरी आइटम हटाकर लौटाता है |
| L.reverse() | उसी जगह उलटता है |
| L.sort(), L.sort(reverse=True) | उसी जगह क्रम में |
| sorted(L) | नई क्रमबद्ध लिस्ट |
| min(L), max(L), sum(L) | 2, 7, 13 |
del L[0] इंडेक्स से हटाता है; L.clear() लिस्ट खाली करता है।
नेस्टेड लिस्ट
लिस्ट में दूसरी लिस्ट हो सकती है: M = [[1, 2, 3], [4, 5, 6]]। M[1] = [4, 5, 6]; M[1][2] = 6। नेस्टेड लूप से ट्रैवर्सल:
for row in M:
for x in row:
print(x, end=' ')
print()
प्रोग्राम: max, min, mean, रैखिक खोज, बारंबारता
L = [4, 7, 2, 9, 5]
big = L[0]; small = L[0]
for x in L:
if x > big: big = x
if x < small: small = x
mean = sum(L) / len(L) # 5.4
# रैखिक खोज
key = 9; pos = -1
for i in range(len(L)):
if L[i] == key:
pos = i; break
print(pos) # 3
# हर तत्व की बारंबारता
for x in set(L):
print(x, L.count(x))रैखिक खोज एक-एक आइटम जाँचती है; सबसे बुरी स्थिति में हर आइटम देखती है।
मुख्य सूत्र और परिभाषाएँ
- L[i] (0 से), L[-1] आख़िरी; लिस्ट म्यूटेबल
- append(x) एक · extend(list) कई · insert(i, x)
- remove(मान) · pop(इंडेक्स) आइटम लौटाता है
- sort() उसी जगह · sorted() नई लिस्ट
- mean = sum(L) / len(L)
हल किए गए उदाहरण
1. L = [10, 20, 30, 40]। L[1:3], L[-1], L * 2, 25 in L निकालें।
[20, 30]; 40; [10, 20, 30, 40, 10, 20, 30, 40]; False।
2. आउटपुट? L = [3, 1, 2]; L.append([4, 5]); print(len(L))
4, क्योंकि append पूरी लिस्ट को एक आइटम जोड़ता है: [3, 1, 2, [4, 5]]।
3. आउटपुट? L = [3, 1, 2]; L.extend([4, 5]); L.insert(0, 9); L.remove(1); print(L)
[9, 3, 2, 4, 5]
4. max/min के बिना [12, 5, 8, 20, 15] का max, min, mean।
big = small = 12; सब जाँचने पर big = 20, small = 5; mean = 60 / 5 = 12.0।
5. [12, 5, 8, 20, 15] में 15 की रैखिक खोज। कितनी तुलनाएँ?
12, 5, 8, 20, 15 → इंडेक्स 4 पर 5 तुलनाओं के बाद मिला।
6. [1, 2, 3, 4, 5, 6] में सम स्थान के तत्व को अगले से बदलें।
for i in range(0, len(L) - 1, 2): L[i], L[i+1] = L[i+1], L[i] # [2, 1, 4, 3, 6, 5]
7. [2, 3, 2, 5, 3, 2] में हर तत्व की बारंबारता।
लूप और count() से: 2 → 3, 3 → 2, 5 → 1।
आम गलतियाँ
- append और extend में उलझना: append([4, 5]) एक नेस्टेड लिस्ट जोड़ता है; extend 4 और 5 अलग जोड़ता है।
- L = L.sort() लिखना। sort() None लौटाता है; बस L.sort() लिखें।
- remove में इंडेक्स देना। remove मान लेता है; pop इंडेक्स।
- for x in L में घूमते समय लिस्ट बदलना, जिससे आइटम छूट जाते हैं।