Python सूची का आकार: Python में सूची की लंबाई ज्ञात करने के 8 अलग-अलग तरीके

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

Python सूचियाँ महत्वपूर्ण क्यों हैं?

Python में सूचियाँ डायनेमिक ऐरे होती हैं जो विभिन्न डेटा प्रकारों का मिश्रण रख सकती हैं, और डेटा भंडारण व हेरफेर के लिए बहुउद्देशीय उपकरण हैं। ये iteration, slicing जैसी क्रियाओं के साथ-साथ append(), remove(), और sort() जैसी अंतर्निहित विधियों द्वारा व्यापक हेरफेर को भी संभव बनाती हैं। आप इस ट्यूटोरियल में सूची हेरफेर के बारे में अधिक पढ़ सकते हैं।

Python में सूची कैसे परिभाषित करें

इस ट्यूटोरियल के उद्देश्यों के लिए, हम प्रत्येक विधि को प्रदर्शित करने हेतु एक साधारण सूची का उपयोग करेंगे। निम्नलिखित के अनुसार परिभाषित सूची my_list पर विचार करें:

# Define a sample list to be used throughout the tutorial
my_list = ["I", "Love", "Learning", "Python"]संचालित द्वारा

यह सूची, भले ही सरल है, इसकी लंबाई निर्धारित करने की विभिन्न तकनीकों को दिखाने के लिए उपयुक्त है।

Python सूची का आकार जानने के 8 तरीके

1. len() फ़ंक्शन का उपयोग करके सूची का आकार जानें

len() फ़ंक्शन सूची का आकार जानने का सबसे सीधा तरीका है। यह न केवल संक्षिप्त है बल्कि अत्यंत कुशल भी है, इसलिए अधिकांश मामलों में यह प्राथमिक विधि होती है।

# Use len() to find the size of the list
length = len(my_list)
print(length)  # Output: 4संचालित द्वारा

2. For लूप का उपयोग करके सूची का आकार जानें

इसे सरल (naive) विधि कहा जाता है। इसमें एक काउंटर को प्रारंभ करना और सूची पर for लूप चलाते समय प्रत्येक तत्व के लिए उसे 1 से बढ़ाना शामिल है। आप for लूप और अन्य प्रकार के लूप्स इस ट्यूटोरियल में सीख सकते हैं।

# Naive method using a for loop to count the list's size
counter = 0
for item in my_list:
    counter += 1
print(counter)  # Output: 4संचालित द्वारा

3. List Comprehension का उपयोग करके सूची का आकार जानें

Python में लिस्ट कॉम्प्रिहेंशन्स किसी सूची पर क्रियाएँ करने के लिए संक्षिप्त सिंटैक्स प्रदान करती हैं। यहाँ, हम इसे sum() फ़ंक्शन के साथ मिलाकर तत्वों की गिनती करते हैं।

# Using list comprehension to count the list's size
length = sum([1 for item in my_list])
print(length)  # Output: 4संचालित द्वारा

4. reduce() का उपयोग करके सूची का आकार जानें

reduce() फ़ंक्शन थोड़ा उन्नत है, पर बहुत शक्तिशाली भी। यह किसी सूची की वस्तुओं पर बाएँ से दाएँ दो आर्ग्युमेंट्स वाले एक फ़ंक्शन को क्रमिक रूप से लागू करता है ताकि सूची को एक एकल मान में समेट दे। हमारे उद्देश्य के लिए, हम इसे सूची में वस्तुओं की संख्या गिनने में उपयोग करेंगे।

इसे समझना आसान बनाने के लिए, हम इसे दो भागों में बाँटते हैं:

1. एक सरल फ़ंक्शन परिभाषित करें: पहले, हम एक सरल फ़ंक्शन परिभाषित करेंगे जो दो आर्ग्युमेंट लेता है: वर्तमान गिनती (count_so_far) और सूची से एक व्यक्तिगत आइटम (जिसे हम _ नाम देंगे ताकि स्पष्ट हो कि इस आइटम का उपयोग नहीं होगा)।
2. reduce() का उपयोग करें: फिर, हम reduce() का उपयोग करके इस फ़ंक्शन को सूची के हर आइटम पर लागू करेंगे, और इस प्रकार आइटमों की गिनती होती जाएगी।

# Import the reduce function from the functools module
from functools import reduce

