Python के argparse मॉड्यूल में महारत: बेहतर CLI बनाएं

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

कमांड-लाइन पैरामीटर संभालना CLI डिजाइन का एक महत्वपूर्ण हिस्सा है। ये आर्ग्यूमेंट प्रोग्राम के चलते समय इनपुट पैरामीटर देकर उसके व्यवहार को प्रभावित करने देते हैं। यदि इन कारकों का आकलन करने की क्षमता न हो, तो प्रोग्राम कम बहुमुखी होंगे और विशिष्ट कार्यों के लिए समायोजित करना कठिन होगा।

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

इस ट्यूटोरियल में, हम Python के argparse पैकेज का उपयोग कैसे करें, यह देखेंगे। हम Python के कमांड-लाइन इंटरफेस का अवलोकन और कमांड-लाइन इनपुट पार्सिंग के महत्व से शुरू करेंगे। फिर हम argparse मॉड्यूल और इसके लाभों पर चर्चा करेंगे।

Python में कमांड-लाइन इंटरफेस का अवलोकन

कमांड-लाइन इंटरफेस ऐसे प्रोग्राम हैं जो पूरी तरह से टेक्स्ट-आधारित कमांड पर चलते हैं। उपयोगकर्ता टर्मिनल या कमांड लाइन में कमांड दर्ज करते हैं, जिनमें आमतौर पर ऐसे आर्ग्यूमेंट्स और ऑप्शन होते हैं जो प्रोग्राम के व्यवहार को बदलते हैं। CLI उपयोगी हैं क्योंकि इन्हें आसानी से स्वचालित किया जा सकता है और अन्य तकनीकों के साथ एकीकृत किया जा सकता है।

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

कमांड-लाइन आर्ग्यूमेंट्स पार्सिंग का महत्व

कमांड-लाइन आर्ग्यूमेंट्स पार्स करना कई कारणों से आवश्यक है: 

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

argparse मॉड्यूल का परिचय और इसके लाभ

argparse मॉड्यूल Python की स्टैंडर्ड लाइब्रेरी का हिस्सा है। इसलिए, इसे किसी अतिरिक्त पैकेज को इंस्टॉल किए बिना उपयोग किया जा सकता है। यह कमांड लाइन इनपुट पार्स करने के लिए एक सीधा और सुसंगत इंटरफेस प्रदान करता है। argparse का उपयोग करने के कुछ फायदे हैं:

• स्वचालित सहायता निर्माण: यह कोड के आर्ग्यूमेंट्स के आधार पर सहायता और उपयोग संदेश उत्पन्न करता है।
• त्रुटि प्रबंधन: जब उपयोगकर्ता अमान्य आर्ग्यूमेंट दर्ज करते हैं, तो यह सहायक त्रुटि संदेश प्रदर्शित करता है।
• टाइप रूपांतरण: यह पैरामीटर स्ट्रिंग्स को स्वतः उपयुक्त डेटा टाइप में बदल सकता है।
• यह आवश्यक पोज़िशनल आर्ग्यूमेंट्स और वैकल्पिक आर्ग्यूमेंट्स दोनों का सरलता से समर्थन करता है।
• डिफ़ॉल्ट मान: यह आपको ऐसे पैरामीटर के लिए डिफ़ॉल्ट मान प्रदान करने देता है जिन्हें उपयोगकर्ता सप्लाई नहीं करता।

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

argparse सेट करना और बुनियादी उपयोग

अब जब हमने कमांड-लाइन आर्ग्यूमेंट्स पार्स करने के महत्व और argparse का उपयोग करने के लाभों को कवर कर लिया है, तो आइए देखें कि इसे Python स्क्रिप्ट में कैसे सेट किया जाए और उपयोग किया जाए।

argparse इंस्टॉल करना और इम्पोर्ट करना

अलग से कुछ इंस्टॉल करने की आवश्यकता नहीं है क्योंकि argparse Python की स्टैंडर्ड लाइब्रेरी का हिस्सा है। आप इसे अपनी स्क्रिप्ट की शुरुआत में ही इम्पोर्ट कर सकते हैं।

