Python Language
विनाशकारी सूची (उर्फ पैकिंग और अनपैकिंग)

विनाशकारी कार्य

असाइनमेंट में, आप "अनपैकिंग" सिंटैक्स का उपयोग करके एक इरेटेबल को मानों में विभाजित कर सकते हैं:

मूल्यों के रूप में विनाशकारी

a, b = (1, 2)
print(a)
# Prints: 1
print(b)
# Prints: 2

यदि आप चलने की लंबाई से अधिक अनपैक करने का प्रयास करते हैं, तो आपको एक त्रुटि मिलेगी:

a, b, c = [1]
# Raises: ValueError: not enough values to unpack (expected 3, got 1)

head, *tail = [1, 2, 3, 4, 5]

print(head)
# Prints: 1
print(tail)
# Prints: [2, 3, 4, 5]

l = [1, 2, 3, 4, 5]
head = l[0]
tail = l[1:]

a, b, *other, z = [1, 2, 3, 4, 5]
print(a, b, z, other)
# Prints: 1 2 5 [3, 4]

असाइनमेंट को नष्ट करने में मूल्यों की अनदेखी करना

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

a, _ = [1, 2]
print(a)
# Prints: 1
a, _, c = (1, 2, 3)
print(a)
# Prints: 1
print(c)
# Prints: 3

a, *_ = [1, 2, 3, 4, 5]
print(a)
# Prints: 1

 a, *_, b = [1, 2, 3, 4, 5]
 print(a, b)
 # Prints: 1 5

 a, _, b, _, c, *_ = [1, 2, 3, 4, 5, 6]
 print(a, b, c)
 # Prints: 1 3 5

पैकिंग समारोह तर्क

फ़ंक्शन में, आप कई अनिवार्य तर्कों को परिभाषित कर सकते हैं:

def fun1(arg1, arg2, arg3): 
    return (arg1,arg2,arg3)

जो तीन तर्कों के दिए जाने पर ही कार्य को सुगम बनाएगा:

fun1(1, 2, 3)

और आप डिफ़ॉल्ट मानों का उपयोग करके तर्कों को वैकल्पिक के रूप में परिभाषित कर सकते हैं:

def fun2(arg1='a', arg2='b', arg3='c'):
    return (arg1,arg2,arg3)

इसलिए आप फ़ंक्शन को कई अलग-अलग तरीकों से कॉल कर सकते हैं, जैसे:

fun2(1)              → (1,b,c)
fun2(1, 2)           → (1,2,c)
fun2(arg2=2, arg3=3) → (a,2,3)
...

लेकिन आप तर्कों को पैक करने के लिए विनाशकारी वाक्यविन्यास का भी उपयोग कर सकते हैं, इसलिए आप किसी list या dict का उपयोग करके चर असाइन कर सकते हैं।

तर्कों की सूची तैयार करना

विचार करें कि आपके पास मूल्यों की एक सूची है

l = [1,2,3]

आप फ़ंक्शन को मानों की सूची के साथ एक तर्क के रूप में कॉल कर सकते हैं * सिंटैक्स:

fun1(*l)
# Returns: (1,2,3)
fun1(*['w', 't', 'f'])
# Returns: ('w','t','f')

लेकिन यदि आप एक सूची प्रदान नहीं करते हैं जो लंबाई तर्क की संख्या से मेल खाती है:

fun1(*['oops'])
# Raises: TypeError: fun1() missing 2 required positional arguments: 'arg2' and 'arg3'

पैकिंग कीवर्ड तर्क

अब, आप डिक्शनरी का उपयोग करके तर्क भी पैक कर सकते हैं। आप उपयोग कर सकते हैं ** अजगर बताने के लिए खोल करने के लिए ऑपरेटर dict पैरामीटर मान:

d = {
  'arg1': 1,
  'arg2': 2,
  'arg3': 3
}
fun1(**d)
# Returns: (1, 2, 3)