# Define a simple function to use with reduce
def update_count(count_so_far, _):
    """Increases the count by 1. The second parameter is not used."""
    return count_so_far + 1

# Use reduce to count the items in the list
# We start counting from 0, which is why we have '0' at the end
list_length = reduce(update_count, my_list, 0)

# Print out the result
print(list_length)  # Output will be 4संचालित द्वारा

5. iter() और next() का उपयोग करके सूची का आकार जानें

iter() और next() का उपयोग कर सूची के तत्वों की गिनती समझने के लिए इटरेटर्स से परिचित होना ज़रूरी है। एक इटरेटर Python में ऐसा ऑब्जेक्ट है जो हमें सूची के सभी तत्वों को एक-एक करके पार करने देता है। iter() किसी सूची को इटरेटर में बदल देता है, और next() इटरेटर में अगले तत्व पर जाता है।

यहाँ चरण-दर-चरण विवरण दिया गया है:

1. एक इटरेटर बनाएँ: हम iter() फ़ंक्शन का उपयोग करके अपनी सूची को इटरेटर में बदलते हैं। इससे हम सूची में एक समय में एक आइटम पर जा सकते हैं।
2. लूप से गिनें: हम एक लूप सेट करते हैं जो तब तक चलता रहेगा जब तक सूची में और आइटम न बचें। लूप के अंदर, हम सूची के अगले आइटम पर जाने के लिए next() का उपयोग करते हैं। हर बार next() सफल होने पर, हम अपनी गिनती 1 से बढ़ाते हैं।
3. सूची के अंत को संभालें: अंततः, हम सूची के अंत तक पहुँचेंगे। तब next() एक StopIteration त्रुटि उत्पन्न करेगा, जो दर्शाता है कि अब और आइटम नहीं हैं। हम try और except ब्लॉक के साथ इस त्रुटि को पकड़ते हैं और गिनती रोक देते हैं।

प्रत्येक चरण को समझने में मदद के लिए टिप्पणी सहित सरल कोड यहाँ है:

# Step 1: Turn the list into an iterator
list_iterator = iter(my_list)

# Initialize a counter to keep track of the number of items
count = 0

# Step 2: Loop through the list using the iterator
while True:
    try:
        # Use next() to get the next item from the iterator
        next(list_iterator)
        
        # If next() was successful, increase the count
        count += 1
    except StopIteration:
        # Step 3: If we reach the end of the list, break out of the loop
        break

# Print out the total count of items in the list
print(count)  # Output will be 4संचालित द्वारा

6. enumerate() का उपयोग करके सूची का आकार जानें

Python में enumerate() फ़ंक्शन किसी iterable में काउंटर जोड़ता है और उसे एक enumerate ऑब्जेक्ट के रूप में लौटाता है। यह फ़ंक्शन आमतौर पर लूप्स में सूची के प्रत्येक आइटम का इंडेक्स और मान दोनों प्राप्त करने के लिए उपयोग किया जाता है। यद्यपि enumerate() आमतौर पर सूची का आकार जानने के लिए उपयोग नहीं होता, हम इसे यह दिखाने के लिए उपयोग कर सकते हैं कि Python कितना लचीला हो सकता है।

# Step 1: Enumerate the list and convert it to a list of tuples (index, element)
enumerated_list = list(enumerate(my_list))

# Step 2: Extract the last tuple (which contains the last index and the last element)
last_tuple = enumerated_list[-1]

# Step 3: The size of the list is the last index plus 1 (because of zero-based indexing)
list_size = last_tuple[0] + 1

# Print out the size of the list
print(list_size)  # Output will be 4संचालित द्वारा

7. NumPy का उपयोग करके सूची का आकार जानें

NumPy Python में एक शक्तिशाली लाइब्रेरी है जिसका व्यापक उपयोग वैज्ञानिक कंप्यूटिंग में होता है। यह बड़े, बहुआयामी ऐरे और मैट्रिस के लिए समर्थन प्रदान करती है, साथ ही इन ऐरे पर काम करने के लिए गणितीय फ़ंक्शनों का एक संग्रह भी देती है। संख्यात्मक डेटा के साथ काम करने वालों के लिए NumPy अपरिहार्य है, क्योंकि यह बड़े डेटासेट पर कुशल भंडारण और संचालन प्रदान करती है। Python में NumPy का उपयोग करके किसी सूची का आकार जानने के लिए, हम नीचे दिखाए गए अनुसार .size एट्रिब्यूट का उपयोग कर सकते हैं।