import argparse

यह पंक्ति आपकी स्क्रिप्ट में argparse मॉड्यूल लोड करती है, जिससे आप कमांड-लाइन आर्ग्यूमेंट्स पार्स करने के लिए इसकी कार्यक्षमता का उपयोग कर सकें।

एक साधारण आर्ग्यूमेंट पार्सर बनाना

argparse का उपयोग करने का पहला कदम एक पार्सर ऑब्जेक्ट बनाना है। यह ऑब्जेक्ट आपके प्रोग्राम द्वारा स्वीकार किए जाने वाले आर्ग्यूमेंट्स की जानकारी संग्रहीत करेगा और कमांड-लाइन इनपुट पार्स करेगा।

parser = argparse.ArgumentParser(description='Process some integers.')

इस उदाहरण में, हम एक ArgumentParser() ऑब्जेक्ट बनाते हैं और प्रोग्राम का वर्णन करते हैं। जब उपयोगकर्ता सहायता विकल्प (-h या --help) चुनता है, तो यह विवरण प्रदर्शित होगा।

पोज़िशनल और वैकल्पिक आर्ग्यूमेंट्स जोड़ना

अब जब हमने पार्सर विकसित कर लिया है, तो हम उन आर्ग्यूमेंट्स को निर्दिष्ट कर सकते हैं जिन्हें हमारा प्रोग्राम स्वीकार करेगा।

पोज़िशनल आर्ग्यूमेंट्स जोड़ना

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

parser.add_argument('num1', type=int, help='The first number to add.')
parser.add_argument('num2', type=int, help='The second number to add.')

इस कोड में, num1 और num2 पोज़िशनल पैरामीटर्स को संदर्भित करते हैं।

type=int इंगित करता है कि पैरामीटर्स को इंटीजर में परिवर्तित किया जाना चाहिए। help आर्ग्यूमेंट उस विवरण को निर्दिष्ट करता है जो सहायता संदेश में दिखाई देगा।

वैकल्पिक आर्ग्यूमेंट्स जोड़ना

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

parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.')

यहाँ:

• शॉर्ट ऑप्शन -v है (उदाहरण के लिए, -v)। --verbose एक लंबा विकल्प है।
• action='store_true' इंगित करता है कि यदि विकल्प चुना गया है, तो verbose एट्रिब्यूट True पर सेट हो जाएगा; अन्यथा यह False होगा।
• help आर्ग्यूमेंट सहायता संदेश के लिए विवरण निर्दिष्ट करता है।

आर्ग्यूमेंट्स पार्स करना और उनके मान एक्सेस करना

सभी आर्ग्यूमेंट्स निर्दिष्ट करने के बाद, हमें कमांड-लाइन इनपुट पार्स करना होगा। इसके लिए .parse_args() मेथड का उपयोग करें।

args = parser.parse_args()

पार्स किए गए पैरामीटर्स अब args वेरिएबल में एट्रिब्यूट्स के रूप में संग्रहीत हैं। हम उन्हें डॉट नोटेशन का उपयोग करके एक्सेस कर सकते हैं।

result = args.num1 + args.num2
print('The sum of {} and {} is {}'.format(args.num1, args.num2, result))
if args.verbose:
    print('Verbose mode is enabled.')

सब कुछ एक साथ रखते हुए, यहाँ एक पूर्ण स्क्रिप्ट है जो दो संख्याएँ जोड़ती है और वैकल्पिक वर्बोज़ मोड शामिल करती है:

import argparse
parser = argparse.ArgumentParser(description='Add two integers.')
parser.add_argument('num1', type=int, help='The first number to add.')
parser.add_argument('num2', type=int, help='The second number to add.')
parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.')
args = parser.parse_args()
result = args.num1 + args.num2
print('The sum of {} and {} is {}'.format(args.num1, args.num2, result))
if args.verbose:
    print('Calculation completed successfully.')

