पाइथन सूचियां (Python Lists)

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

सूची क्या है? (What is a List?)

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

उदाहरण (Example)

my_list = [1, "Hello", 3.14, [1, 2, 3]]
print(my_list)

आउटपुट:

[1, "Hello", 3.14, [1, 2, 3]]

सूचियों का निर्माण (Creating Lists)

सूचियों का निर्माण विभिन्न तरीकों से किया जा सकता है। आप सूचियों को सीधे वर्ग कोष्ठकों ([]) का उपयोग करके या list() फ़ंक्शन का उपयोग करके बना सकते हैं।

उदाहरण (Examples)

1. सरल सूची (Simple List)

   my_list = [1, 2, 3, 4, 5]
   

    

2. विभिन्न प्रकार के तत्वों के साथ सूची (List with Different Types of Elements)

   my_list = [1, "Hello", 3.14, True]
   

    

3. list() फ़ंक्शन का उपयोग करके सूची (Creating List Using list() Function)

   my_list = list((1, 2, 3, 4, 5))
   

    

सूचियों के तत्वों तक पहुंच (Accessing Elements in a List)

आप सूची के तत्वों तक उनकी अनुक्रमणिका (index) का उपयोग करके पहुंच सकते हैं। पाइथन में, सूचियों का अनुक्रमणिका शून्य (0) से शुरू होता है।

उदाहरण (Example)

my_list = ["a", "b", "c", "d", "e"]
print(my_list[0])  # आउटपुट: a
print(my_list[2])  # आउटपुट: c
print(my_list[-1]) # आउटपुट: e

सूचियों के तत्वों में परिवर्तन (Modifying Elements in a List)

सूचियां परिवर्तनशील होती हैं, इसलिए आप सूचियों के तत्वों को उनकी अनुक्रमणिका का उपयोग करके बदल सकते हैं।

उदाहरण (Example)

my_list = [1, 2, 3, 4, 5]
my_list[2] = 10
print(my_list)  # आउटपुट: [1, 2, 10, 4, 5]

सूचियों में तत्व जोड़ना (Adding Elements to a List)

सूचियों में तत्व जोड़ने के कई तरीके हैं। आप append(), insert(), और extend() विधियों का उपयोग कर सकते हैं।

उदाहरण (Examples)

1. append() विधि का उपयोग करके (Using append() Method)

   my_list = [1, 2, 3]
   my_list.append(4)
   print(my_list)  # आउटपुट: [1, 2, 3, 4]
   

    

2. insert() विधि का उपयोग करके (Using insert() Method)

   my_list = [1, 2, 3]
   my_list.insert(1, 5)
   print(my_list)  # आउटपुट: [1, 5, 2, 3]
   

    

3. extend() विधि का उपयोग करके (Using extend() Method)

   my_list = [1, 2, 3]
   my_list.extend([4, 5])
   print(my_list)  # आउटपुट: [1, 2, 3, 4, 5]
   

    

सूचियों से तत्व निकालना (Removing Elements from a List)

सूचियों से तत्व निकालने के कई तरीके हैं। आप remove(), pop(), और del का उपयोग कर सकते हैं।

उदाहरण (Examples)

1. remove() विधि का उपयोग करके (Using remove() Method)

   my_list = [1, 2, 3, 4, 5]
   my_list.remove(3)
   print(my_list)  # आउटपुट: [1, 2, 4, 5]
   

    

2. pop() विधि का उपयोग करके (Using pop() Method)

   my_list = [1, 2, 3, 4, 5]
   my_list.pop(2)
   print(my_list)  # आउटपुट: [1, 2, 4, 5]
   

    

3. del का उपयोग करके (Using del)

   my_list = [1, 2, 3, 4, 5]
   del my_list[2]
   print(my_list)  # आउटपुट: [1, 2, 4, 5]
   

    

सूचियों के साथ लूप्स (Loops with Lists)

आप लूप्स का उपयोग करके सूचियों के तत्वों को इटरेट कर सकते हैं।

उदाहरण (Examples)

1. for लूप का उपयोग करके (Using for Loop)

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

    

2. while लूप का उपयोग करके (Using while Loop)

   my_list = [1, 2, 3, 4, 5]
   i = 0
   while i < len(my_list):
       print(my_list[i])
       i += 1
   

    

सूचियों का टुकड़ा करना (Slicing Lists)

स्लाइसिंग (Slicing) का उपयोग सूचियों के एक भाग को निकालने के लिए किया जाता है। आप स्लाइसिंग के लिए कोलन (:) का उपयोग कर सकते हैं।

उदाहरण (Examples)

1. सरल स्लाइसिंग (Simple Slicing)

   my_list = [1, 2, 3, 4, 5]
   print(my_list[1:3])  # आउटपुट: [2, 3]
   

    

2. सकारात्मक और नकारात्मक इंडेक्स का उपयोग करके (Using Positive and Negative Index)

   my_list = [1, 2, 3, 4, 5]
   print(my_list[:3])    # आउटपुट: [1, 2, 3]
   print(my_list[-3:])   # आउटपुट: [3, 4, 5]
   

    

