लिस्ट्स
एक वेरिएबल एक चीज़ रखता है। एक लिस्ट बहुत सारी चीज़ों को एक क्रम में रखता है, सब एक नाम के अंतर्गत। एक लीडरबोर्ड स्कोर का एक रैंक किया हुआ क्रम है। एक क्विज़ प्रश्नों का एक संग्रह है। जब आपको संबंधित मानों के एक समूह को प्रबंधित करने की आवश्यकता होती है, तो आपको एक लिस्ट की आवश्यकता होती है।
एक लिस्ट बनाना
स्क्वायर ब्रैकेट, अल्पविरामों से अलग किए गए मान। लिस्ट्स किसी भी मिश्रण प्रकार को रख सकते हैं, और एक खाली लिस्ट वैध है और एक शुरुआती बिंदु के रूप में सामान्य है जिसे आप समय के साथ बनाते हैं।
scores = [87, 92, 74, 65, 91]
players = ["राज", "प्रिया", "अमित"]
mixed = ["राज", 87, True, 3.14] # कोई भी प्रकार, हालांकि असामान्य
empty = []
[] एक सही शुरुआती बिंदु है जब आप इसे भरने की योजना बनाते हैं जैसे-जैसे आप जाते हैं। मेरी अधिकांश लिस्ट्स इसी तरह शुरू होती हैं, खाली और प्रतीक्षा में। इंडेक्सिंग और स्लाइसिंग
लिस्ट्स स्ट्रिंग्स के समान नंबरिंग का उपयोग करते हैं: पॉजीशन 0 से शुरू होते हैं, नकारात्मक संख्याएं अंत से गिनती करते हैं। आप किसी भी आइटम को इसकी पॉजीशन से पढ़ते हैं। क्योंकि लिस्ट्स म्यूटेबल हैं, आप किसी विशिष्ट पॉजीशन में लिख भी सकते हैं।
scores = [87, 92, 74, 65, 91]
scores[0] # 87 (पहला)
scores[-1] # 91 (अंतिम)
scores[1:3] # [92, 74]
scores[:2] # [87, 92]
scores[::-1] # [91, 65, 74, 92, 87] (उलट)
scores[0] = 90 # म्यूटेबल: काम करता है (स्ट्रिंग्स TypeError उठाती हैं)0 से शुरू होते हैं, और नकारात्मक संख्याएं अंत से पीछे की ओर गिनती करते हैं, इसलिए scores[-1] अंतिम एक है। एक स्लाइस जैसे scores[1:3] आपको पॉजीशन 1 और 2 के साथ एक ताज़ी लिस्ट देता है। जो भाग मेरे लिए एक पल का था: एक लिस्ट के साथ आप एक पॉजीशन में भी लिख सकते हैं, scores[0] = 90, जहां एक स्ट्रिंग इंकार करती। आइटम्स जोड़ना
आइटम्स जोड़ने के लिए तीन तरीके। append() अंत में एक आइटम जोड़ता है और वह है जो आप लगभग हर समय उपयोग करेंगे। insert() एक विशिष्ट पॉजीशन पर जोड़ता है। extend() एक और लिस्ट को विलय करता है।
scores = [87, 92, 74]
scores.append(65) # [87, 92, 74, 65]
scores.insert(1, 100) # [87, 100, 92, 74, 65]
scores.extend([55, 71]) # [87, 100, 92, 74, 65, 55, 71]एक सामान्य गलती: append() के साथ एक लिस्ट पूरी लिस्ट को एक आइटम के रूप में जोड़ता है, जो आपको एक लिस्ट के अंदर एक लिस्ट देता है। इसके बजाय extend() का उपयोग करें:
scores.append([55, 71]) # [..., [55, 71]] नेस्टेड लिस्ट, संभवतः गलत
scores.extend([55, 71]) # [..., 55, 71] विलय, सहीappend() अंत में एक आइटम को टैक करता है और वह है जो आप लगभग हर समय पहुंचेंगे। insert() एक पॉजीशन पर एक आइटम डालता है, extend() एक और लिस्ट को विलय करता है। क्लासिक स्लिप: append() एक लिस्ट और आप अपनी लिस्ट के अंदर एक लिस्ट पाते हैं, तो विलय करने का मतलब extend() का उपयोग करें। आइटम्स हटाना
आइटम्स हटाने के लिए चार उपकरण। remove() मान से खोज करता है। pop() पॉजीशन से हटाता है और आपको आइटम वापस देता है। del पॉजीशन से हटाता है कोई रिटर्न वैल्यू के बिना। clear() पूरी लिस्ट को खाली कर देता है।
scores = [87, 92, 74, 65, 91]
scores.remove(74) # 74 की पहली घटना को हटाता है
scores.pop() # अंतिम आइटम को हटाता है और रिटर्न करता है (91)
scores.pop(0) # पॉजीशन 0 पर आइटम को हटाता है और रिटर्न करता है (87)
del scores[1] # पॉजीशन 1 को हटाता है, कोई रिटर्न वैल्यू नहीं
scores.clear() # सब कुछ हटाता हैremove() एक ValueError उठाता है यदि मान लिस्ट में नहीं है। पहले in के साथ जांचें यदि आप निश्चित नहीं हैं:
if 74 in scores:
scores.remove(74)remove() मान से हटाता है और केवल पहली मेल, और यह `ValueError` उठाता है यदि मान वहां नहीं है, तो पहले `in` के साथ जांचें जब आप निश्चित नहीं हैं। pop() पॉजीशन से हटाता है और आइटम वापस देता है, del पॉजीशन से हटाता है और आपको कुछ नहीं देता। सॉर्ट करना
sorted() एक ब्रांड नई सॉर्ट की गई लिस्ट रिटर्न करता है और आपकी मूल को अकेला छोड़ देता है। .sort() लिस्ट को जगह पर सॉर्ट करता है और None रिटर्न करता है। वह अंतर सुनाई देने से अधिक मायने रखता है।
scores = [87, 42, 96, 55, 71]
ranked = sorted(scores) # [42, 55, 71, 87, 96] (नई लिस्ट)
scores.sort() # जगह पर सॉर्ट करता है, None रिटर्न करता है
scores.sort(reverse=True) # [96, 87, 71, 55, 42]
result = scores.sort() # result None है, सॉर्ट की गई लिस्ट नहींsorted() आपको एक नई सॉर्ट की गई लिस्ट देता है और मूल को अकेला छोड़ता है। .sort() लिस्ट को पुनर्व्यवस्थित करता है और `None` रिटर्न करता है, तो `x = scores.sort()` आपको `None` के साथ देता है, लिस्ट नहीं। मैंने वह सटीक गलती एक से अधिक बार की थी इससे पहले कि यह अटका। उपयोगी संचालन
Python में अंतर्निहित उपकरणों का एक सेट है जो सीधे लिस्ट्स पर काम करता है। len(), sum(), min(), और max() चार हैं जो आप लगातार पहुंचेंगे।
scores = [87, 92, 74, 65, 91]
len(scores) # 5
sum(scores) # 409
min(scores) # 65
max(scores) # 92
scores.count(87) # 1
scores.index(74) # 2
74 in scores # True
74 not in scores # False
scores.copy() # उथली प्रति
scores.reverse() # जगह पर उलटता हैlen(), sum(), min(), और max() सब सीधे एक लिस्ट पर काम करते हैं, कोई सेटअप नहीं। in पूछता है कि कुछ मौजूद है, .count() कितनी बार तालिका करता है, और .index() पहली मेल की पॉजीशन पाता है। पुनरावृत्ति
एक for लूप एक लिस्ट से होकर एक बार में एक आइटम जाता है। for के बाद वेरिएबल हर बार में वह आइटम प्राप्त करता है। जब आपको पॉजीशन भी चाहिए, enumerate() आपको बिना मैनुअल काउंटर के दोनों देता है।
players = ["राज", "प्रिया", "अमित"]
for player in players:
print(player)
for i, player in enumerate(players, start=1):
print(f"{i}. {player}")
# 1. राज
# 2. प्रिया
# 3. अमितfor और enumerate() को पूरा उपचार नियंत्रण प्रवाह अध्याय में मिलता है। संक्षिप्त संस्करण: for player in players हर आइटम के लिए एक बार चलाता है, और enumerate() हर पुनरावृत्ति पर आपको पॉजीशन और मान दोनों देता है।
for लूप लिस्ट को एक बार में एक आइटम चलता है, और for के बाद नाम हर बार वह आइटम बन जाता है। जब आप पॉजीशन भी चाहते हैं, `enumerate()` आपको दोनों देता है, तो आपको कभी अपने आप काउंटर नहीं रखना है। मुझे इसके लिए गिनती करने देने से ऑफ-बाय-वन स्लिप्स का एक ढेर बचा। नेस्टेड लिस्ट्स
एक लिस्ट अन्य लिस्ट्स को रख सकती है। यह है कि आप एक ग्रिड या तालिका का प्रतिनिधित्व कैसे करते हैं: पंक्तियों की एक लिस्ट, हर पंक्ति मानों की एक लिस्ट। दो सेट स्क्वायर ब्रैकेट अंदर एक आइटम पहुंचता है: पहला पंक्ति चुनता है, दूसरा कॉलम चुनता है।
grid = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
]
grid[0] # [1, 2, 3]
grid[1][2] # 6 (पंक्ति 1, कॉलम 2)म्यूटेबिलिटी: जाल
यह लगभग सभी को आश्चर्यचकित करता है। एक लिस्ट को एक नए वेरिएबल में असाइन करना एक प्रति नहीं बनाता है। दोनों नाम समान लिस्ट की ओर इशारा करते हैं। एक को बदलें और आप दूसरे को बदलते हैं। एक स्वतंत्र प्रति के लिए, आपको स्पष्ट रूप से एक के लिए पूछना है।
a = [1, 2, 3]
b = a # b एक प्रति नहीं है; यह समान लिस्ट की ओर इशारा करता है
b.append(4)
print(a) # [1, 2, 3, 4] (परिवर्तित: a और b समान लिस्ट हैं)b = a.copy() # स्वतंत्र प्रति
b = list(a) # समान परिणाम
b = a[:] # भी समान
# नेस्टेड लिस्ट्स अभी भी अपनी आंतरिक वस्तुओं को साझा करते हैं:
matrix = [[1, 2], [3, 4]]
copy = matrix.copy()
copy[0].append(99)
print(matrix) # [[1, 2, 99], [3, 4]] (आंतरिक लिस्ट साझा थी)b = a एक प्रति नहीं बनाता है, दोनों नाम समान लिस्ट की ओर इशारा करते हैं, तो एक के माध्यम से परिवर्तन दूसरे से दिखता है। एक स्वतंत्र लिस्ट के लिए आपको पूछना है: .copy(), list(a), या a[:]। यह एक लगभग सभी को पहली बार आश्चर्यचकित करता है, मुझे सहित। अधिक तरीके
| विधि | यह क्या करता है |
|---|---|
.append(item) | अंत में जोड़ें |
.insert(i, item) | पॉजीशन i पर सम्मिलित करें |
.extend(iterable) | पुनरावृत्तीय से सभी आइटम्स जोड़ें |
.remove(value) | मान की पहली घटना हटाएं |
.pop(i) | पॉजीशन i पर आइटम हटाएं और रिटर्न करें (डिफ़ॉल्ट: अंतिम) |
.clear() | सभी आइटम्स हटाएं |
.index(value) | पहली घटना की पॉजीशन |
.count(value) | घटनाओं की संख्या |
.sort() | जगह पर सॉर्ट करें |
.reverse() | जगह पर उलटें |
.copy() | एक उथली प्रति रिटर्न करें |
व्यवहार में
एक स्कोर ट्रैकर बनाना: परिणाम जोड़ें, उन्हें सॉर्ट करें, और एक सारांश प्रिंट करें।
scores = []
scores.append(87)
scores.append(54)
scores.append(92)
scores.append(67)
scores.append(45)
scores.sort(reverse=True)
print(f"रैंक किए गए स्कोर: {scores}")
print(f"उच्चतम: {scores[0]}")
print(f"सबसे कम: {scores[-1]}")
print(f"औसत: {sum(scores) / len(scores):.1f}")
print(f"शीर्ष 3: {scores[:3]}")