आप कमांड लाइन से इस स्क्रिप्ट को चल सकते हैं और आवश्यक पोज़िशनल आर्ग्यूमेंट्स प्रदान कर सकते हैं:

python add_numbers.py 3 5
The sum of 3 and 5 is 8

यदि आप -व या --verbose विकल्प शामिल करते हैं, तो स्क्रिप्ट अतिरिक्त वर्बोज़ संदेश प्रिंट करेगी:

python add_numbers.py 3 5 --verbose
The sum of 3 and 5 is 8
Calculation completed successfully.

यदि उपयोगकर्ता स्क्रिप्ट को -h या --help विकल्प के साथ चलाता है, तो argparse स्वतः जनरेटेड सहायता संदेश प्रदर्शित करेगा:

python add_numbers.py -h
usage: add_numbers.py [-h] [-v] num1 num2
Add two integers.
positional arguments:
  num1           The first number to add.
  num2           The second number to add.
optional arguments:
  -h, --help     show this help message and exit
  -v, --verbose  Increase output verbosity.

यह सुविधा आपके प्रोग्राम को स्पष्ट निर्देश प्रदान करके अधिक उपयोगकर्ता-अनुकूल बनाती है।

उन्नत आर्ग्यूमेंट हैंडलिंग

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

कई आर्ग्यूमेंट्स के लिए nargs का उपयोग

ऐसी स्थितियाँ होती हैं जब आपके अनुप्रयोग को उसी आर्ग्यूमेंट के लिए कई मान स्वीकार करने की आवश्यकता होती है। उदाहरण के लिए, मान लें कि आप एक स्क्रिप्ट बनाना चाहते हैं जो एक साथ कई फाइलें प्रोसेस करे। argparse में nargs पैरामीटर आपको यह निर्दिष्ट करने की अनुमति देता है कि कितने कमांड-लाइन आर्ग्यूमेंट्स पढ़े जाने चाहिए।

यहाँ nargs का उपयोग करके कई फ़ाइलनाम स्वीकार करने का तरीका है:

import argparse
parser = argparse.ArgumentParser(description='Process multiple files.')
parser.add_argument('filenames', nargs='+', help='List of files to process.')
args = parser.parse_args()
for filename in args.filenames:
    print(f'Processing file: {filename}')
    # Add your file processing code here

इस मामले में, nargs='+' पार्सर को filenames में एक या अधिक आर्ग्यूमेंट्स की अपेक्षा करने का निर्देश देता है। उपयोगकर्ता आवश्यकतानुसार जितने चाहें उतने फ़ाइल नाम दे सकता है, और वे args.filenames नामक सूची में सहेजे जाएंगे।

यदि आप निश्चित संख्या में आर्ग्यूमेंट्स स्वीकार करना चाहते हैं, तो nargs को उस संख्या पर सेट करें। उदाहरण के लिए, nargs=2 ठीक दो पैरामीटर आवश्यक करता है।

आर्ग्यूमेंट मान सीमित करने के लिए choices लागू करना

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

ऐसी स्क्रिप्ट पर विचार करें जो उपयोगकर्ता द्वारा चुने गए मोड के आधार पर कई गतिविधियाँ निष्पादित करती है।

import argparse
parser = argparse.ArgumentParser(description='Perform actions in different modes.')
parser.add_argument('--mode', choices=['backup', 'restore', 'delete'], required=True, help='Mode of operation.')
args = parser.parse_args()
if args.mode == 'backup':
    print('Backing up data...')
    # Backup code here
elif args.mode == 'restore':
    print('Restoring data...')
    # Restore code here
elif args.mode == 'delete':
    print('Deleting data...')
    # Delete code here

इस स्क्रिप्ट में, --mode आर्ग्यूमेंट को इन विकल्पों में से एक होना ही चाहिए। यदि उपयोगकर्ता ऐसा मान दर्ज करता है जो सूची में नहीं है, तो argparse एक त्रुटि संदेश लौटाएगा।

बूलियन फ्लैग्स और टॉगल्स को संभालना