जब फ़ंक्शन में केवल स्थिति संबंधी तर्क होते हैं (डिफ़ॉल्ट मानों के बिना) आपको शब्दकोश की आवश्यकता होती है जिसमें सभी अपेक्षित पैरामीटर होते हैं, और कोई अतिरिक्त पैरामीटर नहीं होता है, या आपको एक त्रुटि मिलेगी:

fun1(**{'arg1':1, 'arg2':2})
# Raises: TypeError: fun1() missing 1 required positional argument: 'arg3'
fun1(**{'arg1':1, 'arg2':2, 'arg3':3, 'arg4':4})
# Raises: TypeError: fun1() got an unexpected keyword argument 'arg4'

वैकल्पिक तर्कों वाले कार्यों के लिए, आप तर्कों को शब्दकोश के रूप में पैक कर सकते हैं:

fun2(**d)
# Returns: (1, 2, 3)

लेकिन वहाँ आप मूल्यों को छोड़ सकते हैं, क्योंकि वे चूक से बदल जाएंगे:

fun2(**{'arg2': 2})
# Returns: ('a', 2, 'c')

और पहले की तरह ही, आप अतिरिक्त मान नहीं दे सकते हैं जो मौजूदा पैरामीटर नहीं हैं:

fun2(**{'arg1':1, 'arg2':2, 'arg3':3, 'arg4':4})
# Raises: TypeError: fun2() got an unexpected keyword argument 'arg4'

वास्तविक दुनिया के उपयोग में, कार्यों में स्थिति और वैकल्पिक तर्क दोनों हो सकते हैं, और यह एक ही काम करता है:

def fun3(arg1, arg2='b', arg3='c')
    return (arg1, arg2, arg3)

आप फ़ंक्शन को सिर्फ एक पुनरावृत्ति के साथ कह सकते हैं:

fun3(*[1])
# Returns: (1, 'b', 'c')
fun3(*[1,2,3])
# Returns: (1, 2, 3)

या सिर्फ एक शब्दकोश के साथ:

fun3(**{'arg1':1})
# Returns: (1, 'b', 'c')
fun3(**{'arg1':1, 'arg2':2, 'arg3':3})
# Returns: (1, 2, 3)

या आप एक ही कॉल में दोनों का उपयोग कर सकते हैं:

fun3(*[1,2], **{'arg3':3})
# Returns: (1,2,3)

हालांकि सावधान रहें कि आप एक ही तर्क के लिए कई मान प्रदान नहीं कर सकते हैं:

fun3(*[1,2], **{'arg2':42, 'arg3':3})
# Raises: TypeError: fun3() got multiple values for argument 'arg2'

समारोह तर्क अनपैकिंग

जब आप एक ऐसा फ़ंक्शन बनाना चाहते हैं जो किसी भी तर्क को स्वीकार कर सकता है, और "संकलन" समय पर स्थिति या तर्क के नाम को लागू नहीं करना है, तो यह संभव है और यहां बताया गया है:

def fun1(*args, **kwargs):
    print(args, kwargs)

*args और **kwargs पैरामीटर विशेष पैरामीटर हैं जो क्रमशः एक tuple और एक dict लिए निर्धारित हैं:

fun1(1,2,3)
# Prints: (1, 2, 3) {}
fun1(a=1, b=2, c=3)
# Prints: () {'a': 1, 'b': 2, 'c': 3}
fun1('x', 'y', 'z', a=1, b=2, c=3)
# Prints: ('x', 'y', 'z') {'a': 1, 'b': 2, 'c': 3}

यदि आप पर्याप्त पायथन कोड देखते हैं, तो आप जल्दी से पता लगा लेंगे कि किसी अन्य फ़ंक्शन पर तर्क पारित करते समय इसका व्यापक रूप से उपयोग किया जा रहा है। उदाहरण के लिए यदि आप स्ट्रिंग क्लास को विस्तारित करना चाहते हैं:

class MyString(str):
    def __init__(self, *args, **kwarg):
        print('Constructing MyString')
        super(MyString, self).__init__(*args, **kwarg)