पायथन में स्टार एक्सप्रेशन का उपयोग करके अनपैक कैसे करें

परिचय

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

कैसे करें

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]

अगर मैं अब सबसे बड़ी और दूसरी सबसे बड़ी संख्या ढूंढना चाहता हूं, तो हमें "too many values to unpack" एक्सेप्शन मिलेगा।

largest, second_largest = random_numbers_descending

एरर: ValueError: too many values to unpack (expected 2)

पायथन अक्सर इंडेक्सिंग और स्लाइसिंग पर निर्भर करता है।

largest = random_numbers_descending[0]
second_largest = random_numbers_descending[1]
rest_of_numbers = random_numbers_descending[2:]

जबकि यह काम करता है, सभी इंडेक्सिंग और स्लाइसिंग विजुअली नॉइज़ी हैं। अभ्यास में, इस तरह सीक्वेंस के सदस्यों को विभिन्न सबसेट्स में विभाजित करना एरर-प्रोन है।

इसे बेहतर करने के लिए, पायथन स्टार्ड एक्सप्रेशन के माध्यम से कैच-ऑल अनपैकिंग सपोर्ट करता है।

यह स्टार्ड सिंटैक्स अनपैकिंग असाइनमेंट के एक हिस्से को उन सभी मानों को प्राप्त करने की अनुमति देता है जो अनपैकिंग पैटर्न के किसी अन्य हिस्से से मेल नहीं खाते।

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, *rest_of_numbers, smallest = random_numbers_descending
print(f"largest: {largest} \n rest_of_numbers:{rest_of_numbers} \n smallest:{smallest}")

आउटपुट: 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"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

महत्वपूर्ण प्रतिबंध

1. कम से कम एक आवश्यक भाग होना चाहिए: आप केवल कैच-ऑल एक्सप्रेशन का उपयोग नहीं कर सकते।

   
   *rest_of_numbers = random_numbers_descending
   # SyntaxError: starred assignment target must be in a list or tuple
   

2. एक ही लेवल पर एकाधिक कैच-ऑल एक्सप्रेशन्स नहीं:

   
   *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'Player - {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

स्टार्ड एक्सप्रेशन्स सभी मामलों में लिस्ट इंस्टेंसेस बन जाते हैं। अगर अनपैक की जा रही सीक्वेंस से कोई बचा हुआ आइटम नहीं है, तो कैच-ऑल भाग एक खाली लिस्ट होगी।

random_numbers = [0, 1]
first, second, *rest = random_numbers
print(f"Output \n{first, second, rest}")

आउटपुट: (0, 1, [])