बूलियन फ्लैग ऐसे विकल्प होते हैं जो आपके अनुप्रयोग में विशिष्ट कार्यक्षमताओं को सक्षम या अक्षम करते हैं। इन्हें आमतौर पर किसी मान के बिना परिभाषित किया जाता है, केवल कमांड में फ्लैग शामिल करके। आप argparse में action पैरामीटर के साथ इन फ्लैग्स को संभाल सकते हैं।

उदाहरण के लिए, आइए किसी स्क्रिप्ट में डिबग मोड शामिल करें:

import argparse
parser = argparse.ArgumentParser(description='A script with debug mode.')
parser.add_argument('--debug', action='store_true', help='Enable debug output.')
args = parser.parse_args()
if args.debug:
    print('Debug mode is enabled.')
    # Additional debug information here
else:
    print('Debug mode is disabled.')

action='store_true' का उपयोग करके, --debug फ्लैग मौजूद होने पर args.debug को True पर सेट करेगा और अन्यथा False रहेगा।

डिफ़ॉल्ट मान सेट करना और आवश्यक आर्ग्यूमेंट्स

वैकल्पिक आर्ग्यूमेंट्स में अक्सर उपयुक्त डिफ़ॉल्ट मान शामिल होते हैं। इसका अर्थ है कि यदि उपयोगकर्ता आर्ग्यूमेंट निर्दिष्ट नहीं करता, तो अनुप्रयोग डिफ़ॉल्ट का उपयोग करेगा। default आर्ग्यूमेंट आपको डिफ़ॉल्ट मान निर्दिष्ट करने देता है।

यहाँ एक उदाहरण है:

import argparse
parser = argparse.ArgumentParser(description='Adjust program settings.')
parser.add_argument('--timeout', type=int, default=30, help='Timeout in seconds.')
args = parser.parse_args()
print(f'Timeout is set to {args.timeout} seconds.')

इस परिदृश्य में, यदि उपयोगकर्ता --timeout निर्दिष्ट नहीं करता, तो डिफ़ॉल्ट 30 सेकंड है।

किसी वैकल्पिक आर्ग्यूमेंट को अनिवार्य बनाने के लिए, required=True सेट करें।

import argparse
parser = argparse.ArgumentParser(description='Send a message.')
parser.add_argument('--recipient', required=True, help='Recipient of the message.')
args = parser.parse_args()
print(f'Sending message to {args.recipient}.')

अब स्क्रिप्ट को --recipient आर्ग्यूमेंट की आवश्यकता होगी।

सहायता और त्रुटि संदेशों को कस्टमाइज़ करना

उपयोगकर्ताओं को स्पष्ट और सहायक संदेश प्रदान करना एक प्रभावी कमांड-लाइन प्रोग्राम विकसित करने का आवश्यक घटक है। Python का argparse मॉड्यूल स्वतः सहायता संदेश बनाता है, लेकिन आप इन संदेशों को अपनी आवश्यकताओं के अनुसार संशोधित कर सकते हैं।

स्वचालित सहायता संदेश उत्पन्न करना

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

उदाहरण के लिए:

import argparse
parser = argparse.ArgumentParser(description='Calculate factorial of a number.')
parser.add_argument('number', type=int, help='The number to calculate the factorial for.')
args = parser.parse_args()

जब कोई उपयोगकर्ता स्क्रिप्ट को -h के साथ चलाता है, तो वे देखेंगे:

usage: script.py [-h] number
Calculate factorial of a number.
positional arguments:
  number      The number to calculate the factorial for.
optional arguments:
  -h, --help  show this help message and exit

यह स्वचालित सहायता संदेश बिना किसी अतिरिक्त प्रयास के उपयोगी जानकारी देता है।

सहायता विवरण और उपयोग संदेशों को कस्टमाइज़ करना

हालाँकि डिफ़ॉल्ट सहायता संदेश उपयोगी हैं, आप उन्हें अतिरिक्त जानकारी प्रदान करने या किसी विशिष्ट संरचना में ढालने के लिए बदलना चाह सकते हैं। आप ArgumentParser में description, epilog और usage टेक्स्ट बदल सकते हैं।

