पायथन में कमांड लाइन तर्क

अवलोकन

पाइथन एक बहुत ही लोकप्रिय प्रोग्रामिंग भाषा होने के साथ-साथ अधिकांश ऑपरेटिंग सिस्टम और कई पुस्तकालयों के लिए समर्थन है जो कमांड-लाइन तर्क प्रसंस्करण को आसान बनाते हैं - इसका उपयोग कई उद्देश्यों के लिए कमांड लाइन टूल बनाने के लिए व्यापक रूप से किया जाता है। ये उपकरण सरल सीएलआई ऐप्स से लेकर अधिक जटिल ऐप्स तक हो सकते हैं, जैसे AWS' awscli उपकरण.

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

सामान्य तौर पर, आपके ऑपरेटिंग सिस्टम के आधार पर, सीएलआई टूल को तर्क अलग-अलग तरीके से दिए जाते हैं:

• यूनिक्स की तरह: - उसके बाद एक पत्र, जैसे -hया, -- उसके बाद एक शब्द, जैसे --help
• Windows: / उसके बाद या तो कोई अक्षर, या शब्द, जैसे /help

ये विभिन्न दृष्टिकोण ऐतिहासिक कारणों से मौजूद हैं। यूनिक्स जैसी प्रणालियों पर कई प्रोग्राम सिंगल और डबल डैश नोटेशन दोनों का समर्थन करते हैं। सिंगल डैश नोटेशन का उपयोग ज्यादातर एकल अक्षर विकल्पों के साथ किया जाता है, जबकि डबल डैश अधिक पठनीय विकल्प सूची प्रस्तुत करता है, जो विशेष रूप से जटिल विकल्पों के लिए उपयोगी है जिन्हें अधिक स्पष्ट होने की आवश्यकता है।

ध्यान रखें कि किसी तर्क का नाम और अर्थ दोनों ही किसी कार्यक्रम के लिए विशिष्ट होते हैं - कुछ सामान्य परंपराओं के अलावा, इसकी कोई सामान्य परिभाषा नहीं है जैसे --help टूल के उपयोग के बारे में अधिक जानकारी के लिए। पायथन स्क्रिप्ट के डेवलपर के रूप में, आप तय करेंगे कि कॉल करने वाले को कौन से तर्क प्रदान करने हैं और वे क्या करते हैं। इसके लिए उचित मूल्यांकन की आवश्यकता है।

जैसे-जैसे आपके उपलब्ध तर्कों की सूची बढ़ती जाएगी, आपका कोड उन्हें सटीक रूप से पार्स करने की कोशिश में और अधिक जटिल होता जाएगा। सौभाग्य से, पायथन में इसमें आपकी सहायता के लिए कई पुस्तकालय उपलब्ध हैं। हम कुछ सबसे आम समाधानों को कवर करेंगे, जो "इसे स्वयं करें" से लेकर हैं sys.argv, "आपके लिए किया गया" दृष्टिकोण के साथ argparse.

पायथन के साथ कमांड लाइन तर्कों को संभालना

पायथन 3+ और आसपास का पारिस्थितिकी तंत्र कमांड लाइन तर्कों को संभालने के कई अलग-अलग तरीकों का समर्थन करता है। वहाँ हैं बहुत पुस्तकालय जो पार्सिंग कमांड-लाइन तर्कों को आकर्षक बनाते हैं।

अंतर्निहित तरीका का उपयोग करना है sys मापांक। नाम और इसके उपयोग के संदर्भ में, यह सीधे सी लाइब्रेरी से संबंधित है (libc).

दूसरा तरीका है getopt मॉड्यूल, जो पैरामीटर मानों के मूल्यांकन सहित छोटे और लंबे दोनों विकल्पों को संभालता है।

RSI argparse मॉड्यूल, जो से प्राप्त होता है optparse मॉड्यूल (पायथन 2.7 तक उपलब्ध)।

RSI docopt मॉड्यूल, जो है गिटहब पर उपलब्ध, समान कार्यक्षमता की भी अनुमति देता है।

हाल ही में, absl प्रतिस्थापन के साधन के रूप में पुस्तकालय भी लोकप्रियता हासिल कर रहा है optparse और getopt().

