पायथन 2.7 के साथ शुरू, कमांड लाइन तर्क (मापदंडों, कुंजियों) को संभालने के लिए मानक लाइब्रेरी के सेट में अर्गपर्स लाइब्रेरी को शामिल किया गया है। मैं आपका ध्यान इस पर रोकना चाहूंगा।
आरंभ करने के लिए, इस बात पर विचार करें कि अर्गपर्स को क्या पेशकश करनी है।
Argparse एक सुरुचिपूर्ण उपकरण है:
- पार्सिंग sys.argv तर्क
- अपने कार्यक्रम की वस्तुओं और उनके साथ काम करने के लिए स्ट्रिंग तर्क परिवर्तित करना;
- सूचनात्मक संकेतों को प्रारूपित करना और प्रदर्शित करना;
- बहुत अधिक।
पायथन में अर्ग्पैरस को शामिल करने के विरोधियों के तर्कों में से एक तर्क था कि मानक मॉड्यूल यहां तक कि कमांड लाइन मापदंडों के शब्दार्थ प्रसंस्करण (पार्सिंग) के लिए दो पुस्तकालय होते हैं। हालाँकि, argparse डेवलपर्स का दावा है कि कई कारणों से गेटअप और ऑप्टपर्स argparse से हीन हैं:
- सामान्य कमांड लाइन मापदंडों के साथ कार्यों की सभी पूर्णता रखते हुए, वे स्थिति संबंधी तर्कों को संसाधित करने में सक्षम नहीं हैं। स्थिति संबंधी तर्क वे तर्क हैं जो कार्यक्रम के संचालन को प्रभावित करते हैं, इस आदेश के आधार पर कि वे इस कार्यक्रम में स्थानांतरित किए जाते हैं। सबसे सरल उदाहरण एक cp प्रोग्राम है जिसमें कम से कम 2 ऐसे तर्क ("cp source गंतव्य") हैं ।
- argparse न्यूनतम लागत के साथ आउटपुट पर बेहतर संकेत संदेश देता है (इस संबंध में, ऑप्टपर्स के साथ काम करते समय, आप अक्सर कोड के कुछ अतिरेक का निरीक्षण कर सकते हैं);
- argparse प्रोग्रामर को अपने लिए सेट करने की अनुमति देता है कि कौन से अक्षर पैरामीटर हैं और कौन से नहीं हैं। इसके विपरीत, ऑप्टपर्स सिंटैक्स जैसे "-पीएफ, -फाइल, + आरजीबी, / एफ," "आंतरिक रूप से असंगत" और "ऑप्टपर्स द्वारा समर्थित नहीं है और कभी नहीं होगा" जैसे विकल्पों पर विचार करता है;
- argparse आपको एक कमांड लाइन तर्क (नर्ग) के लिए कई चर मानों का उपयोग करने में सक्षम करेगा;
- argparse उपकमांड का समर्थन करता है। यह तब होता है जब इनपुट तर्कों के आधार पर मुख्य पार्सर दूसरे (उप-पार्सर) को संदर्भित करता है।
अर्गपर्स के साथ काम करना शुरू करने के लिए, आपको एक पार्सर निर्दिष्ट करना होगा:
ap.py: import argparse parser = argparse.ArgumentParser(description='Great Description To Be Here')
इसके अलावा, पार्सर को इंगित करना चाहिए कि आप किन वस्तुओं से इसकी उम्मीद करते हैं। किसी विशेष मामले में, ऐसा लग सकता है:
parser.add_argument('-n', action='store', dest='n', help='Simple value')
यदि इस तर्क के लिए कोई कार्रवाई निर्दिष्ट नहीं है, तो डिफ़ॉल्ट रूप से इसे नेमस्पेस में संग्रहीत (स्टोर) किया जाएगा, और हम इस तर्क के प्रकार (इंट, बूलियन, आदि) को भी निर्दिष्ट कर सकते हैं। यदि वापसी तर्क (भाग्य) का नाम निर्दिष्ट किया गया है, तो इसका मान संबंधित नामस्थान विशेषता में संग्रहीत किया जाएगा।
हमारे मामले में:
print parser.parse_args(['-n', '3']) Namespace(n='3') print parser.parse_args([]) Namespace(n=None) print parser.parse_args(['-a', '3']) error: unrecognized arguments: -a 3
वैकल्पिक तर्क (-v) के आधार पर एक स्थितीय तर्क (वर्ग) के मान को उत्पन्न करने और आउटपुट उत्पन्न करने वाले कार्यक्रम का एक सरल उदाहरण:
import argparse parser = argparse.ArgumentParser() parser.add_argument("square", type=int, help="display a square of a given number") parser.add_argument("-v", "--verbose", action="store_true", help="increase output verbosity") args = parser.parse_args() answer = args.square**2 if args.verbose: print("the square of {} equals {}".format(args.square, answer)) else: print(answer)
हमें कर्मों पर ध्यान देना चाहिए। वे इस प्रकार हो सकते हैं:
- स्टोर: नेमस्पेस (एक वैकल्पिक प्रकार के बाद) में एक मान लौटाता है। जैसा कि पहले ही उल्लेख किया गया है, स्टोर डिफ़ॉल्ट क्रिया है;
- store_const: मुख्य रूप से झंडे के लिए उपयोग किया जाता है। यह या तो const में निर्दिष्ट मान लौटाएगा, या (यदि कुछ भी निर्दिष्ट नहीं है), कोई नहीं। एक उदाहरण:
parser.add_argument('--LifetheUniverseandEverything', action='store_const', const=42) print parser.parse_args(['--LifetheUniverseandEverything']) Namespace(LifetheUniverseandEverything=42)
- store_true / store_false: store_const का एनालॉग, लेकिन बूलियन ट्रू और गलत के लिए;
- परिशिष्ट: इसमें तर्क मान जोड़कर एक सूची लौटाता है। एक उदाहरण:
parser.add_argument('--l', action='append') print parser.parse_args('--la --lb --l Y'.split()) Namespace(l=['abY'])
- append_const: सूची में तर्क विनिर्देश में निर्दिष्ट मान
लौटाएं । अभी तक मेरे पास ऐसा मामला नहीं है जिसमें अपेंडेंट_कॉन्स्ट की जरूरत होगी।
- गिनती: जैसा कि नाम से ही स्पष्ट है कि इस तर्क का मूल्य कितनी बार आता है। एक उदाहरण:
parser.add_argument('--verbose', '-v', action='count') print parser.parse_args('-vvv'.split()) Namespace(verbose=3)
Parser के कंस्ट्रक्टर में दिए गए तर्क add_help (बूलियन प्रकार) के आधार पर, यह निर्धारित किया जाएगा कि कुंजियों द्वारा मानक आउटपुट में संदेशों को शामिल किया जाए या नहीं ['-h', '--help']। तर्क संस्करण (स्ट्रिंग प्रकार) के साथ भी ऐसा ही होगा, डिफ़ॉल्ट कुंजी हैं: ['-v', '--version']। मदद या संस्करण संख्या का अनुरोध करते समय, आगे निष्पादन बाधित होता है।
parser = argparse.ArgumentParser(add_help=True, version='4.0')
कभी-कभी कमांड लाइन मापदंडों के एक निश्चित सेट को परिभाषित करना आवश्यक होता है जो आपके प्रोग्राम के सभी पार्सर्स पर लागू होगा। इस मामले में, वे अक्सर प्राधिकरण की आवश्यकता का एक उदाहरण देते हैं:
parent_parser = argparse.ArgumentParser(add_help=False) parent_parser.add_argument('--user', action="store") parent_parser.add_argument('--password', action="store") child_parser = argparse.ArgumentParser(parents=[parent_parser]) child_parser.add_argument('--show_all', action="store_true") print child_parser.parse_args(['--user', 'guest']) Namespace(password=None, show_all=False, user='guest')
ध्यान दें कि पैरेंट पार्सर add_help = गलत पैरामीटर के साथ बनाया गया है। ऐसा इसलिए है क्योंकि प्रत्येक पार्सर ईमानदारी से अपने स्वयं के '-h' कुंजी हैंडलर को जोड़ने का प्रयास करेगा, जो संघर्ष की स्थिति पैदा करेगा। यह इस सवाल का जवाब देता है कि क्या करें यदि आपके बच्चे के पार्सर में माता-पिता के समान चाबियां हैं और आप उन्हें बिना किसी संघर्ष के उपयोग करना चाहते हैं? यह केवल तर्क परस्पर विरोधी_हैंडलर को जोड़कर किया जाता है:
parent_parser = argparse.ArgumentParser(add_help=False) parent_parser.add_argument('--user', action="store") parent_parser.add_argument('--password', action="store") child_parser = argparse.ArgumentParser(parents=[parent_parser], conflict_handler='resolve') child_parser.add_argument('--user', action="store", default="Guest") print child_parser.parse_args() Namespace(password=None, user='Guest')
विभिन्न स्तरों पर प्रसंस्करण आदेशों के लिए उपरोक्त दृष्टिकोण के अलावा, एक वैकल्पिक दृष्टिकोण भी है जो आपको सबपरर्स का उपयोग करके एक प्रोग्राम में सभी कमांड के प्रसंस्करण को संयोजित करने की अनुमति देता है। एक उदाहरण खुद के लिए सबसे अच्छा बताएगा:
ap.py import argparse parser = argparse.ArgumentParser() subparsers = parser.add_subparsers(help='List of commands')
यह '-h' विकल्प के साथ कार्यक्रम का उत्पादन करेगा:
usage: ap.py [-h] {list,create} ...
positional arguments:
{list,create} list of commands
list List contents
create Create a directory
optional arguments:
-h, --help show this help message and exitउदाहरण में निम्नलिखित बातों पर ध्यान दिया जा सकता है:
1.
स्थिति संबंधी तर्क सूची, कार्यक्रम के लिए बनाया गया, पारित किया गया - अनिवार्य रूप से सबपर्सर्स;
2. तर्क `- केवल-केवल 'सबपर के create_parser -
वैकल्पिक , dir_name - दोनों subparsers के लिए आवश्यक;
3. मदद (मदद) पार्सर और प्रत्येक उप-पार्सर के लिए दोनों प्रदान की जाती है।
सामान्य तौर पर, argparse एक काफी शक्तिशाली और हल्का पुस्तकालय है, जो मेरी राय में, कमांड लाइन मापदंडों के साथ काम करने के लिए बहुत सुविधाजनक इंटरफ़ेस प्रदान करता है। अगली बार मैं फ़ाइल तर्क (फ़ाइलों के साथ अधिक उन्नत कार्य के लिए), चर तर्क सूची, तर्कों के समूह और टाइपिंग तर्कों की अधिक विस्तृत चर्चा जैसे मुद्दों को कवर करने का प्रयास करूँगा।
आपका ध्यान देने के लिए धन्यवाद।
संदर्भ:
अडॉप्ट और ऑप्टपर्स पर्याप्त क्यों नहीं हैं (PEP 389)तर्कपूर्ण स्थिति और वैकल्पिक तर्कअर्गपर्स डॉक्यूमेंटेशनकमांड-लाइन विकल्प, तर्क और उप-कमांड के लिए पार्सर