रेल इंजन चालक

अनपैकिंग का मतलब है किसी कलेक्शन, जैसे list, tuple या dict, के एलिमेंट्स को इटरेशन के ज़रिए निकालना। इस तरह निकाली गई वैल्यू को फिर उसी स्टेटमेंट में वेरिएबलो को असाइन किया जा सकता है। इसे ही आम तौर पर मल्टीपल असाइनमेंट कहा जाता है।

खास ऑपरेटर * और ** अक्सर अनपैकिंग और मल्टीपल असाइनमेंट में इस्तेमाल होते हैं।

मल्टीपल असाइनमेंट

मल्टीपल असाइनमेंट में असाइनमेंट ऑपरेटर (=) के बाईं ओर वेरिएबलो की संख्या और दाईं ओर वैल्यू की संख्या बराबर होनी चाहिए। वैल्यू को अलग करने के लिए कॉमा , का इस्तेमाल कीजिए:

>>> a, b = 1, 2
>>> a
1

अगर मल्टीपल असाइनमेंट में दी गई वैल्यू के लिए वेरिएबलो की संख्या गलत हो, तो ValueError मिलती है:

>>> x, y, z = 1, 2

ValueError: too many values to unpack (expected 3, got 2)

मल्टीपल असाइनमेंट सिर्फ एक डेटा टाइप तक सीमित नहीं है:

>>> x, y, z = 1, "Hello", True
>>> x
1

>>> y
'Hello'

>>> z
True

मल्टीपल असाइनमेंट का इस्तेमाल lists के एलिमेंट्स को आपस में बदलने के लिए किया जा सकता है। यह तरीका सॉर्टिंग एल्गोरिदम में काफी आम है। उदाहरण के लिए:

>>> numbers = [1, 2]
>>> numbers[0], numbers[1] = numbers[1], numbers[0]
>>> numbers
[2, 1]

चूँकि tuples इम्यूटेबल होते हैं, आप tuple के एलिमेंट्स को आपस में नहीं बदल सकते।

अनपैकिंग

Python में list/tuple/dictionary के एलिमेंट्स को अलग-अलग वेरिएबलो में अनपैक करना संभव है। चूँकि lists/tuples में वैल्यू एक तय क्रम में होती हैं, इसलिए उन्हें उसी क्रम में वेरिएबलो में अनपैक किया जाता है:

>>> fruits = ["apple", "banana", "cherry"]
>>> x, y, z = fruits
>>> x
"apple"

अगर कुछ वैल्यू की ज़रूरत नहीं है, तो आप उन्हें चिह्नित करने के लिए _ का इस्तेमाल कर सकते हैं:

>>> fruits = ["apple", "banana", "cherry"]
>>> _, _, z = fruits
>>> z
"cherry"

गहरी अनपैकिंग

किसी list या tuple के अंदर बंद list/tuple (जिसे नेस्टेड ऐरे/ट्यूपल भी कहते हैं) से वैल्यू अनपैक करके असाइन करना उसी तरह काम करता है जैसे सतही अनपैकिंग करता है, लेकिन संदर्भ या स्थिति स्पष्ट करने के लिए अक्सर क्वालिफायर की ज़रूरत पड़ती है:

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [c, d]] = fruits_vegetables
>>> a
"apple"

>>> d
"potato"

आप नेस्टेड list/tuple के सिर्फ एक हिस्से को भी गहराई से अनपैक कर सकते हैं:

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [a, [c, d]] = fruits_vegetables
>>> a
["apple", "banana"]

>>> c
"carrot"

अगर अनपैकिंग में वेरिएबलो की जगह गलत हो या वैल्यू की संख्या गलत हो, तो आपको ValueError मिलती है:

>>> fruits_vegetables = [["apple", "banana"], ["carrot", "potato"]]
>>> [[a, b], [d]] = fruits_vegetables

ValueError: too many values to unpack (expected 1)

* की मदद से ऐरे/ट्यूपल अनपैक करना

