पायथन में सूची का उपयोग कैसे करें

हम आइटम जोड़ना और संशोधित करना सीखते हैं, सूचियों को एक साथ जोड़ना और कॉपी करना।

सामर्थ्य भाषाओं में, पूर्वनिर्धारित टाइप्स होते हैं: वर्ण, संख्या या क्लासेस। वे संग्रह भी होते हैं — एरे, सूचियाँ और अन्य डेटा संरचनाएँ — जिनमें निर्धारित या गतिशील आयाम के तत्वों की एक समूची होती है।

जब किसी वेरिएबल को ऑब्जेक्ट के रूप में घोषित किया जाता है, तो ऑपरेटिंग सिस्टम द्वारा कुछ स्थान सुरक्षित किया जाता है। उदाहरण के लिए, एक चार वर्ण वाली स्ट्रिंग के लिए आठ बाइट का आकार होता है। प्रत्येक वर्ण ओपरेटिंग सिस्टम की यादि का पता लगाता है, और स्ट्रिंग इन पतों का एक सरणी होती है। सी-स्टाइल भाषाओं में, सरणियों का निर्माण विशिष्ट आकार में, ऑब्जेक्ट के प्रकार के लिए होता है। पायथन में, सूचियों के तत्वों के प्रकार या उनके आयाम के कोई प्रतिबंध नहीं होते हैं। अर्थात पायथन में, सूची एक गतिशील सूचना संग्रह होती है।

कैसे सामान्य समस्याओं का समाधान करें

सूची घोषित करें

Python में सूची बनाने के लिए वाक्यात्मक ढंग:

Mylst — वेरिएबल का नाम। ब्रैकेट्स में तत्वों को निर्दिष्ट किया गया है।

Python में list() की एक प्रमुख शब्द है। यह फ़ंक्शन या तो एक खाली सूची बनाती है, या एक सूची को एकाधिक शुभ्र ऑब्जेक्ट में परिवर्तित करती है। फ़ंक्शन के साथ एक खाली सूची ऑब्जेक्ट बनाने के लिए, निम्नलिखित लिखें:

तत्व को पहुंचें

सूचियाँ — यह तत्वों के समूह हैं। उन्हें पहुंचने के लिए, उनका सूचकांक — क्रमांकीय संख्या दिखाते हैं। उलट, उदाहरण के लिए, एक शब्दकोश के विपरीत, जो की कुंजी के अनुसार मान प्राप्त करने की अनुमति देता है। पहले तत्व का सूचकांक — 0, दूसरे का — 1, तीसरे का — 2 होता है।

इस प्रकार सूची के पांचवें तत्व का उल्लंघन करें:

mylst = [1, 2, 3, 4, 5]
print(mylst[4])  # Will print 5.

तत्व जोड़ें

इसे आप निर्मित ‘फ़ंक्शन’ append() के माध्यम से कर सकते हैं:

mylst = [1, 2, 3, 4, 5]
mylst.append(6)
print(mylst)  # Will print [1, 2, 3, 4, 5, 6].

आप इसे insert() विधि के माध्यम से कर सकते हैं, जो दो प्रकार को स्वीकार करती है — सूचकांक और मान:

mylst = [1, 2, 3, 4, 5]
mylst.insert(1, 25)
print(mylst)  # Will print [1, 25, 2, 3, 4, 5].

❗ यदि इस विधि का उपयोग करके एक तत्व जोड़ा जाता है, तो स्थिति में स्थानांतरण होगा, न कि उसकी पुनः स्थानांतरण।

तत्व परिवर्तित करें

इसके लिए उसके सूचकांक पर एक नए मान सेट करें:

mylst = [1, 2, 3, 4, 5]
mylst[1] = None
print(mylst)  # Will print [1, None, 3, 4, 5].

पायथन में संग्रह के तत्वों को एक ही प्रकार का होना आवश्यक नहीं है।

तत्व हटाने के लिए

इसके लिए आप del() इनबिल्ट फ़ंक्शन का उपयोग कर सकते हैं:

mylst = [1, 2, 3, 4, 5, 4, 3, 2, 1]
del mylst[2]
print(mylst)  # Will print [1, 2, 4, 5, 4, 3, 2, 1].

