Python Empty Lists पर एक व्यापक मार्गदर्शिका

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

यदि आप इस विषय पर अधिक जानकारी चाहते हैं, तो हमारा पूरा Python Lists ट्यूटोरियल देखें।

संक्षिप्त उत्तर; Python में खाली सूची कैसे बनाएँ

यदि आप जल्दी में हैं, तो Python में खाली सूची बनाना उतना ही सरल है जितना कि वर्ग कोष्ठकों [] का उपयोग करना। यह संक्षिप्त तरीका न केवल याद रखने में आसान है बल्कि आगे के संचालन के लिए सूची को प्रारंभ करने में कुशल भी है। यहाँ my_list नाम की एक खाली सूची बनाने और उसमें (आगे विस्तार से कवर किया गया है) ‘Python’ और ‘Rocks’ शब्द जोड़ने का उदाहरण दिया गया है।

# Create an empty list called my_list
my_list = []
# Append the words 'Python' and 'Rocks' to it
my_list.append('Python')
my_list.append('Rocks')

# my_list is now ['Python', 'Rocks']

Python खाली सूचियाँ बनाना: उपयोग करने के दो तरीके

हालाँकि ऊपर के संक्षिप्त भाग में खाली सूची प्रारंभ करने के त्वरित तरीके के रूप में वर्ग कोष्ठकों [] का परिचय कराया गया था, इसकी सादगी और दक्षता की सराहना करने के लिए इस तकनीक को थोड़ा और विस्तार से देखना उचित है। इसके अलावा, Python एक और अधिक स्पष्ट विकल्प भी प्रदान करता है जो कुछ कोडिंग शैलियों और स्पष्टता आवश्यकताओं के अनुरूप है।

विधि 1: [] का उपयोग करके खाली सूचियाँ बनाना

खाली सूची बनाने के लिए वर्ग कोष्ठकों [] का उपयोग Python के डिज़ाइन दर्शन का प्रमाण है, जो सादगी और पठनीयता पर जोर देता है। यह सूची संचालन के लिए एक साफ-सुथला, सहज शुरुआती बिंदु है। यहाँ [] का उपयोग करके खाली सूची को कैसे प्रारंभ करें, इसकी एक याद दिलाई गई है:

# Initializing an empty list with square brackets
my_empty_list = []

विधि 2: Python के अंतर्निहित list() फ़ंक्शन का उपयोग

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

# Create an empty list using the list() function
my_empty_list = list()

खाली सूचियों पर सामान्य संचालन

खाली सूचियों में हेरफेर करना समझना प्रभावी Python प्रोग्रामिंग के लिए महत्वपूर्ण है। यहाँ कुछ प्रमुख संचालन दिए गए हैं जिन्हें आप खाली सूचियों के साथ काम करते समय अवश्य उपयोग करेंगे।

.append() का उपयोग करके खाली सूची में तत्व जोड़ना

यदि आप उसमें तत्व नहीं जोड़ सकते, तो खाली सूची बहुत उपयोगी नहीं है। सूची के अंत में कोई तत्व जोड़ने के लिए, बस .append() मेथड का उपयोग करें। यहाँ, उदाहरण के लिए, हम एक खाली सूची प्रारंभ करते हैं और शब्द ’Python’, ’Rocks!’, और ‘It’s easy to learn!’ को my_list में जोड़ते हैं।

# Initialize an empty list
my_list = []

# Append elements
my_list.append('Python')
my_list.append('Rocks!')
my_list.append('It’s easy to learn!')

# `my_list` is now ['Python', 'Rocks!', 'It’s easy to learn!']

.insert() का उपयोग करके सूची में किसी विशिष्ट स्थान पर तत्व डालना

.append() की एक कमी यह है कि यह केवल सूची के अंत में तत्व जोड़ता है — यानी .append() का उपयोग करते समय हमारे पास नए तत्व को ठीक कहाँ डालना है, इस पर नियंत्रण नहीं होता। दूसरी ओर, .insert() मेथड हमें बिल्कुल यही करने देता है। यहाँ हम पिछले खंड के उदाहरण को आगे बढ़ाते हैं और ’Truly’ को ’Python’ और ’Rocks!’ के बीच डालते हैं। ध्यान दें कि Python में ज़ीरो-बेस्ड इंडेक्सिंग होती है, यानी सूची के पहले तत्व का इंडेक्स 0 होता है। अधिक विवरण के लिए उदाहरण देखें:

# Initialize an empty list
my_list = []

# Append elements
my_list.append('Python')
my_list.append('Rocks!')
my_list.append('It’s easy to learn!')

# `my_list` is now ['Python', 'Rocks!', 'It’s easy to learn!']

# Showcase zero-based indexing in Python
my_list[0] # Returns 'Python'
my_list[1] # Returns 'Rocks'
my_list[2] # Returns 'It's easy to learn!'

# Use the .insert() method to insert ’Truly’ between ’Python’ and ’Rocks!’
my_list.insert(1, 'Truly')
# `my_list` is now ['Python', 'Truly', 'Rocks', 'It’s easy to learn!']

.extend() का उपयोग करके कई तत्व जोड़ना

जहाँ .append() और .insert() मेथड सूची में व्यक्तिगत तत्व जोड़ने के लिए उपयुक्त हैं, वहीं .extend() हमें एक साथ कई तत्व जोड़ने की अनुमति देता है। जब आप दो सूचियों को मर्ज करना चाहते हैं या बिना इटरेट किए तत्वों का एक संग्रह जोड़ना चाहते हैं, तो यह विशेष रूप से उपयोगी हो सकता है। पिछले उदाहरण पर आगे बढ़ते हुए, आइए अपनी my_list में कुछ और वर्णनात्मक शब्द जोड़ें ताकि हमारा वाक्य और रोचक बने:

# Reminder that `my_list` is ['Python', 'Truly', 'Rocks', 'It’s easy to learn!']

# Extend my_list with ['and', 'fun', 'to', 'use!']
my_list.extend(['and', 'fun', 'to', 'use!'])

# `my_list` is now ['Python', 'Truly', 'Rocks!', 'It’s easy to learn!', 'and', 'fun', 'to', 'use!']

इस उदाहरण में, .extend() एक इटरेबल (जैसे सूची, सेट, या ट्यूपल) लेता है और उसके प्रत्येक तत्व को my_list के अंत में जोड़ देता है, जिससे हमारा वाक्य और विस्तृत हो जाता है।

+ का उपयोग करके सूचियों को जोड़ना

एक सूची से दूसरी सूची में तत्व जोड़ने का एक और तरीका + ऑपरेटर का उपयोग करना है, जो दो सूचियों को जोड़ता है। यह तरीका सीधा है और मूल सूचियों को संशोधित नहीं करता, बल्कि एक नई सूची बनाता है। आइए अपनी मौजूदा my_list के साथ एक नई सूची को जोड़ते हैं:

# Define a new list to concatenate
additional_words = ['Python is also', 'very versatile.']

# Concatenate lists using +
complete_sentence = my_list + additional_words

# `complete_sentence` now contains the elements of both lists
# `complete_sentence` is now ['Python', 'Truly', 'Rocks!', 'It’s easy to learn!', 'and', 'fun', 'to', 'use!', 'Python is also', 'very versatile.']

इस उदाहरण में, .extend() एक इटरेबल (जैसे सूची, सेट, या ट्यूपल) लेता है और उसके प्रत्येक तत्व को my_list के अंत में जोड़ देता है, जिससे हमारा वाक्य और विस्तृत हो जाता है।

.copy() का उपयोग करके सूचियों की कॉपी बनाना

जब आप मूल सूची को संरक्षित रखना चाहते हैं और उसकी प्रतिलिपि में संशोधन करना चाहते हैं, तो सूची की कॉपी बनाना आवश्यक होता है। .copy() मेथड सूची की शैलो कॉपी बनाता है, यानी यह सूची को डुप्लिकेट करता है लेकिन उसके भीतर के गहरे ऑब्जेक्ट्स को नहीं। आइए my_list की एक कॉपी बनाते हैं:

# Make a copy of `my_list`
my_list_copy = my_list.copy()

# Verify that `my_list_copy` is a separate object
assert my_list_copy is not my_list  # This will pass, confirming they are different objects

