Python में आर्गुमेंट पार्सिंग

यदि आप डेटा साइंस या मशीन लर्निंग प्रोजेक्ट की योजना बना रहे हैं, तो यह असामान्य नहीं है कि आप इसे एक Jupyter Notebook में विकसित करना शुरू करें। यह आपके कंप्यूटिंग टूल्स में इंटरएक्टिविटी प्रदान करता है, आपको अपने मॉड्यूल्स जल्दी चलाने देता है, आदि। डेटा साइंस या मशीन लर्निंग प्रोजेक्ट्स के लिए खासतौर पर Jupyter Notebooks को प्राथमिक टूल के रूप में चुनने के कई कारण हैं। हालांकि, यह ट्यूटोरियल उस हिस्से पर प्रकाश डालने का उद्देश्य नहीं रखता।

मान लीजिए आपको अपने डेटा साइंस प्रोजेक्ट में डेटा इन्जेशन के लिए एक Python स्क्रिप्ट को बैच जॉब के रूप में चलाना है। या आपको किसी मशीन लर्निंग मॉडल को रिमोट सर्वर पर डिप्लॉय करने के लिए Python स्क्रिप्ट चलानी है। ऐसे मामलों में, केवल python your_script.py चलाना पर्याप्त नहीं हो सकता। आपको python your_script.py के साथ और विकल्प या आर्गुमेंट पास करने की आवश्यकता हो सकती है। आप शायद पहले से Linux टर्मिनल पर कमांड्स (जैसे ps, ls, आदि) चलाते समय अतिरिक्त आर्गुमेंट्स के प्रयोग से परिचित होंगे।

इस ट्यूटोरियल में, आप सीखेंगे कि कमांड लाइन से Python स्क्रिप्ट के साथ पास किए गए अतिरिक्त आर्गुमेंट्स, विकल्पों को कैसे पार्स किया जाए। आज के ट्यूटोरियल की सामग्री का सारांश यहाँ है:

• आर्गुमेंट पार्सिंग का एक बुनियादी परिचय
• Python में आर्गुमेंट पार्सिंग
  • sys.argv का उपयोग
  • getopt का उपयोग
  • argparse का उपयोग

नोट कि यह ट्यूटोरियल Python की बुनियादी जानकारी मानकर चलता है।

आर्गुमेंट पार्सिंग क्या है?

अगर आप Linux यूज़र हैं, तो शायद आप पहले से यह जानते हैं। किसी विशेष डायरेक्ट्री में मौजूद फ़ाइलों और फ़ोल्डरों का सारांश पाने के लिए ls कमांड अक्सर उपयोग में आता है। ls कमांड चलाने का एक सामान्य आउटपुट कुछ इस तरह दिखता है -

हालाँकि, आप ls कमांड को कई विकल्प दे सकते हैं, जैसे -l। आइए देखें उसका आउटपुट कैसा दिखता है -

-l विकल्प पास करके, आपको अधिक जानकारी मिली। अब, इस संदर्भ में विकल्प और आर्गुमेंट में थोड़ा फर्क है। अपनी वर्तमान कार्यशील डायरेक्ट्री से फ़ाइल या फ़ोल्डर हटाने के लिए rm कमांड का अक्सर उपयोग किया जाता है। मान लीजिए, आपके पास demo.txt नाम की एक टेक्स्ट फ़ाइल है और आप उसे हटाने के लिए rm demo.txt चलाते हैं। इस मामले में, demo.txt वह आर्गुमेंट है जिसे आपने rm कमांड पर लागू किया। अगर आप rm कमांड को कोई आर्गुमेंट पास नहीं करते, तो आपको इस तरह की त्रुटि मिलेगी -

तो, विकल्प और आर्गुमेंट में अंतर क्या है? अब यह काफी स्पष्ट है। विकल्प वैकल्पिक होते हैं जबकि आर्गुमेंट्स अक्सर आवश्यक होते हैं। ls कमांड को कोई इनपुट दिए बिना भी वह आउटपुट दे सकता है।

अब, जब आप ls -l या rm demo.txt टाइप करते हैं, तो ऑपरेटिंग सिस्टम उसे आंतरिक रूप से एक खास तरीके से पार्स करता है। यह तंत्र आम तौर पर ऑपरेटिंग सिस्टम के डेवलपर्स द्वारा परिभाषित होता है, और इसे पार्सिंग कहा जाता है।