आप इसे remove() विधि के माध्यम से भी कर सकते हैं:

mylst = [1, 2, 3, 4, 5, 4, 3, 2, 1]
mylst.remove(2)
print(mylst)  # Will print [1, 3, 4, 5, 4, 3, 2, 1].

अनुपस्थिति की जांच करें

यदि आप चाहते हैं कि क्या निर्दिष्ट तत्व सूची में मौजूद है, तो आप in के साथ उपयोग कर सकते हैं:

mylst = [1, 2, 3, 4, 5]
print(None in mylst)  # Will print False.
print(3 in mylst)  # Will print True.

सूचियों को एक साथ मिलाना

आप extend() मेथड को बुलाएं:

mylst = [1, 2]
mylst1 = [3, 4]
mylst2 = [5]
mylst.extend(mylst1)
print(mylst)  # [1, 2, 3, 4]
mylst.extend(mylst2)
print(mylst)  # [1, 2, 3, 4, 5]

या जोड़ने ऑपरेटर के साथ प्रियता:

mylst = [1, 2]
mylst1 = [3, 4]
mylst2 = [5]
mylst += mylst1
print(mylst)  # [1, 2, 3, 4]
mylst += mylst2
print(mylst)  # [1, 2, 3, 4, 5]

सूची की प्रतिलिपि बनाएं

आप copy() सूची का उपयोग करके कर सकते हैं:

mylst = [1, 2, 3, 4, 5]
mylst_copy = mylst.copy()
print(mylst)  # Will print [1, 2, 3, 4, 5].
print(mylst_copy)  # Will print [1, 2, 3, 4, 5].

या पूर्ण स्लाइस बनाएं:

mylst = [1, 2, 3, 4, 5]
mylst_copy = mylst[::]
print(mylst)  # Will print [1, 2, 3, 4, 5].
print(mylst_copy)  # Will print [1, 2, 3, 4, 5].

सूची पर अभ्यास करें

आप for ढांचा का उपयोग कर सकते हैं:

mylst = [1, 2, 3, 4, 5]
for item in mylst:
    print(item)
# 1
# 2
# 3
# 4
# 5

आप while लूप का उपयोग करके भी अभ्यास कर सकते हैं:

mylst = [1, 2, 3, 4, 5]
i = 0
while True:
    try:
        print(mylst[i])
    except IndexError:
        print("Done!")
        break
    i += 1
# 1
# 2
# 3
# 4
# 5
# Done!

सूची के विधियाँ

index

यह तत्व का सूचकांक प्राप्त करने की अनुमति देता है, और पहली मिलान पर इसे लौटाता है:

mylst = [1, 2, 3, 4, 5, 4, 3, 2, 1]
print(mylst.index(3))  # Will print 2.

count

यह सूची के तत्वों की संख्या प्राप्त करने की अनुमति देता है:

mylst = [1, 2, 3, 4, 5, 4, 3, 2, 1]
count_for_one = mylst.count(1)
print(count_for_one)  # Will print 2.
count_for_five = mylst.count(5)
print(count_for_five)  # Will print 1.

clear

यह सूची को पूरी तरह से साफ़ करता है:

mylst = [1, 2, 3, 4, 5]
mylst.clear()
print(mylst)  # Will print [].

sort

यह सूची को निर्दिष्ट कुंजी के आधार पर क्रमबद्ध करता है। यह दो ऐच्छिक तरीके स्वीकार करता है: कुंजी – जिस पर क्रमबद्ध किया जाता है, बूलियन फ्लैग रिवर्स – वस्तुओं को उल्टे क्रम में क्रमबद्ध करता है। डिफ़ॉल्ट रूप से मूल्य परिवर्तन के रूप में उपयोग किया जाता है:

mylst = [1, 3, 2, 4, 5]
mylst.sort()
print(mylst)  # Will print [1, 2, 3, 4, 5].

reverse

यह तत्वों की क्रमवार्ता को उलट देता है:

mylst = [1, 2, 3, 4, 5]
mylst.reverse()
print(mylst)  # Will print [5, 4, 3, 2, 1].

pop