list/tuple को अनपैक करते समय आप "बची हुई" वैल्यू को पकड़ने के लिए * ऑपरेटर का इस्तेमाल कर सकते हैं। यह list/tuple को स्लाइस करने से ज़्यादा स्पष्ट है (जो कुछ स्थितियों में कम पठनीय होता है)। उदाहरण के लिए, पहला एलिमेंट निकाला जा सकता है और फिर बाकी वैल्यू को पहले एलिमेंट के बिना एक नए list में रखा जा सकता है:

>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *last = fruits
>>> x
"apple"

>>> last
["banana", "cherry", "orange", "kiwi", "melon", "mango"]

हम list के शुरू और अंत की वैल्यू भी निकाल सकते हैं और बीच की सारी वैल्यू को एक साथ समूहित कर सकते हैं:

>>> fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
>>> x, *middle, y, z = fruits
>>> y
"melon"

>>> middle
["banana", "cherry", "orange", "kiwi"]

हम गहरी अनपैकिंग में * का भी इस्तेमाल कर सकते हैं:

>>> fruits_vegetables = [["apple", "banana", "melon"], ["carrot", "potato", "tomato"]]
>>> [[a, *rest], b] = fruits_vegetables
>>> a
"apple"

>>> rest
["banana", "melon"]

डिक्शनरी अनपैक करना

डिक्शनरी को अनपैक करना list/tuple को अनपैक करने से थोड़ा अलग है। डिक्शनरी पर इटरेशन डिफ़ॉल्ट रूप से कीज़ पर होता है। इसलिए जब आप dict को अनपैक करते हैं, तो आप सिर्फ कीज़ अनपैक कर सकते हैं, वैल्यू नहीं:

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory
>>> x
"apple"

अगर आप वैल्यू को अनपैक करना चाहते हैं, तो <dict>.values() मेथड का इस्तेमाल कर सकते हैं:

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.values()
>>> x
6

अगर कीज़ और वैल्यू दोनों की ज़रूरत हो, तो <dict>.items() मेथड का इस्तेमाल कीजिए। <dict>.items() की-वैल्यू जोड़ों वाला एक इटरेबल व्यू बनाता है। इन्हें एक tuple में अनपैक किया जा सकता है:

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> x, y, z = fruits_inventory.items()
>>> x
("apple", 6)

पैकिंग

पैकिंग का मतलब है कई वैल्यू को एक list में समूहित करके उसे किसी वेरिएबल को असाइन करना। यह तब काम आता है जब आप वैल्यू को अनपैक करना, उनमें बदलाव करना और फिर नतीजों को वापस पैक करके किसी वेरिएबल में रखना चाहते हैं। इससे 2 या अधिक lists/tuples/dicts को आपस में जोड़ना भी संभव हो जाता है।

* की मदद से ऐरे/ट्यूपल पैक करना

list/tuple को पैक करने के लिए * ऑपरेटर का इस्तेमाल किया जा सकता है। यह सारी वैल्यू को एक list/tuple में पैक कर देता है।

>>> fruits = ("apple", "banana", "cherry")
>>> more_fruits = ["orange", "kiwi", "melon", "mango"]

# fruits and more_fruits are unpacked and then their elements are packed into combined_fruits
>>> combined_fruits = *fruits, *more_fruits

# If there is no * on to the left of the "=" the result is a tuple
>>> combined_fruits
("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")

# If the * operator is used on the left side of "=" the result is a list.
# Note the trailing comma.
>>> *combined_fruits_too, = *fruits, *more_fruits
>>> combined_fruits_too
['apple', 'banana', 'cherry', 'orange', 'kiwi', 'melon', 'mango']

* को बाईं ओर इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए PEP 3132 देखिए।

** की मदद से डिक्शनरी पैक करना

डिक्शनरी को पैक करने के लिए ** ऑपरेटर का इस्तेमाल किया जाता है। यह एक डिक्शनरी के सारे की-वैल्यू जोड़ों को दूसरी डिक्शनरी में पैक कर देता है, या दो डिक्शनरी को आपस में जोड़ देता है।