यदि आप और अधिक Linux कमांड्स तथा उनके समर्थित विकल्पों और आर्गुमेंट्स के बारे में जानने में रुचि रखते हैं, तो Unix Concepts and Applications पुस्तक पढ़ना अत्यधिक अनुशंसित है।

तो, यह था आर्गुमेंट पार्सिंग का एक बुनियादी परिचय। लगभग सभी प्रोग्रामिंग भाषाएँ आर्गुमेंट पार्सिंग का समर्थन करती हैं। Python भी इसका अपवाद नहीं है। Python में आर्गुमेंट पार्सिंग करने के तीन बहुत प्रचलित तरीके हैं -

• sys.argv
• getopt
• argparse

अब आप ऊपर दिए गए प्रत्येक विकल्प को एक-एक करके लेंगे और देखेंगे कि उन्हें आर्गुमेंट्स (और विकल्पों) को पार्स करने के लिए कैसे उपयोग करें। चलिए कालानुक्रमिक क्रम में चलते हैं।

sys.argv का उपयोग करके आर्गुमेंट पार्सिंग

आइए सरल से शुरू करें। इस पहले उदाहरण में, आप demo1.py नाम की एक Python फ़ाइल बनाएँगे। आपका कार्यक्रम चलने के दौरान कमांड-लाइन (या टर्मिनल) से पास किए गए आर्गुमेंट्स की मनमानी संख्या स्वीकार करेगा। प्रोग्राम पास किए गए आर्गुमेंट्स और कुल आर्गुमेंट्स की संख्या प्रिंट करेगा।

उदाहरण के लिए, यदि आप python demo1.py abc 123 चलाते हैं, तो प्रोग्राम यह देगा -

Number of arguments: 3
Argument(s) passed: ['demo1.py', 'abc', '123']

ध्यान दें कि पहला आर्गुमेंट हमेशा Python फ़ाइल का नाम होता है। लेकिन कोड को इस तरह बदला जा सकता है कि यह उसे शामिल न करे।

अब कोड की ओर आते हैं -

import sys

print('Number of arguments: {}'.format(len(sys.argv)))
print('Argument(s) passed: {}'.format(str(sys.argv)))

आपने पहले Python मॉड्यूल sys को इम्पोर्ट किया, जो Python की मानक इंस्टॉलेशन के साथ आता है। फिर आपने argv सबमॉड्यूल का उपयोग किया जो Python स्क्रिप्ट को पास किए गए आर्गुमेंट्स की सूची लौटाता है, जहाँ argv[0] में Python स्क्रिप्ट का नाम होता है। यदि आप निम्न की तरह किसी कोड सेल में sys.argv चलाते हैं, तो आपको वे कॉन्फ़िगरेशन फाइलें दिखेंगी जो IPython कर्नेल को ठीक से काम कराने के लिए जिम्मेदार हैं। इनके साथ छेड़छाड़ न करना बेहतर है।

sys.argv

['/home/nbuser/anaconda3_501/lib/python3.6/site-packages/ipykernel/__main__.py',
 '-f',
 '/home/nbuser/.local/share/jupyter/runtime/kernel-dabba4f7-e3e0-4c39-99d2-261ba835c53f.json']

अब देखते हैं कि getopt मॉड्यूल का उपयोग आर्गुमेंट्स (और विकल्पों) को पार्स करने के लिए कैसे किया जाए।

getopt का उपयोग करके आर्गुमेंट पार्सिंग

sys.argv की तुलना में, getopt मॉड्यूल काफी अधिक लचीलापन प्रदान करता है। पहले एक नमूना परिदृश्य बनाते हैं और फिर उसी के अनुसार कोड लिखते हैं।

मान लीजिए, आपने एक Python स्क्रिप्ट रिलीज़ की है जिसकी आपने अभी तक डॉक्यूमेंटेशन नहीं लिखी है। लेकिन आप चाहते हैं कि यदि उपयोगकर्ता उस स्क्रिप्ट को गलत तरीके से चलाएँ, तो उन्हें सार्थक फीडबैक मिल सके। आपकी Python स्क्रिप्ट दो संख्याओं को जोड़ने का सरल कार्य करती है और आउटपुट देती है। एकमात्र शर्त यह है कि उपयोगकर्ता को इनपुट्स Python स्क्रिप्ट के साथ कमांड-लाइन आर्गुमेंट्स के रूप में पास करने होंगे।