उदाहरण के लिए, epilog शामिल करने और usage संदेश को वैयक्तिकृत करने के लिए:

import argparse
parser = argparse.ArgumentParser(
    description='Convert temperatures between Celsius and Fahrenheit.',
    epilog='Enjoy using the temperature converter!',
    usage='%(prog)s [options] temperature')
parser.add_argument('temperature', type=float, help='Temperature value to convert.')
parser.add_argument('--to-fahrenheit', action='store_true', help='Convert Celsius to Fahrenheit.')
parser.add_argument('--to-celsius', action='store_true', help='Convert Fahrenheit to Celsius.')
args = parser.parse_args()

अब, जब उपयोगकर्ता सहायता संदेश जाँचेगा, तो इसमें कस्टमाइज्ड विवरण, usage और epilog शामिल होगा:

python file.py --help

usage: p.py [options] temperature

Convert temperatures between Celsius and Fahrenheit.

positional arguments:
  temperature      Temperature value to convert.

options:
  -h, --help       show this help message and exit
  --to-fahrenheit  Convert Celsius to Fahrenheit.
  --to-celsius     Convert Fahrenheit to Celsius.

त्रुटि प्रबंधन और उपयोगकर्ता फीडबैक संभालना

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

एक तरीका है कि ArgumentParser की एक सबक्लास में error मेथड को ओवरराइड करें:

import argparse
import sys
class CustomArgumentParser(argparse.ArgumentParser):
    def error(self, message):
        print(f'Error: {message}')
        self.print_help()
        sys.exit(2)
parser = CustomArgumentParser(description='Divide two numbers.')
parser.add_argument('numerator', type=float, help='The numerator.')
parser.add_argument('denominator', type=float, help='The denominator.')
args = parser.parse_args()
if args.denominator == 0:
    parser.error('Denominator cannot be zero.')
result = args.numerator / args.denominator
print(f'Result: {result}')

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

Python file.py 6 0
Error: Denominator cannot be zero.
usage: file.py [-h] numerator denominator
Divide two numbers.
positional arguments:
  numerator    The numerator.
  denominator  The denominator.
options:
  -h, --help   show this help message and exit

आप अपनी स्क्रिप्ट में कस्टम त्रुटि प्रबंधन भी शामिल कर सकते हैं। उदाहरण के लिए, अमान्य फ़ाइल पथों को प्रबंधित करने के लिए:

import argparse
import os
parser = argparse.ArgumentParser(description='Read a file and display its contents.')
parser.add_argument('filepath', help='Path to the file.')
args = parser.parse_args()
if not os.path.exists(args.filepath):
    parser.error(f"The file {args.filepath} does not exist.")
with open(args.filepath, 'r') as file:
    contents = file.read()
    print(contents)

अमान्य पथ के साथ स्क्रिप्ट चलाने पर नीचे दी गई त्रुटि प्रदर्शित होगी:

python app..py file
usage: p.py [-h] filepath
app.py: error: The file file does not exist.

वास्तविक दुनिया के उदाहरण और उपयोग के मामले

argparse मॉड्यूल का वास्तविक दुनिया के परिदृश्यों में उपयोग समझना इसकी कार्यक्षमता को और स्पष्ट करेगा। आइए देखें कि वास्तविक अनुप्रयोगों में argparse का उपयोग कैसे किया जा सकता है।

कमांड-लाइन कैलकुलेटर बनाना

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

इस कार्य के लिए इस तरह दृष्टिकोण अपनाएँ:

import argparse
parser = argparse.ArgumentParser(description='Simple command-line calculator.')
parser.add_argument('num1', type=float, help='First number.')
parser.add_argument('operator', choices=['+', '-', '*', '/'], help='Operation to perform.')
parser.add_argument('num2', type=float, help='Second number.')
args = parser.parse_args()
if args.operator == '+':
    result = args.num1 + args.num2
elif args.operator == '-':
    result = args.num1 - args.num2
elif args.operator == '*':
    result = args.num1 * args.num2