यह सूची से तत्व को प्राप्त करने और उसे हटाने की अनुमति देता है। यह एक वैकल्पिक आर्ग्यूमेंट के रूप में सूचकांक को स्वीकार करता है। डिफ़ॉल्ट रूप से यह आखिरी तत्व होता है।

mylst = [1, 2, 3, 4, 5]
x = mylst.pop()
print(x)  # Will print 5.
print(mylst)  # Will print [1, 2, 3, 4].
y = mylst.pop(2)
print(y)  # Will print 3.
print(mylst)  # Will print [1, 2, 4].

अंतर्निर्मित कार्य

किसी भी संग्रह की लंबाई प्राप्ति

len() फ़ंक्शन का उपयोग करें:

mylst = [1, 2, 3, 4, 5]
list_length = len(mylst)
print(list_length)  # Will print 5.

अधिकतम मान वाले तत्व को लौटाएं

max() फ़ंक्शन का उपयोग करें:

mylst = [1, 2, 3, 4, 5, 4, 3, 2, 1]
max_value = max(mylst)
print(max_value)  # Will print 5.

न्यूनतम मान वाले तत्व को लौटाएं

min() फ़ंक्शन का उपयोग करें:

mylst = [1, 2, 3, 4, 5]
min_value = min(mylst)
print(min_value)  # Will print 1.

टाइप कैस्टिंग

किसी भी इटरेटेबल ऑब्जेक्ट से आप सूची प्राप्त कर सकते हैं। इसके लिए आप इटरेटेबल ऑब्जेक्ट को list() फ़ंक्शन को पास करें। यह ऑब्जेक्ट स्ट्रिंग, सेट, ट्यूपल या जनरेटर हो सकता है:

myset = {1, 2, 3, 4}
mytuple = (5, 6)
mystring = "Test string"
lst1 = list(myset)
lst2 = list(mytuple)
lst3 = list(mystring)
print(lst1)  # Will print [1, 2, 3, 4].
print(lst2)  # Will print [5, 6].
print(lst3)  # Will print ['T', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g'].

स्लाइसिंग काम

स्लाइसिंग का उपयोग मौजूदा सूची पर नई सूचीयों को बनाने के लिए किया जा सकता है। आप पूरी सूची की प्रतिलिपि या कुछ तत्व प्राप्त कर सकते हैं। इसके लिए कदम का उपयोग किया जाता है या प्रारंभिक और अंतिम सूचकांकों को सूचित किया जाता है:

mylst = [1, 2, 3, 4, 5]
mylst_slice_0 = mylst[::]
print(mylst_slice_0)  # Will print [1, 2, 3, 4, 5].
mylst_slice_1 = mylst[0:2]
print(mylst_slice_1)  # Will print [1, 2].
mylst_slice_2 = mylst[::2]
print(mylst_slice_2)  # Will print [1, 3, 5].

सूचियों के जेनरेटर

यह ढांचा सूचियों को आसानी से बनाने की अनुमति देता है:

mylst = [_ for _ in range(6)]
print(mylst)  # Will print [0, 1, 2, 3, 4, 5].

आप मापदंडों को तत्वों की उत्पत्ति के लिए निर्दिष्ट कर सकते हैं।

mylst = [x if x % 2 == 0 else "odd" for x in range(20)]
print(mylst)  # Will print [0, 'odd', 2, 'odd', 4, 'odd', 6, 'odd', 8, 'odd', 10, 'odd', 12, 'odd', 14, 'odd', 16, 'odd', 18, 'odd'].

सूचियों के बारे में मुख्य बातें

• सूचियाँ — तत्वों के लिए निर्देशक संग्रह हैं। पायथन में सूचियों के सभी तत्वों को एक ही प्रकार का होना आवश्यक नहीं है।
• सूची को list() फ़ंक्शन, सूची जेनरेटर या स्लाइसिंग का उपयोग करके बनाया जाता है।
• सूचियों के विधियाँ: insert() — तत्वों को जोड़ें, remove() — हटाएं, extend() — मिलाएं, copy() — प्रतिलिपि बनाएं। और इनके अलावा index(), sort() और अन्य भी हैं।
• पायथन में ऑब्जेक्ट के साथ काम करने के लिए इंटीग्रेटेड फ़ंक्शन होते हैं। उदाहरण के लिए, del(), list(), len(), max(), min()।