# Import the NumPy library
import numpy as np

# Step 1: Convert the list into a NumPy array
my_array = np.array(my_list)

# Step 2: Use the 'size' attribute of the NumPy array to find its size
array_size = my_array.size

# Print out the size of the array (which is the same as the length of the list)
print(array_size)  # Output will be 4संचालित द्वारा

8. map() और sum() का उपयोग करके सूची का आकार जानें

लिस्ट कॉम्प्रिहेंशन के समान, यह विधि map() का उपयोग प्रत्येक तत्व के लिए 1 लौटाने वाले फ़ंक्शन को लागू करने हेतु करती है, और फिर sum() के साथ इन मानों को जोड़कर तत्वों की गिनती करती है। इस विधि के लिए Python में lambda फ़ंक्शनों से परिचित होना आवश्यक है। तेज़ी से सीखने के लिए, यह Python lambda ट्यूटोरियल अवश्य देखें।

# Using map() and sum() to count the list's size
length = sum(map(lambda x: 1, my_list))
print(length)  # Output: 4संचालित द्वारा

विभिन्न Python सूची आकार विधियों के प्रदर्शन की तुलना

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

प्रयोग की सेटअप

सरलता के लिए, हम अपनी सूची और प्रत्येक विधि के फ़ंक्शनों को परिभाषित करते हैं। यदि आप फ़ंक्शनों से परिचित नहीं हैं तो भी ठीक है; हम यहाँ केवल विभिन्न विधियों को व्यवस्थित कर रहे हैं ताकि उनकी तुलना करना आसान हो।

import timeit
from functools import reduce
import numpy as np

# Define the list
my_list = ["I", "Love", "Learning", "Python"] * 100  # Increased size for better statistical signifcance

# Method 1: Using len()
def method_len():
    return len(my_list)

# Method 2: Looping through the list
def method_loop():
    counter = 0
    for _ in my_list:
        counter += 1
    return counter

# Method 3: Using a list comprehension
def method_list_comprehension():
    return sum([1 for _ in my_list])

# Method 4: Using reduce()
def method_reduce():
    return reduce(lambda acc, _: acc + 1, my_list, 0)

# Method 5: Using iter() and next()
def method_iter_next():
    iterator = iter(my_list)
    counter = 0
    while True:
        try:
            next(iterator)
            counter += 1
        except StopIteration:
            break
    return counter

# Method 6: Using enumerate()
def method_enumerate():
    return max(enumerate(my_list, 1))[0]

# Method 7: Using numpy
def method_numpy():
    np_array = np.array(my_list)
    return np_array.size

# Method 8: Using map() and sum()
def method_map_sum():
    return sum(map(lambda _: 1, my_list))संचालित द्वारा

प्रत्येक विधि का समय मापना

अब, हम निर्दिष्ट क्रम में प्रत्येक फ़ंक्शन का समय मापने के लिए timeit.timeit() का उपयोग करेंगे:

# List to hold method names and their execution times
timing_results = []

methods = [method_len, method_loop, method_list_comprehension, method_reduce, 
           method_iter_next, method_enumerate, method_numpy, method_map_sum]

# Time each method
for method in methods:
 # Execute the operation 100000 times for better statistical significance  
    time_taken = timeit.timeit(method, number=100000)
    timing_results.append((method.__name__, time_taken))

# Sort results by time taken for better readability
timing_results.sort(key=lambda x: x[1])

# Print the timing results
for method_name, time_taken in timing_results:
    print(f"{method_name}: {time_taken:.5f} seconds")संचालित द्वारा

इसे DataLab में चलाने पर हमें निम्नलिखित परिणाम मिलते हैं:

निष्कर्ष

समापन में, Python में सूची का आकार जानने की विभिन्न विधियों का यह अन्वेषण न केवल एक प्रोग्रामिंग भाषा के रूप में Python की बहुमुखी प्रतिभा और शक्ति दर्शाता है, बल्कि विभिन्न तरीकों की दक्षता और प्रयोज्यता को समझने के महत्त्व को भी रेखांकित करता है।

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

• Python Fundamentals स्किल ट्रैक
• Introduction to Python कोर्स
• शुरुआती के लिए Python चीट शीट