इनमें से प्रत्येक तरीके के अपने फायदे और नुकसान हैं, इसलिए यह देखने के लिए प्रत्येक का मूल्यांकन करना उचित है कि कौन सा आपकी आवश्यकताओं के लिए सबसे उपयुक्त है।

सिस मॉड्यूल

यह एक बुनियादी मॉड्यूल है जिसे शुरुआती दिनों से पायथन के साथ भेजा गया है। यह सी लाइब्रेरी के उपयोग के समान ही दृष्टिकोण अपनाता है argc/argv तर्कों तक पहुँचने के लिए। sys मॉड्यूल नाम की एक सरल सूची संरचना में कमांड लाइन तर्क लागू करता है sys.argv.

प्रत्येक सूची तत्व एक एकल तर्क का प्रतिनिधित्व करता है। सूची में पहला आइटम, sys.argv[0], पायथन लिपि का नाम है। सूची के शेष तत्व, sys.argv[1] सेवा मेरे sys.argv[n], कमांड लाइन तर्क 2 से n तक हैं।

तर्कों के बीच सीमांकक के रूप में, एक रिक्त स्थान का उपयोग किया जाता है। जिन तर्क मानों में एक स्थान होता है उन्हें ठीक से पार्स करने के लिए उद्धरण चिह्नों से घिरा होना चाहिए sys.

के समकक्ष argc यह सूची में केवल तत्वों की संख्या है। इस मान को प्राप्त करने के लिए, पायथन का उपयोग करें len() ऑपरेटर। हम इसे बाद में एक कोड उदाहरण में दिखाएंगे।

पहला सीएलआई तर्क मुद्रित करना

इस पहले उदाहरण में, हमारी स्क्रिप्ट यह निर्धारित करेगी कि इसे किस प्रकार बुलाया गया था। यह जानकारी पहले कमांड लाइन तर्क में रखी जाती है, जिसे 0 के साथ अनुक्रमित किया जाता है। नीचे दिया गया कोड दिखाता है कि आप अपनी पायथन स्क्रिप्ट का नाम कैसे प्राप्त करते हैं:

import sys

