पायथन positional argument follows keyword argument समाधान

पायथन में, दो प्रकार के आर्गुमेंट्स होते हैं: पोजिशनल और कीवर्ड आर्गुमेंट्स। इन आर्गुमेंट्स को एक विशेष क्रम में आना चाहिए अन्यथा पायथन इंटरप्रेटर एक त्रुटि लौटाता है।

इस गाइड में, हम "positional argument follows keyword argument" त्रुटि के बारे में बात करने जा रहे हैं और यह क्यों उठाई जाती है। हम इस त्रुटि के साथ एक उदाहरण कोड स्निपेट देखेंगे ताकि हम यह बता सकें कि इसे कैसे हल किया जाए।

शुरू करते हैं!

समस्या: positional argument follows keyword argument

आइए हमारी पूरी त्रुटि पर एक नज़र डालते हैं:

SyntaxError: positional argument follows keyword argument

अंग्रेजी भाषा की तरह, प्रोग्रामिंग भाषाओं के अपने नियम होते हैं। इन नियमों को सिंटैक्स कहा जाता है। हमारी त्रुटि एक सिंटैक्स त्रुटि है जिसका अर्थ है कि हम पायथन कोड लिखने को नियंत्रित करने वाले नियमों में से एक का पालन करने में विफल रहे हैं।

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

पोजिशनल आर्गुमेंट्स वे आर्गुमेंट्स हैं जो अपनी संबंधित स्थितियों में दिखाई देते हैं:

def add_numbers(a, b):
    return a + b

Let's call this function:
add_numbers(2, 3)

"a" और "b" हमारे फ़ंक्शन के अंदर वेरिएबल्स बन जाते हैं। यह कोड काम करता है क्योंकि हमने दो पोजिशनल आर्गुमेंट्स निर्दिष्ट किए हैं। "a" 2 के बराबर है और "b" तीन के बराबर है। हम इन आर्गुमेंट्स को कीवर्ड आर्गुमेंट्स के रूप में भी निर्दिष्ट कर सकते हैं:

add_numbers(a=2, b=2)

हालांकि, हम पहले पोजिशनल सिंटैक्स निर्दिष्ट नहीं कर सकते और फिर कीवर्ड सिंटैक्स पर स्विच कर सकते हैं।

ऐसा इसलिए है क्योंकि पायथन में *args नामक एक विशेष फ़ंक्शन है जो फ़ंक्शन में कई आर्गुमेंट्स को प्रोसेस करता है। इस कोड पर विचार करें:

def show_users(a, b, *args):
    print(a, b, *args)

यह कोड *args का उपयोग करता है। यह कीवर्ड वेरिएबल संख्या में आर्गुमेंट्स को दर्शाता है। हम अपने show_users() फ़ंक्शन में जितने चाहें उतने आर्गुमेंट्स पास कर सकते हैं:

show_users("Alex", "Peter", "Violet", "Julie")

हमारा कोड लौटाता है: Alex Peter Violet Julie

हमारे पहले दो आर्गुमेंट्स, "a" और "b", के मान क्रमशः "Alex" और "Peter" हैं।

ऐसा इसलिए है क्योंकि यदि आप पोजिशनल सिंटैक्स का उपयोग करते हैं, तो आर्गुमेंट्स उस क्रम में असाइन किए जाते हैं जिसमें वे पास किए जाते हैं। अंतिम आर्गुमेंट्स उस क्रम में दिखाई देते हैं जिसमें वे बताए गए हैं क्योंकि *args अज्ञात मात्रा में अतिरिक्त आर्गुमेंट्स को दर्शाता है।

एक उदाहरण परिदृश्य

आइए एक कोड स्निपेट पर नज़र डालते हैं जो इस त्रुटि का अनुभव करता है:

def print_menu(salads, pizzas):
    print("Salad Menu")
    for s in salads:
        print(s)
    print("")
    print("Pizza Menu")
    for p in pizzas:
        print(p)

यह फ़ंक्शन दो आर्गुमेंट्स स्वीकार करता है: salads और pizzas। हमारा फ़ंक्शन सलाद मेनू पर प्रत्येक सलाद और पिज्जा मेनू पर प्रत्येक पिज्जा को कंसोल पर प्रिंट करता है।

आइए अपना फ़ंक्शन कॉल करते हैं:

salads = ["Tuna Salad", "Lettuce and Mango Salad", "Greek Salad"]
pizzas = ["Veggie Supreme", "Ham and Pineapple", "BBQ Chicken"]
print_menu(pizzas=pizzas, salads)

हमारा कोड लौटाता है:

File "main.py", line 13
    print_menu(pizzas=pizzas, salads)
    ^
SyntaxError: positional argument follows keyword argument

हमारे कोड में एक त्रुटि है, जैसा कि हमने अपेक्षा की थी। आइए इसे ठीक करते हैं।

समाधान

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

print_menu(salads, pizzas)

हमने दो पोजिशनल आर्गुमेंट्स निर्दिष्ट किए हैं: salads और pizzas। वैकल्पिक रूप से, हम "salads" के बाद "pizzas" को कीवर्ड आर्गुमेंट के रूप में निर्दिष्ट कर सकते हैं:

print_menu(salads, pizzas = pizzas)

इस उदाहरण में, किसी भी कीवर्ड आर्गुमेंट को जोड़ना अनावश्यक है क्योंकि हम *args मेथड का उपयोग नहीं कर रहे हैं। उस ने कहा, कीवर्ड आर्गुमेंट्स जोड़ने से कोड अधिक पठनीय हो सकता है, यह इस बात पर निर्भर करता है कि फ़ंक्शन में कितने मान पास किए जा रहे हैं।

आइए इस संशोधित फ़ंक्शन कॉल के साथ अपना कोड चलाते हैं:

Salad Menu
Tuna Salad
Lettuce and Mango Salad
Greek Salad

Pizza Menu
Veggie Supreme
Ham and Pineapple
BBQ Chicken

हमारा कोड सफलतापूर्वक हमारी दो पायथन सूचियों को प्रिंट करता है।

निष्कर्ष

पायथन में पोजिशनल आर्गुमेंट्स को कीवर्ड आर्गुमेंट से पहले आना चाहिए। ऐसा इसलिए है क्योंकि पायथन पोजिशनल आर्गुमेंट्स को उस क्रम में इंटरप्रेट करता है जिसमें वे दिखाई देते हैं। फिर, यह निर्दिष्ट किए गए कीवर्ड आर्गुमेंट्स को इंटरप्रेट करता है।

अब आप "positional argument follows keyword argument" त्रुटि को एक विशेषज्ञ पायथन डेवलपर की तरह हल करने के लिए तैयार हैं!