ज्यादा व्यावहारिक रूप से कहें तो, स्क्रिप्ट आदर्श रूप से इस तरह चलाई जानी चाहिए -

python add_numbers.py -a 3 -b 8

आउटपुट 11 होना चाहिए। यहाँ -a और -b विकल्प हैं, और 3, 8 वे आर्गुमेंट्स हैं जो आप स्क्रिप्ट को देते हैं। विकल्प न सिर्फ पठनीयता बढ़ाते हैं बल्कि मूल्यांकन के प्रवाह को तय करने में भी मदद करते हैं (मान लें कि आप जोड़ने के बजाय भाग दे रहे हैं)। पहले इसका कोड देखते हैं।

import getopt
import sys

# Get the arguments from the command-line except the filename
argv = sys.argv[1:]
sum = 0

try:
    # Define the getopt parameters
    opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])
    # Check if the options' length is 2 (can be enhanced)
    if len(opts) == 0 and len(opts) > 2:
      print ('usage: add.py -a <first_operand> -b <second_operand>')
    else:
      # Iterate the options and get the corresponding values
      for opt, arg in opts:
         sum += int(arg)
      print('Sum is {}'.format(sum))

except getopt.GetoptError:
    # Print something useful
    print ('usage: add.py -a <first_operand> -b <second_operand>')
    sys.exit(2)

विचार यह है कि पहले sys.argv का उपयोग करके सभी आर्गुमेंट्स लिए जाएँ और फिर उन्हें उसी अनुसार प्रोसेस किया जाए। अब कोड की सबसे महत्वपूर्ण पंक्ति पर आते हैं - opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])

getopt() मेथड का सिग्नेचर इस प्रकार दिखता है:

getopt.getopt(args, shortopts, longopts=[])

• args कमांड-लाइन से लिए गए आर्गुमेंट्स की सूची है।
• shortopts वह जगह है जहाँ आप विकल्प अक्षर निर्दिष्ट करते हैं। यदि आप a: देते हैं, तो इसका मतलब है कि आपकी स्क्रिप्ट को विकल्प a के साथ एक मान बतौर आर्गुमेंट दिया जाना चाहिए। तकनीकी रूप से, आप यहाँ किसी भी संख्या में विकल्प उपयोग कर सकते हैं। जब आप इन विकल्पों को कमांड-लाइन से पास करते हैं, तो उन्हें '-' के साथ प्रीपेन्ड करना होता है।
• longopts वह जगह है जहाँ आप shortopts के विस्तृत संस्करण निर्दिष्ट कर सकते हैं। उन्हें '--' के साथ प्रीपेन्ड करना आवश्यक है।

आपने shortopts को a:b: परिभाषित किया है, जिसका अर्थ है कि आपकी Python स्क्रिप्ट दो विकल्प अक्षर लेगी - 'a' और 'b'। ':' निर्दिष्ट करके, आप स्पष्ट रूप से बता रहे हैं कि इन विकल्पों के बाद आर्गुमेंट्स आएँगे।

आपने longopts को ['foperand', 'soperand'] परिभाषित किया है, जो कोड को यह बताने का तरीका है कि a और b की जगह f_operand और s_operand को विकल्प के रूप में स्वीकार किया जाए। लेकिन इनके आगे हमेशा -- आना चाहिए।

getopt मॉड्यूल आपको एक सुविधाजनक Exception क्लास GetoptError भी देता है, ताकि आप उपयोगी संदेश परिभाषित कर सकें और उपयोगकर्ता को आपकी Python स्क्रिप्ट का उपयोग कैसे करना है, इस बारे में मार्गदर्शन दे सकें। यही वजह है कि आपने अपनी स्क्रिप्ट के क्रियात्मक भाग को try ब्लॉक में रखा और उसके अनुरूप except ब्लॉक परिभाषित किया।

यहाँ बताया गया है कि आप Python स्क्रिप्ट कैसे चला सकते हैं:

नोट कि ऊपर दी गई स्क्रिप्ट को longopts संभालने के लिए परिभाषित नहीं किया गया था। यह आप अभ्यास के रूप में आज़मा सकते हैं।

अब देखते हैं कि आर्गुमेंट पार्सिंग के लिए argparse का उपयोग कैसे करें।

argparse का उपयोग करके आर्गुमेंट पार्सिंग

ऊपर दिए गए दोनों विकल्पों से यह स्पष्ट है कि वे बहुत पठनीय नहीं हैं। एक बार जब आप argparse को क्रिया में देखेंगे, तो आप सहमत होंगे कि लचीलेपन के लिहाज़ से भी वे पिछड़ते हैं। argparse के उपयोग को समझने के लिए, आइए एक कोड स्निपेट से शुरू करें जो ऊपर वाले सेक्शन के परिदृश्य को लागू करता है।

import argparse

# Construct the argument parser
ap = argparse.ArgumentParser()

# Add the arguments to the parser
ap.add_argument("-a", "--foperand", required=True,
   help="first operand")
ap.add_argument("-b", "--soperand", required=True,
   help="second operand")
args = vars(ap.parse_args())

# Calculate the sum
print("Sum is {}".format(int(args['foperand']) + int(args['soperand'])))

सबसे पहले, argparse भी, ऊपर चर्चा किए गए अन्य दो मॉड्यूल्स की तरह, Python की मानक इंस्टॉलेशन के साथ आता है। आप argparse ऑब्जेक्ट को इंस्टेंशिएट करके शुरू करते हैं। और बाकी चीज़ें लिखना काफी सरल हो जाता है। उदाहरण के लिए, निम्न पंक्ति पर ध्यान दें -

ap.add_argument("-a", "--foperand", required=True, help="first operand")

यहाँ आपने वह आर्गुमेंट जोड़ा है जिसकी आप अपेक्षा करते हैं कि Python स्क्रिप्ट चलाते समय दिया जाए। आपने आर्गुमेंट का अक्षर-वाला संस्करण और उसका विस्तृत संस्करण दोनों प्रदान किए। required=True निर्दिष्ट करके आप उपयोगकर्ता से स्पष्ट कह रहे हैं कि वह विशेष आर्गुमेंट देना अनिवार्य है। अंत में, आपने आर्गुमेंट का अर्थपूर्ण विवरण जोड़ा है जो उपयोगकर्ता को तब दिखेगा जब वह स्क्रिप्ट को सही तरीके से निष्पादित नहीं करेगा।

दूसरे आर्गुमेंट के लिए भी परिभाषा का भाग यही है। आप दिए गए आर्गुमेंट्स को उनके संबंधित इंडेक्स के माध्यम से एक्सेस करते हैं।

ऊपर दिया गया कोड-स्निपेट साफ़ दिखाता है कि argparse के साथ कमांड-लाइन आर्गुमेंट पार्सिंग कार्यों को परिभाषित करना कितना आसान और लचीला है। यहाँ बताया गया है कि आप ऊपर वाली Python स्क्रिप्ट के साथ कैसे प्रयोग कर सकते हैं:

ध्यान दें कि argparse के साथ प्रक्रिया कितनी आसान हो गई।

आगे क्या?

आज का ट्यूटोरियल अंत तक पढ़ने के लिए धन्यवाद। अब, आप उन नेटिव Python मॉड्यूल्स से लैस हैं जो कमांड-लाइन से आपकी Python स्क्रिप्ट के साथ पास किए गए आर्गुमेंट्स को पार्स करने में सक्षम हैं। अभ्यास के तौर पर, आप अपने मशीन लर्निंग और डेटा साइंस प्रोजेक्ट्स को इस तरह कस्टमाइज़ कर सकते हैं कि आर्गुमेंट पार्सिंग आसान हो और वे उपयोगी स्क्रिप्ट यूटिलिटीज़ बन जाएँ। सिर्फ मशीन लर्निंग या डेटा साइंस ही नहीं, बल्कि जहाँ भी आपको यह प्रासंगिक लगे। आज के ट्यूटोरियल के लिए बस इतना ही। यदि आप अपनी Python स्किल्स को और निखारने में रुचि रखते हैं, तो आप DataCamp का Python Data Science Toolbox (Part 1) कोर्स लेना चाहेंगे।