सूची विधियाँ (List Methods)

सूचियों के साथ काम करने के लिए पाइथन में कई बिल्ट-इन विधियाँ होती हैं।

उदाहरण (Examples)

1. count() विधि (count() Method)

   my_list = [1, 2, 3, 4, 3, 2, 1]
   print(my_list.count(2))  # आउटपुट: 2
   

    

2. index() विधि (index() Method)

   my_list = [1, 2, 3, 4, 5]
   print(my_list.index(3))  # आउटपुट: 2
   

    

3. reverse() विधि (reverse() Method)

   my_list = [1, 2, 3, 4, 5]
   my_list.reverse()
   print(my_list)  # आउटपुट: [5, 4, 3, 2, 1]
   

    

सूचियों की कॉपी (Copying Lists)

सूचियों की कॉपी बनाने के कई तरीके होते हैं। आप copy(), स्लाइसिंग, या list() फ़ंक्शन का उपयोग कर सकते हैं।

उदाहरण (Examples)

1. copy() विधि का उपयोग करके (Using copy() Method)

   my_list = [1, 2, 3, 4, 5]
   copied_list = my_list.copy()
   print(copied_list)  # आउटपुट: [1, 2, 3, 4, 5]
   

    

2. स्लाइसिंग का उपयोग करके (Using Slicing)

   my_list = [1, 2, 3, 4, 5]
   copied_list = my_list[:]
   print(copied_list)  # आउटपुट: [1, 2, 3, 4, 5]
   

    

3. list() फ़ंक्शन का उपयोग करके (Using list() Function)

   my_list = [1, 2, 3, 4, 5]
   copied_list = list(my_list)
   print(copied_list)  # आउटपुट: [1, 2, 3, 4, 5]
   

    

सूची समझ (List Comprehensions)

सूची समझ (List Comprehensions) एक संक्षिप्त तरीका है सूचियों को बनाने का। यह कोड को संक्षिप्त और पठनीय बनाता है।

उदाहरण (Example)

1. सरल सूची समझ (Simple List Comprehension)

   squares = [x ** 2 for x in range(10)]
   print(squares)  # आउटपुट: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
   

    

2. शर्त के साथ सूची समझ (List Comprehension with Condition)

   even_squares = [x ** 2 for x in range(10) if x % 2 == 0]
   print(even_squares)  # आउटपुट: [0, 4, 16, 36, 64]
   

    

सूची में नष्टानुक्रम और क्रमबद्ध करना (Sorting and Reversing Lists)

आप सूचियों को क्रमबद्ध (sort) और नष्टानुक्रम (reverse) कर सकते हैं।

उदाहरण (Examples)

1. sort() विधि (sort() Method)

   my_list = [3, 1, 4, 1, 5, 9, 2]
   my_list.sort()
   print(my_list)  # आउटपुट: [1, 1, 2, 3, 4, 5, 9]
   

    

2. reverse() विधि (reverse() Method)

   my_list = [3, 1, 4, 1, 5, 9, 2]
   my_list.reverse()
   print(my_list)  # आउटपुट: [2, 9, 5, 1, 4, 1, 3]
   

    

सूचियों के उदाहरण (Examples with Lists)

इस सेक्शन में, हम सूचियों के कुछ उपयोगी उदाहरण देखेंगे जो विभिन्न समस्याओं का समाधान करेंगे।

1. सभी सम संख्याओं की गणना (Count All Even Numbers)

   numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   even_count = len([num for num in numbers if num % 2 == 0])
   print(even_count)  # आउटपुट: 5
   

    

2. सूचियों का संयोजन (Combining Lists)

   list1 = [1, 2, 3]
   list2 = [4, 5, 6]
   combined_list = list1 + list2
   print(combined_list)  # आउटपुट: [1, 2, 3, 4, 5, 6]
   

    

सूचियों के लिए उपयोगी टिप्स (Useful Tips for Lists)

1. स्मृति दक्षता (Memory Efficiency): बड़ी सूचियों के साथ काम करते समय स्मृति दक्षता का ध्यान रखें। यदि आवश्यक हो, तो सूची समझ या अन्य डेटा संरचनाओं का उपयोग करें।
2. अनुक्रमणिका की जाँच करें (Check Indices): अनुक्रमणिका का उपयोग करते समय यह सुनिश्चित करें कि आप वैध अनुक्रमणिका का उपयोग कर रहे हैं ताकि IndexError से बचा जा सके।
3. डॉक्स्ट्रिंग्स का उपयोग (Use Docstrings): यदि आपकी सूची जटिल है, तो उसके उपयोग के बारे में जानकारी देने के लिए डॉक्स्ट्रिंग्स का उपयोग करें।
4. लूप्स में सावधानी बरतें (Be Careful in Loops): सूचियों के साथ लूप्स का उपयोग करते समय अनावश्यक पुनरावृत्तियों से बचें और कोड को कुशल बनाए रखने का प्रयास करें।