परिचय

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

आर्गपर्स क्या है?

Argparse मॉड्यूल आपकी पायथन स्क्रिप्ट को दिए गए कमांड-लाइन तर्कों को संभालने का एक आसान तरीका प्रदान करता है। यह स्वचालित रूप से सहायता संदेश उत्पन्न करता है, प्रकार की जाँच को संभालता है, और वैकल्पिक और स्थितिगत तर्क दोनों को संसाधित कर सकता है।

आर्गपर्स का उपयोग क्यों करें?

• स्वचालित सहायता संदेश: उपयोगकर्ता --help विकल्प का उपयोग करके आसानी से समझ सकते हैं कि आपका प्रोग्राम कैसे चलाया जाए।
• टाइप चेकिंग: आप यह सुनिश्चित कर सकते हैं कि इनपुट मान्य हैं (उदाहरण के लिए, पूर्णांक जहां आप उनसे अपेक्षा करते हैं)।
• पढ़ने योग्य कमांड-लाइन इंटरफेस: आपकी स्क्रिप्ट को अधिक पेशेवर और उपयोगकर्ता के अनुकूल बनाता है।

आइए बुनियादी बातों से शुरू करें!

आर्गपर्स की स्थापना

Argparse का उपयोग शुरू करने के लिए, आपको सबसे पहले मॉड्यूल आयात करना होगा और एक ArgumentParser ऑब्जेक्ट बनाना होगा:

import argparse

parser = argparse.ArgumentParser(description="Demo script for argparse.")

यहां विवरण तर्क वैकल्पिक है और आपकी स्क्रिप्ट के उद्देश्य को समझाने में मदद करता है। यह तब दिखाई देता है जब उपयोगकर्ता --help कमांड चलाते हैं।

स्थितीय तर्क

आर्गपर्से में स्थितीय तर्क सबसे बुनियादी प्रकार के तर्क हैं। ये आवश्यक हैं और कमांड में सही क्रम में दिखाई देने चाहिए।

parser.add_argument("name", help="Your name")
args = parser.parse_args()
print(f"Hello, {args.name}!")

स्क्रिप्ट चल रहा है:

$ python script.py Alice
Hello, Alice!

यदि आप नाम तर्क प्रदान नहीं करते हैं, तो argparse एक त्रुटि देगा:

$ python script.py
usage: script.py [-h] name
script.py: error: the following arguments are required: name

वैकल्पिक तर्क

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

parser.add_argument("-g", "--greeting", help="Custom greeting message", default="Hello")
args = parser.parse_args()
print(f"{args.greeting}, {args.name}!")

स्क्रिप्ट चल रहा है:

$ python script.py Alice --greeting Hi
Hi, Alice!

डिफ़ॉल्ट तर्क यह सुनिश्चित करता है कि यदि उपयोगकर्ता विकल्प प्रदान नहीं करता है तो एक डिफ़ॉल्ट मान का उपयोग किया जाता है:

$ python script.py Alice
Hello, Alice!

तर्क प्रकार

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

parser.add_argument("age", type=int, help="Your age")
args = parser.parse_args()
print(f"{args.name} is {args.age} years old.")

स्क्रिप्ट चल रहा है:

$ python script.py Alice 25
Alice is 25 years old.

यदि आप एक अमान्य प्रकार प्रदान करते हैं (उदाहरण के लिए, एक स्ट्रिंग जहां एक पूर्णांक अपेक्षित है), तो argparse स्वचालित रूप से एक त्रुटि दिखाएगा:

$ python script.py Alice twenty-five
usage: script.py [-h] name age
script.py: error: argument age: invalid int value: 'twenty-five'

ध्वज तर्क (बूलियन विकल्प)

फ़्लैग तर्क कुछ सुविधाओं को सक्षम या अक्षम करने के लिए उपयोगी होते हैं। ये कोई मूल्य नहीं लेते बल्कि स्विच के रूप में कार्य करते हैं। ध्वज बनाने के लिए Action='store_true' विकल्प का उपयोग करें।

parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose mode")
args = parser.parse_args()

if args.verbose:
    print("Verbose mode is on.")

स्क्रिप्ट चल रहा है:

$ python script.py Alice -v
Verbose mode is on.

यदि आप ध्वज प्रदान नहीं करते हैं, तो गलत का डिफ़ॉल्ट मान उपयोग किया जाता है:

$ python script.py Alice

छोटे बनाम लंबे विकल्प वाले नाम

argparse आपको एक ही तर्क के लिए छोटे और लंबे दोनों विकल्प नामों को परिभाषित करने की अनुमति देता है। उदाहरण के लिए:

parser.add_argument("-g", "--greeting", help="Custom greeting message")

आप या तो लघु संस्करण (-जी) या लंबे संस्करण (--ग्रीटिंग) का उपयोग कर सकते हैं:

$ python script.py Alice -g Hi
Hi, Alice!

$ python script.py Alice --greeting Hi
Hi, Alice!

डिफॉल्ट मान

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

parser.add_argument("-g", "--greeting", default="Hello", help="Greeting message")
args = parser.parse_args()
print(f"{args.greeting}, {args.name}!")

