परिचय
अनपैकिंग की मूल सीमाओं में से एक यह है कि आपको उन अनुक्रमों की लंबाई पहले से पता होनी चाहिए जिन्हें आप अनपैक कर रहे हैं।
इसे कैसे करें..
random_numbers = [0, 1, 5, 9, 17, 12, 7, 10, 3, 2]
random_numbers_descending = sorted(random_numbers, reverse=True)
print(f"Output \n*** {random_numbers_descending}") आउटपुट
*** [17, 12, 10, 9, 7, 5, 3, 2, 1, 0]
अगर मैं अब संख्याओं में से सबसे बड़ा और दूसरा सबसे बड़ा पता लगाना चाहता हूं, तो हमें "अनपैक करने के लिए बहुत अधिक मान" अपवाद मिलेगा।
print(f"Output \n*** Getting the largest and second largest") largest, second_largest = random_numbers_descending
आउटपुट
*** Getting the largest and second largest
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) in 1 print(f"Output \n*** Getting the largest and second largest") ----> 2 largest, second_largest = random_numbers_descending ValueError: too many values to unpack (expected 2)
पायथन अक्सर इंडेक्सिंग और स्लाइसिंग पर निर्भर करता है। उदाहरण के लिए, जब मैं नीचे दी गई वस्तुओं की सूची से सबसे बड़ा, दूसरा सबसे बड़ा निकालना चाहता हूं, तो हम यह कैसे कर सकते हैं।
largest = random_numbers_descending[0]
print(f"Output \n*** Getting the largest - {largest}") आउटपुट
*** Getting the largest - 17
second_largest = random_numbers_descending[1]
print(f"Output \n*** Getting the second largest - {second_largest}") आउटपुट
*** Getting the second largest - 12
rest_of_numbers = random_numbers_descending[2:]
print(f"Output \n*** Getting the rest of numbers - {rest_of_numbers}") आउटपुट
*** Getting the rest of numbers - [10, 9, 7, 5, 3, 2, 1, 0]
जबकि यह काम करता है, सभी अनुक्रमण और स्लाइसिंग नेत्रहीन शोर है। व्यवहार में, अनुक्रम के सदस्यों को इस तरह से विभिन्न उपसमुच्चय में विभाजित करने में त्रुटि होती है।
इसे बेहतर तरीके से करने के लिए, पायथन एक तारांकित अभिव्यक्ति के माध्यम से कैच-ऑल अनपैकिंग का समर्थन करता है।
यह तारांकित सिंटैक्स अनपैकिंग असाइनमेंट के एक भाग को वे सभी मान प्राप्त करने की अनुमति देता है जो अनपैकिंग पैटर्न के किसी अन्य भाग से मेल नहीं खाते।
largest,second_largest, *rest_of_numbers = random_numbers_descending
print(f"Output \n largest: {largest} \n second_largest:{second_largest} \n rest_of_numbers:{rest_of_numbers}") आउटपुट
largest: 17 second_largest:12 rest_of_numbers:[10, 9, 7, 5, 3, 2, 1, 0]
उपरोक्त कोड कैसा दिखता है? एक पंक्ति में जिसे पढ़ना भी आसान है, हम आउटपुट प्राप्त करने में सक्षम हैं। तारांकित व्यंजक किसी भी स्थिति में दिखाई दे सकता है, इसलिए जब भी आपको एक टुकड़ा निकालने की आवश्यकता हो तो आप कैच-ऑल अनपैकिंग के लाभ प्राप्त कर सकते हैं
largest: 17 rest_of_numbers:[12, 10, 9, 7, 5, 3, 2, 1] smallest:0
*rest_of_numbers, second_smallest, smallest = random_numbers_descending
print(f"Output \n rest_of_numbers:{rest_of_numbers} \n second_smallest: {second_smallest} \n smallest:{smallest}")
rest_of_numbers:[17, 12, 10, 9, 7, 5, 3, 2] second_smallest: 1 smallest:0
हालांकि, तारांकित अभिव्यक्ति वाले असाइनमेंट को अनपैक करने के लिए, आपके पास कम से कम एक आवश्यक भाग होना चाहिए, अन्यथा आपको एक सिंटैक्स त्रुटि प्राप्त होगी। हम अपने आप में कैच-ऑल एक्सप्रेशन का उपयोग नहीं कर सकते हैं।
*rest_of_numbers = random_numbers_descending
File "", line 1 *rest_of_numbers = random_numbers_descending ^ SyntaxError: starred assignment target must be in a list or tuple
हम एकल-स्तरीय अनपैकिंग पैटर्न में एकाधिक कैच-ऑल एक्सप्रेशन का उपयोग नहीं कर सकते हैं। विचार करने के लिए यह एक और महत्वपूर्ण नोट है।
*rest_of_numbers, *more_smallest, smallest = random_numbers_descending
File "", line 1 *rest_of_numbers, *more_smallest, smallest = random_numbers_descending ^ SyntaxError: two starred expressions in assignment
लेकिन एक अनपैकिंग असाइनमेंट स्टेटमेंट में कई तारांकित अभिव्यक्तियों का उपयोग करना संभव है, जब तक कि वे बहुस्तरीय संरचना के विभिन्न हिस्सों के अनपैक होने के लिए कैच-ऑल हैं।
player_grandslame_and_atptitles = {
'Federer': (20, 103),
'Nadal': (20,84),}
((player1, (grandslam1, *atptitles1)), (player2, (grandslam2, *atptitles2))) = player_grandslame_and_atptitles.items()
print(f'Output \nPlayer - {player1} Have acheived {grandslam1} grandslams and , {atptitles1} atp tour titles')
print(f'Player - {player2} Have acheived {grandslam2} grandslams and , {atptitles2} atp tour titles')
आउटपुट
Player - Federer Have acheived 20 grandslams and , [103] atp tour titles Player - Nadal Have acheived 20 grandslams and , [84] atp tour titles
तारांकित भाव सभी मामलों में सूची उदाहरण बन जाते हैं। यदि अनपैक किए जा रहे अनुक्रम से कोई बचा हुआ आइटम नहीं है, तो कैच-ऑल पार्ट एक खाली सूची होगी। यह विशेष रूप से तब उपयोगी होता है जब आप किसी अनुक्रम को संसाधित कर रहे होते हैं जिसे आप पहले से जानते हैं जिसमें कम से कम N तत्व होते हैं।
random_numbers = [0, 1]
first, second, *rest = random_numbers
print(f"Output \n{first, second, rest}") आउटपुट
(0, 1, [])