print("The script has the name %s" % (sys.argv[0])

इस कोड को नाम की फ़ाइल में सेव करें arguments-program-name.py, और फिर इसे नीचे दिखाए अनुसार कॉल करें। आउटपुट इस प्रकार है और इसमें फ़ाइल का नाम, उसका पूरा पथ शामिल है:

$ python arguments-program-name.py
The script has the name arguments-program-name.py
$ python /home/user/arguments-program-name.py
The script has the name /home/user/arguments-program-name.py

जैसा कि आप ऊपर दूसरी कॉल से देख सकते हैं, हमें न केवल पायथन फ़ाइल का नाम मिलता है, बल्कि इसे कॉल करने के लिए उपयोग किया जाने वाला पूरा पथ भी मिलता है।

तर्कों की संख्या गिनना

इस दूसरे उदाहरण में हम बस बिल्ट-इन का उपयोग करके कमांड लाइन तर्कों की संख्या की गणना करते हैं len() विधि. sys.argv यह वह सूची है जिसकी हमें जांच करनी है। नीचे दिए गए कोड में, हमें तर्कों की संख्या मिलती है और फिर 1 घटाते हैं क्योंकि उन तर्कों में से एक (यानी पहला वाला) हमेशा फ़ाइल के नाम के रूप में सेट होता है, जो हमेशा हमारे लिए उपयोगी नहीं होता है। इस प्रकार, उपयोगकर्ता द्वारा पारित तर्कों की वास्तविक संख्या है len(sys.argv) - 1:

import sys


arguments = len(sys.argv) - 1
print ("The script is called with %i arguments" % (arguments))

इस फ़ाइल को सहेजें और नाम दें-auguments-count.py. इस स्क्रिप्ट को कॉल करने के कुछ उदाहरण नीचे दिखाए गए हैं। इसमें तीन अलग-अलग परिदृश्य शामिल हैं:

• बिना किसी अतिरिक्त कमांड लाइन तर्क के एक कॉल
• दो तर्कों के साथ एक कॉल
• दो तर्कों के साथ एक कॉल, जहां दूसरा एक उद्धृत स्ट्रिंग है जिसमें एक स्थान है

$ python arguments-count.py
The script is called with 0 arguments
$ python arguments-count.py --help me
The script is called with 2 arguments
$ python arguments-count.py --option "long string"
The script is called with 2 arguments

तर्कों के माध्यम से पुनरावृत्ति

हमारा तीसरा उदाहरण प्रोग्राम नाम को छोड़कर, पायथन स्क्रिप्ट में भेजे गए हर एक तर्क को आउटपुट करता है। इसलिए, हम कमांड लाइन तर्कों के माध्यम से लूप शुरू करते हैं दूसरा सूची तत्व. याद रखें कि यह सूचकांक 1 है क्योंकि पायथन में सूचियाँ 0-आधारित हैं:

import sys


arguments = len(sys.argv) - 1


position = 1
while (arguments >= position):
    print ("Parameter %i: %s" % (position, sys.argv[position]))
    position = position + 1

नीचे हम अपने कोड को कॉल करते हैं, जो तर्क-आउटपुट.py फ़ाइल में सहेजा गया था। जैसा कि हमारे पिछले उदाहरण में किया गया था, आउटपुट तीन अलग-अलग कॉल दिखाता है:

• बिना किसी बहस के एक कॉल
• दो तर्कों के साथ एक कॉल
• दो तर्कों के साथ एक कॉल, जहां दूसरा तर्क एक उद्धृत स्ट्रिंग है जिसमें एक स्थान है

$ python arguments-output.py
$ python arguments-output.py --help me
Parameter 1: --help
Parameter 2: me
$ python arguments-output.py --option "long string"
Parameter 1: --option
Parameter 2: long string

याद रखें, उद्धृत स्ट्रिंग उदाहरण दिखाने का मुद्दा यह है कि पैरामीटर आमतौर पर एक स्थान द्वारा सीमांकित होते हैं, जब तक वे उद्धरणों से घिरे हुए हैं।

एब्सिल झंडे (absl)

एब्सिल की फ़्लैग्स लाइब्रेरी का उद्देश्य वितरित कमांड लाइन तर्कों के साथ कमांड लाइन तर्कों को उत्पादन में लाना है। जब एक मॉड्यूल कमांड-लाइन झंडे का उपयोग करता है, और दूसरे मॉड्यूल में आयात किया जाता है - दूसरा मॉड्यूल झंडे भी आयात करता है, और उन्हें आयातित मॉड्यूल पर अग्रेषित करके संसाधित कर सकते हैं।

यह मॉड्यूल के बीच साझा किए जाने वाले जटिल कमांड-लाइन तर्कों को आसान और कम क्रियात्मक बनाता है।

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

from absl import flags
import sys


flags.DEFINE_string('name', 'User', 'The name of the user.')


FLAGS = flags.FLAGS
FLAGS(sys.argv)

print(f"Hello {FLAGS.name}!")

समर्थित डेटा प्रकार हैं:

• DEFINE_integer()
• DEFINE_string()
• DEFINE_bool()
• DEFINE_enum()
• DEFINE_list()
• DEFINE_float()

साथ ही साथ DEFINE_multi_integer(), DEFINE_multi_string() और DEFINE_multi_enum() बहु-तर्क इनपुट के लिए. इसके अतिरिक्त, चल रहा है --help, --helpfull, आदि मौजूदा झंडों और उनके विवरणों को विभिन्न स्वरूपों में प्रिंट करते हैं।

लाइब्रेरी आपको सत्यापन को परिभाषित करने की भी अनुमति देती है - दोनों रेंज के संदर्भ में, जैसे कि पूर्णांक-आधारित मान upper_bound or lower_bound यह स्वीकार्य है, और मानों की जांच के लिए मनमाने तरीके चला रहा है:

def validate_name(value):
    return len(value) > 15

flags.register_validator('name',
                         validate_name,
                         message='Name is over 15 characters long.',
                         flag_values=FLAGS)

इन्हें एक ठोस उदाहरण में एकत्रित करना:

from absl import flags
import sys

flags.DEFINE_string('name', 'User', 'The name of the user.')
flags.DEFINE_integer('tasks', 0, 'The number of tasks a user has.', lower_bound=0)

FLAGS = flags.FLAGS
FLAGS(sys.argv)

print(f"{FLAGS.name} has {FLAGS.tasks} tasks to work on.")

$ python flags.py --name=John --tasks=5
John has 5 tasks to work on.

$ python flags.py --name=John --tasks=-1

Traceback (most recent call last):
  File "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/absl/flags/_flag.py", line 180, in _parse
    return self.parser.parse(argument)
  File "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/absl/flags/_argument_parser.py", line 168, in parse
    raise ValueError('%s is not %s' % (val, self.syntactic_help))
ValueError: -1 is not a non-negative integer
...

आर्गपर्स मॉड्यूल

RSI argparse मॉड्यूल पायथन 3.2 के बाद से उपलब्ध है, और इसका एक संवर्द्धन optparse मॉड्यूल जो Python 2.7 तक मौजूद है। पायथन दस्तावेज़ में एक एपीआई विवरण और एक ट्यूटोरियल शामिल है जो सभी विधियों को विस्तार से कवर करता है।

मॉड्यूल एक मानकीकृत आउटपुट के साथ एक कमांड लाइन इंटरफ़ेस प्रदान करता है, जबकि पहले के दो समाधान आपके हाथों में अधिकांश काम छोड़ देते हैं। argparse छोटी या लंबी शैली के रूप में नाम की जाँच के साथ, निश्चित और वैकल्पिक तर्कों के सत्यापन की अनुमति देता है। डिफ़ॉल्ट वैकल्पिक तर्क के रूप में, इसमें शामिल है -h, इसके लंबे संस्करण के साथ --help. इस तर्क के साथ स्वीकृत तर्कों का वर्णन करने वाला एक डिफ़ॉल्ट सहायता संदेश भी है।

नीचे दिया गया कोड पार्सर आरंभीकरण दिखाता है, और उसके नीचे का आउटपुट मूल कॉल दिखाता है, उसके बाद सहायता संदेश दिखाता है। पिछले उदाहरणों में हमारे द्वारा उपयोग किए गए पायथन कॉल के विपरीत, इन उदाहरणों के साथ पायथन 3 का उपयोग करना याद रखें:

import argparse


parser = argparse.ArgumentParser()
parser.parse_args()

$ python3 arguments-argparse-basic.py 
$ python3 arguments-argparse-basic.py -h
usage: arguments-argparse-basic.py [-h]

optional arguments:
  -h, --help  show this help message and exit
$ python3 arguments-argparse-basic.py --verbose
usage: arguments-argparse-basic.py [-h]
arguments-argparse-basic.py: error: unrecognized arguments: --verbose

अगले चरण में, हम अपने उपयोगकर्ताओं के लिए सहायता संदेश में एक कस्टम विवरण जोड़ेंगे। इस तरह से पार्सर को आरंभ करने से एक अतिरिक्त पाठ की अनुमति मिलती है। नीचे दिया गया कोड विवरण को संग्रहीत करता है text वेरिएबल, जो स्पष्ट रूप से दिया गया है argparse वर्ग के रूप में description पैरामीटर. नीचे दिए गए इस कोड को कॉल करके, आप देख सकते हैं कि आउटपुट कैसा दिखता है:

import argparse


text = 'This is a test program. It demonstrates how to use the argparse module with a program description.'


parser = argparse.ArgumentParser(description=text)
parser.parse_args()

$ python3 arguments-argparse-description.py --help
usage: arguments-argparse-description.py [-h]

This is a test program. It demonstrates how to use the argparse module with a
program description.

optional arguments:
  -h, --help  show this help message and exit

अंतिम चरण के रूप में हम नाम का एक वैकल्पिक तर्क जोड़ेंगे -V, जिसका नाम एक संगत लंबी शैली तर्क है --version. ऐसा करने के लिए हम विधि का उपयोग करते हैं add_argument() जिसे हम तीन मापदंडों के साथ कॉल करते हैं (के लिए प्रदर्शित)। --version, केवल):