>>> fruits_inventory = {"apple": 6, "banana": 2, "cherry": 3}
>>> more_fruits_inventory = {"orange": 4, "kiwi": 1, "melon": 2, "mango": 3}

# fruits_inventory and more_fruits_inventory are unpacked into key-values pairs and combined.
>>> combined_fruits_inventory = {**fruits_inventory, **more_fruits_inventory}

# then the pairs are packed into combined_fruits_inventory
>>> combined_fruits_inventory
{"apple": 6, "banana": 2, "cherry": 3, "orange": 4, "kiwi": 1, "melon": 2, "mango": 3}

फंक्शन के साथ * और ** का उपयोग

फंक्शन पैरामीटर के साथ पैकिंग

जब आप ऐसा फंक्शन बनाते हैं जो किसी भी संख्या में आर्गुमेंट स्वीकार करता है, तो फंक्शन बनाते समय आप *args या **kwargs का इस्तेमाल कर सकते हैं। *args का इस्तेमाल किसी भी संख्या के पोज़िशनल (गैर-कीवर्ड) आर्गुमेंट को एक tuple के रूप में पैक करने के लिए होता है और **kwargs का इस्तेमाल किसी भी संख्या के कीवर्ड आर्गुमेंट को एक डिक्शनरी के रूप में पैक करने के लिए होता है।

*args का उपयोग:

# This function is defined to take any number of positional arguments

>>> def my_function(*args):
...     print(args)

# Arguments given to the function are packed into a tuple

>>> my_function(1, 2, 3)
(1, 2, 3)

>>> my_function("Hello")
("Hello")

>>> my_function(1, 2, 3, "Hello", "Mars")
(1, 2, 3, "Hello", "Mars")

**kwargs का उपयोग:

# This function is defined to take any number of keyword arguments

>>> def my_function(**kwargs):
...   print(kwargs)

# Arguments given to the function are packed into a dictionary

>>> my_function(a=1, b=2, c=3)
{"a": 1, "b": 2, "c": 3}

*args और **kwargs का इस्तेमाल एक साथ भी किया जा सकता है:

>>> def my_function(*args, **kwargs):
...   print(sum(args))
...   for key, value in kwargs.items():
...       print(str(key) + " = " + str(value))

>>> my_function(1, 2, 3, a=1, b=2, c=3)
6
a = 1
b = 2
c = 3

आप खास पोज़िशनल आर्गुमेंट की अनुमति देने के लिए *args से पहले पैरामीटर भी लिख सकते हैं। तब अलग-अलग कीवर्ड आर्गुमेंट **kwargs से पहले आने चाहिए।

>>> def my_function(a, b, *args):
...   print(a)
...   print(b)
...   print(args)

>>> my_function(1, 2, 3, 4, 5)
1
2
(3, 4, 5)

आर्गुमेंट को गलत क्रम में लिखने पर एरर मिलती है:

>>>def my_function(*args, a, b):
... print(args)

>>>my_function(1, 2, 3, 4, 5)
Traceback (most recent call last):
  File "c:\something.py", line 3, in <module>
    my_function(1, 2, 3, 4, 5)
TypeError: my_function() missing 2 required keyword-only arguments: 'a' and 'b'

फंक्शन कॉल में अनपैकिंग

आप आर्गुमेंट के list/tuple को फंक्शन कॉल में अनपैक करने के लिए * का इस्तेमाल कर सकते हैं। यह उन फंक्शनों के लिए बहुत काम का है जो iterable नहीं लेते:

>>> def my_function(a, b, c):
...   print(c)
...   print(b)
...   print(a)

numbers = [1, 2, 3]
>>> my_function(*numbers)
3
2
1

zip() बिल्ट-इन के साथ * अनपैकिंग का इस्तेमाल भी एक आम उदाहरण है। zip() फंक्शन कई इटरेबल लेता है और हर iterable की वैल्यू को समूहित करके tuples की एक list लौटाता है:

>>> values = (['x', 'y', 'z'], [1, 2, 3], [True, False, True])
>>> a, *rest = zip(*values)
>>> rest
[('y', 2, False), ('z', 3, True)]