elif args.operator == '/':
    if args.num2 == 0:
        print('Error: Division by zero is not allowed.')
        exit(1)
    result = args.num1 / args.num2
print(f'The result is: {result}')

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

python calculator.py 10 + 5
The result is: 15.0

यह बुनियादी कैलकुलेटर दिखाता है कि कमांड-लाइन विकल्प किसी प्रोग्राम की लचीलापन और इंटरएक्टिविटी कैसे बढ़ा सकते हैं।

कई विकल्पों के साथ फ़ाइल-प्रोसेसिंग स्क्रिप्ट बनाना

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

इसे सेटअप करने का एक उदाहरण यहाँ है:

import argparse
parser = argparse.ArgumentParser(description='Process text files.')
parser.add_argument('input_file', help='Path to the input file.')
parser.add_argument('-o', '--output', help='Path to the output file.')
parser.add_argument('-m', '--mode', choices=['uppercase', 'lowercase'], default='uppercase', help='Processing mode.')
parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output.')
args = parser.parse_args()
# Read the input file
with open(args.input_file, 'r') as file:
    content = file.read()
if args.verbose:
    print(f'Reading from {args.input_file}')
# Process the content
if args.mode == 'uppercase':
    processed_content = content.upper()
else:
    processed_content = content.lower()
if args.verbose:
    print('Processing content')
# Write to the output file or print to console
if args.output:
    with open(args.output, 'w') as file:
        file.write(processed_content)
    if args.verbose:
        print(f'Writing output to {args.output}')
else:
    print(processed_content)

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

python text_processor.py input.txt -o output.txt --mode lowercase -v
Reading from input.txt
Processing content
Writing output to output.txt

सबकमांड्स के साथ एक CLI टूल विकसित करना

अधिक जटिल अनुप्रयोगों में, सबकमांड्स की आवश्यकता हो सकती है, ठीक वैसे ही जैसे git में git commit और git push जैसे कमांड का उपयोग होता है। इस उद्देश्य के लिए argparse मॉड्यूल सबपार्सर्स प्रदान करता है।

सबकमांड्स के साथ CLI टूल बनाने का तरीका यहाँ है:

import argparse
parser = argparse.ArgumentParser(description='Manage tasks.')
subparsers = parser.add_subparsers(dest='command', required=True)
# Subcommand 'add'
parser_add = subparsers.add_parser('add', help='Add a new task.')
parser_add.add_argument('name', help='Name of the task.')
parser_add.add_argument('-p', '--priority', type=int, choices=range(1, 6), default=3, help='Priority of the task.')
# Subcommand 'list'
parser_list = subparsers.add_parser('list', help='List all tasks.')
parser_list.add_argument('-a', '--all', action='store_true', help='List all tasks, including completed ones.')
# Subcommand 'complete'
parser_complete = subparsers.add_parser('complete', help='Mark a task as completed.')
parser_complete.add_argument('task_id', type=int, help='ID of the task to complete.')
args = parser.parse_args()
if args.command == 'add':
    print(f"Adding task '{args.name}' with priority {args.priority}")
    # Code to add the task
elif args.command == 'list':
    print('Listing tasks')
    if args.all:
        print('Including completed tasks')
    # Code to list tasks
elif args.command == 'complete':
    print(f'Marking task {args.task_id} as completed')
    # Code to complete the task

इस उदाहरण में, स्क्रिप्ट में तीन सबकमांड हैं: add, list, और complete। प्रत्येक सबकमांड के अपने आर्ग्यूमेंट्स हैं। जब उपयोगकर्ता स्क्रिप्ट चलाते हैं, तो वे सबकमांड और अन्य पैरामीटर दर्ज करते हैं।

उदाहरण के लिए:

python task_manager.py add "Write report" -p 2
Adding task 'Write report' with priority 2

कार्य सूचीबद्ध करना

python task_manager.py list
Listing tasks

कार्य को पूर्ण के रूप में चिह्नित करना:

python task_manager.py complete 3
Marking task 3 as completed