.copy() का उपयोग सुनिश्चित करता है कि कॉपी की गई सूची में किए गए बदलाव मूल सूची को प्रभावित नहीं करेंगे।

.clear() का उपयोग करके सूची खाली करना

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

# Clear all elements from `my_list`
my_list.clear()

# `my_list` is now an empty list again
assert len(my_list) == 0  # This will pass, confirming the list is empty

.clear() मेथड विशेष रूप से तब उपयोगी होता है जब आपको सूची को नए सिरे से बनाने के बजाय उसे पुन: उपयोग या रीसेट करना हो।

Python खाली सूचियों को प्रारंभ करने के सामान्य उपयोग-मामले

खाली सूचियाँ विभिन्न प्रोग्रामिंग परिदृश्यों में आवश्यक तत्व के रूप में काम करती हैं। उनके अनुप्रयोगों को समझना कोडिंग की दक्षता और समस्या-समाधान कौशल को उल्लेखनीय रूप से बढ़ा सकता है।

खाली सूची में डेटा को डायनेमिक रूप से संग्रहित करना

ऐसी स्थितियों में जहाँ डेटा की मात्रा या प्रकार अप्रत्याशित होता है, खाली सूचियाँ जानकारी को डायनेमिक रूप से एकत्रित करने के लिए लचीले कंटेनर के रूप में उभरती हैं। एक ऐसे प्रोग्राम पर विचार करें जो किसी विशेष शर्त के पूरा होने तक यूज़र इनपुट पढ़ता है। यहाँ, हमें नहीं पता कि हमें कितने यूज़र इनपुट मिल सकते हैं, और .append() मेथड का उपयोग करके हम user_response सूची में तत्वों को डायनेमिक रूप से जोड़ सकते हैं।

# Initialize an empty list to store user input
user_responses = []

# Collect user input in a loop
while True:
    response = input("Enter your response (or type 'exit' to finish): ")
    if response.lower() == 'exit':
        break
    user_responses.append(response)

# User responses are now stored in `user_responses`

For लूप से परिणामों को खाली सूची में संग्रहित करना

लूप्स के साथ काम करते समय, खाली सूचियाँ प्रत्येक पुनरावृत्ति में उत्पन्न परिणामों को संकलित करने के लिए अमूल्य साबित होती हैं। यहाँ एक उदाहरण है जहाँ हम 0 से 20 तक की रेंज में इटरेट करते हुए सम संख्याएँ संग्रहित करते हैं।

# Initialize an empty list to store even numbers
even_numbers = []

# Loop through a range of numbers and store even ones
for number in range(21):  # Upper limit 21 to include 20 in the range
    if number % 2 == 0: # if remainder when divided by 2 =0, store it in empty list
        even_numbers.append(number)

# `even_numbers` now contains even numbers from 0 to 20

फ़ंक्शन आउटपुट्स को खाली सूचियों में संग्रहित करना

जब आप ऐसे फ़ंक्शन डिज़ाइन करते हैं जिनके रिटर्न मान बदलते रहते हैं, तो खाली सूची को प्रारंभ करना और लौटाना बिना परिणाम वाले परिदृश्यों को सुंदर ढंग से संभाल सकता है। यहाँ, उदाहरण के लिए, हम शब्दों की एक सूची पर लूप लगाते हैं और ’A’ से शुरू होने वाले शब्दों को खाली सूची में संग्रहित करते हैं।

def find_strings_starting_with_a(strings):
    # Initialize an empty list to store strings that start with 'A'
    strings_starting_with_a = []
    
    # Iterate over the input list and append strings that start with 'A' to `strings_starting_with_a`
    for string in strings:
        if string.startswith('A'):
            strings_starting_with_a.append(string)
    
    return strings_starting_with_a

# Example usage
result = find_strings_starting_with_a(['Assert', 'Import', 'Function', 'Array', 'Arguments'])

# 'result' will contain ['Assert', 'Array', 'Arguments']

निष्कर्ष

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

आप Python सूचियों और कई अन्य उपयोगी फ़ंक्शन्स के बारे में और जान सकते हैं हमारे Python Fundamentals स्किल ट्रैक में — आज ही शुरू करें!