• पैरामीटर का नाम: --version
• पैरामीटर के लिए सहायता पाठ: help="show program version"
• क्रिया (अतिरिक्त मूल्य के बिना): action="store_true"

उसके लिए स्रोत कोड नीचे प्रदर्शित किया गया है। वेरिएबल में तर्कों को पढ़ना कहा जाता है args के माध्यम से किया जाता है parse_args() से विधि parser वस्तु। ध्यान दें कि आप एक ही कॉल में लघु और दीर्घ दोनों संस्करण सबमिट करें। अंत में, आप जांचें कि क्या विशेषताएँ हैं args.V or args.version संस्करण संदेश सेट और आउटपुट किया जाता है:

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("-V", "--version", help="show program version", action="store_true")


args = parser.parse_args()


if args.version:
    print("This is myprogram version 0.1")

$ python3 arguments-argparse-optional.py -V
This is myprogram version 0.1
$ python3 arguments-argparse-optional.py --version
This is myprogram version 0.1

RSI --version तर्क के लिए कमांड लाइन पर कोई मान देने की आवश्यकता नहीं है। इसीलिए हमने कार्रवाई तर्क को सेट किया है "store_true". अन्य मामलों में आपको अतिरिक्त निर्दिष्ट मान की आवश्यकता हो सकती है, उदाहरण के लिए यदि आप एक निश्चित मात्रा, ऊंचाई या चौड़ाई निर्दिष्ट करते हैं। इसे अगले उदाहरण में दिखाया गया है. डिफ़ॉल्ट मामले के रूप में, कृपया ध्यान दें कि सभी तर्कों की व्याख्या स्ट्रिंग के रूप में की जाती है:

import argparse


parser = argparse.ArgumentParser()


parser.add_argument("--width", "-w", help="set output width")


args = parser.parse_args()


if args.width:
    print("Set output width to %s" % args.width)

यहां हम दिखाते हैं कि विभिन्न तर्क मान सबमिट करने पर क्या होता है। इसमें लघु और दीर्घ दोनों संस्करण, साथ ही सहायता संदेश भी शामिल है:

$ python3 arguments-argparse-optional2.py -w 10
Set output width to 10
$ python3 arguments-argparse-optional2.py --width 10
Set output width to 10
$ python3 arguments-argparse-optional2.py -h
usage: arguments-argparse-optional2.py [-h] [--width WIDTH]

optional arguments:
  -h, --help            show this help message and exit
  --width WIDTH, -w WIDTH
                        set output width

गेटऑप्ट मॉड्यूल

जैसा कि आपने पहले देखा होगा, sys मॉड्यूल कमांड लाइन स्ट्रिंग को केवल एकल पहलुओं में विभाजित करता है। अजगर getopt मॉड्यूल थोड़ा आगे बढ़ता है और पैरामीटर सत्यापन द्वारा इनपुट स्ट्रिंग के पृथक्करण को बढ़ाता है। पर आधारित getopt सी फ़ंक्शन, यह मान असाइनमेंट सहित छोटे और लंबे दोनों विकल्पों की अनुमति देता है।

व्यवहार में, इसकी आवश्यकता होती है sys इनपुट डेटा को ठीक से संसाधित करने के लिए मॉड्यूल। ऐसा करने के लिए, दोनों sys मॉड्यूल और getopt मॉड्यूल को पहले से लोड करना होगा। इसके बाद, इनपुट मापदंडों की सूची से हम पहले सूची तत्व को हटाते हैं (नीचे कोड देखें), और कमांड लाइन तर्कों की शेष सूची को वेरिएबल में संग्रहीत करते हैं जिसे कहा जाता है argument_list:

import getopt, sys


full_cmd_arguments = sys.argv


argument_list = full_cmd_arguments[1:]

print argument_list

में तर्क argument_list अब का उपयोग करके पार्स किया जा सकता है getopts() तरीका। लेकिन ऐसा करने से पहले हमें ये बताना होगा getopts() कौन से पैरामीटर मान्य हैं इसके बारे में। इन्हें इस प्रकार परिभाषित किया गया है:

short_options = "ho:v"
long_options = ["help", "output=", "verbose"]

इसका मतलब यह है कि ये तर्क वे हैं जिन्हें हम कुछ अतिरिक्त जानकारी के साथ मान्य मानते हैं:

------------------------------------------
long argument   short argument  with value
------------------------------------------
--help           -h              no
--output         -o              yes
--verbose        -v              no
------------------------------------------

आपने देखा होगा कि o लघु विकल्प को कोलन द्वारा आगे बढ़ाया गया था, :। इससे पता getopt कि इस विकल्प को एक मान निर्दिष्ट किया जाना चाहिए।