subparsers आपको सुव्यवस्थित और आसानी से विस्तारित होने वाले जटिल कमांड लाइन टूल बनाने में सक्षम बनाते हैं, जिससे आप एक ही इंटरफेस में कई कार्य कर सकने वाले अनुप्रयोग बना सकते हैं। 

Python argparse सर्वोत्तम प्रथाएँ और सुझाव

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

argparse मॉड्यूल के साथ काम करते समय कुछ सर्वोत्तम प्रथाएँ यहाँ दी गई हैं।

पढ़ने में आसानी और रखरखाव के लिए कोड व्यवस्थित करना

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

अपने प्रोग्राम को छोटे, पुन: प्रयोज्य हिस्सों में तोड़ने से इसे प्रबंधित करना आसान हो जाता है और कोड डुप्लीकेशन समाप्त होता है।

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

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

उपयुक्त वेरिएबल नामों का उपयोग करना भी पठनीयता में सुधार करता है। ऐसे नाम चुनें जो उनके उद्देश्य को दर्शाएँ, ताकि कोई भी आपके कोड को देखकर समझ सके कि क्या हो रहा है। अपने फ़ंक्शंस क्या करते हैं और कोई भी महत्वपूर्ण विवरण समझाने के लिए टिप्पणियाँ और docstrings शामिल करना समझ को बढ़ाने में मदद कर सकता है।

कमांड-लाइन अनुप्रयोगों का परीक्षण और डिबगिंग

अपने अनुप्रयोगों का परीक्षण करना यह सुनिश्चित करने के लिए महत्वपूर्ण है कि वे ठीक से काम करें और शुरुआती चरण में ही त्रुटियों का पता चल जाए। unittest या pytest जैसे Python परीक्षण फ्रेमवर्क के साथ यूनिट टेस्ट लिखना आपके कोड का परीक्षण करने का उत्कृष्ट तरीका है। ये टेस्ट आपको विभिन्न इनपुट का अनुकरण करने और यह सुनिश्चित करने की अनुमति देते हैं कि आपके फ़ंक्शंस सही तरीके से काम करें।

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

अपवादों को शालीनता से संभालना भी महत्वपूर्ण है। try-except ब्लॉक्स का उपयोग करके, आप त्रुटियाँ पकड़ सकते हैं और उपयोगकर्ता को उपयोगी संदेश दे सकते हैं। इससे आपका अनुप्रयोग अधिक स्थिर और उपयोगकर्ता-अनुकूल बनता है।

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

argparse की अन्य आर्ग्यूमेंट पार्सिंग लाइब्रेरियों से तुलना

हालाँकि argparse Python की स्टैंडर्ड लाइब्रेरी में एक मूल्यवान यूटिलिटी है, फिर भी अन्य लाइब्रेरियाँ उपलब्ध हैं जो कमांड-लाइन आर्ग्यूमेंट्स पार्स करने के वैकल्पिक तरीके प्रदान करती हैं। इन विकल्पों को समझना आपके प्रोजेक्ट के लिए सही टूल चुनने में मदद करेगा।

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

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

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

निष्कर्ष

पूरे इस लेख में, हमने Python में कमांड-लाइन प्रोग्राम विकसित करने के लिए Python के argparse मॉड्यूल का उपयोग कैसे करें, यह देखा। वास्तविक दुनिया के उदाहरणों पर काम करते हुए, हमने सीखा कि उपयोगकर्ता इनपुट प्राप्त करने और प्रासंगिक कार्यों को पूरा करने वाली व्यावहारिक स्क्रिप्ट कैसे बनाईं जाएँ।

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

चाहे आप कार्यों को स्वचालित कर रहे हों, डेटा का विश्लेषण कर रहे हों, या जटिल टूल बना रहे हों, कमांड-लाइन आर्ग्यूमेंट पार्सिंग को समझना प्रभावी Python प्रोग्राम डिजाइन करने की आपकी क्षमता में सुधार करता है। हमारे Python Fundamentals स्किल ट्रैक के साथ आज ही अपने Python ज्ञान को बढ़ाएँ।