एकाधिक मानों को संभालना

आप nargs का उपयोग करके ऐसे तर्क भी निर्दिष्ट कर सकते हैं जो एकाधिक मान स्वीकार करते हैं। उदाहरण के लिए, एकाधिक फ़ाइल नाम स्वीकार करने के लिए:

parser.add_argument("files", nargs=" ", help="List of file names")
args = parser.parse_args()
print(f"Files to process: {args.files}")

स्क्रिप्ट चल रहा है:

$ python script.py file1.txt file2.txt file3.txt
Files to process: ['file1.txt', 'file2.txt', 'file3.txt']

विकल्प सीमित करना

आप विकल्प विकल्प का उपयोग करके किसी तर्क के संभावित मानों को प्रतिबंधित कर सकते हैं:

parser.add_argument("--format", choices=["json", "xml"], help="Output format")
args = parser.parse_args()
print(f"Output format: {args.format}")

स्क्रिप्ट चल रहा है:

$ python script.py Alice --format json
Output format: json

यदि उपयोगकर्ता कोई अमान्य विकल्प प्रदान करता है, तो argparse एक त्रुटि देगा:

$ python script.py Alice --format csv
usage: script.py [-h] [--format {json,xml}] name
script.py: error: argument --format: invalid choice: 'csv' (choose from 'json', 'xml')

स्थितीय और वैकल्पिक तर्कों का संयोजन

आप एक ही स्क्रिप्ट में स्थितीय और वैकल्पिक तर्कों का मिश्रण और मिलान कर सकते हैं।

parser.add_argument("name", help="Your name")
parser.add_argument("--greeting", help="Custom greeting", default="Hello")
parser.add_argument("--verbose", action="store_true", help="Enable verbose output")

args = parser.parse_args()

if args.verbose:
    print(f"Running in verbose mode...")

print(f"{args.greeting}, {args.name}!")

सहायता संदेश उत्पन्न करना

आर्गपर्स की सबसे बड़ी खूबियों में से एक इसका अंतर्निहित सहायता संदेश जनरेटर है। जब कोई उपयोगकर्ता आपकी स्क्रिप्ट को -h या --help ध्वज के साथ चलाता है, तो argparse स्वचालित रूप से तर्क और उनके विवरण प्रदर्शित करेगा।

$ python script.py -h
usage: script.py [-h] [--greeting GREETING] [--verbose] name

Demo script for argparse.

positional arguments:
  name             Your name

optional arguments:
  -h, --help       show this help message and exit
  --greeting GREETING
                   Custom greeting
  --verbose        Enable verbose output

सबपार्सर: एकाधिक कमांड को संभालना

यदि आपकी स्क्रिप्ट में कई उपकमांड हैं (उदाहरण के लिए, गिट कमिट, गिट पुश), तो आप उन्हें संभालने के लिए सबपार्सर का उपयोग कर सकते हैं।

parser = argparse.ArgumentParser(description="Git-like command-line tool")
subparsers = parser.add_subparsers(dest="command")

# Add "commit" subcommand
commit_parser = subparsers.add_parser("commit", help="Record changes to the repository")
commit_parser.add_argument("-m", "--message", help="Commit message", required=True)

# Add "push" subcommand
push_parser = subparsers.add_parser("push", help="Update remote refs")

args = parser.parse_args()

if args.command == "commit":
    print(f"Committing changes with message: {args.message}")
elif args.command == "push":
    print("Pushing changes to remote repository.")

सर्वोत्तम प्रथाएं

Argparse का उपयोग करते समय विचार करने के लिए यहां कुछ सर्वोत्तम अभ्यास दिए गए हैं:

1. हमेशा एक सहायता संदेश प्रदान करें: प्रत्येक विकल्प क्या करता है इसका वर्णन करने के लिए add_argument में सहायता तर्क का उपयोग करें।
2. समझदार डिफ़ॉल्ट का उपयोग करें: सभी तर्कों की आवश्यकता के बिना सुचारू निष्पादन सुनिश्चित करने के लिए जहां उपयुक्त हो वहां डिफ़ॉल्ट मान प्रदान करें।
3. इनपुट मान्य करें: यह सुनिश्चित करने के लिए विकल्पों और प्रकार का उपयोग करें कि उपयोगकर्ता वैध इनपुट प्रदान करते हैं।
4. इसे सरल रखें: जब तक बिल्कुल आवश्यक न हो, अपनी स्क्रिप्ट को बहुत अधिक तर्कों से न भरने का प्रयास करें।
5. अपने आदेशों की संरचना करें: जटिल उपकरणों के लिए, विभिन्न आदेशों को तार्किक रूप से अलग करने के लिए सबपार्सर का उपयोग करें।

निष्कर्ष

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

अगली बार जब आप पायथन स्क्रिप्ट बना रहे हों, तो इसे अधिक लचीला और सुलभ बनाने के लिए argparse का उपयोग करने पर विचार करें। हैप्पी कोडिंग!

यदि आपके कोई प्रश्न या सुझाव हों तो बेझिझक मुझसे संपर्क करें। मेरे साथ यहां जुड़ें:

• लिंक्डइन
• गिटहब