यह अब हमें तर्कों की एक सूची संसाधित करने की अनुमति देता है। getopt() विधि को कॉन्फ़िगर करने के लिए तीन पैरामीटर की आवश्यकता होती है - वास्तविक तर्कों की सूची argv, साथ ही वैध छोटे और लंबे दोनों विकल्प (पिछले कोड स्निपेट में दिखाए गए हैं)।

मूल्यांकन के दौरान त्रुटियों को कवर करने के लिए विधि कॉल को ट्राइ-कैच-स्टेटमेंट में रखा जाता है। यदि कोई ऐसा तर्क खोजा जाता है जो पहले परिभाषित सूची का हिस्सा नहीं है तो एक अपवाद उठाया जाता है। पायथन स्क्रिप्ट स्क्रीन पर त्रुटि संदेश प्रिंट करेगी, और त्रुटि कोड 2 के साथ बाहर निकलेगी:

try:
    arguments, values = getopt.getopt(argument_list, short_options, long_options)
except getopt.error as err:
    
    print (str(err))
    sys.exit(2)

अंत में, संबंधित मानों वाले तर्कों को नामित दो चरों में संग्रहीत किया जाता है arguments और values. अब, आप अपने कोड में इन वेरिएबल्स का आसानी से मूल्यांकन कर सकते हैं। हम एक का उपयोग कर सकते हैं for-मान्यता प्राप्त तर्कों की सूची के माध्यम से पुनरावृत्त करने के लिए लूप, एक के बाद एक प्रविष्टि।

for current_argument, current_value in arguments:
    if current_argument in ("-v", "--verbose"):
        print ("Enabling verbose mode")
    elif current_argument in ("-h", "--help"):
        print ("Displaying help")
    elif current_argument in ("-o", "--output"):
        print (("Enabling special output mode (%s)") % (current_value))

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

$ python arguments-getopt.py -h
Displaying help
$ python arguments-getopt.py --help
Displaying help
$ python arguments-getopt.py --output=green --help -v
Enabling special output mode (green)
Displaying help
Enabling verbose mode
$ python arguments-getopt.py -verbose
option -e not recognized

हमारे कार्यक्रम की अंतिम कॉल पहली बार में थोड़ी भ्रमित करने वाली लग सकती है। इसे समझने के लिए, आपको यह जानना होगा कि शॉर्टहैंड विकल्प (कभी-कभी फ़्लैग भी कहा जाता है) का उपयोग एक ही डैश के साथ किया जा सकता है। यह आपके टूल को कई विकल्पों को अधिक आसानी से स्वीकार करने की अनुमति देता है। उदाहरण के लिए, कॉल करना python arguments-getopt.py -vh कॉल करने के समान ही है python arguments-getopt.py -v -h. तो उपरोक्त अंतिम कॉल में, getopt मॉड्यूल ने सोचा कि उपयोगकर्ता पास होने का प्रयास कर रहा है -e एक विकल्प के रूप में, जो अमान्य है।

निष्कर्ष

इस लेख में हमने पायथन में कमांड लाइन तर्कों को पुनः प्राप्त करने के लिए कई अलग-अलग तरीके दिखाए हैं, जिनमें इसका उपयोग भी शामिल है sys, getopt, तथा argparse. ये मॉड्यूल कार्यक्षमता में भिन्न होते हैं, कुछ दूसरों की तुलना में बहुत अधिक प्रदान करते हैं। sys पूरी तरह से लचीला है, जबकि दोनों getoptऔर argparse कुछ संरचना की आवश्यकता है. इसके विपरीत, वे अधिकांश जटिल कार्यों को कवर करते हैं sys आप पर निर्भर करता है. दिए गए उदाहरणों पर काम करने के बाद, आपको यह निर्धारित करने में सक्षम होना चाहिए कि कौन सा मॉड्यूल आपके प्रोजेक्ट के लिए सबसे उपयुक्त है।

इस लेख में हमने जैसे अन्य समाधानों के बारे में बात नहीं की docopts मॉड्यूल, हमने अभी इसका उल्लेख किया है। यह मॉड्यूल पूरी तरह से अलग दृष्टिकोण का पालन करता है, और अगले लेखों में से एक में विस्तार से बताया जाएगा।

संदर्भ