पायथन में 'argparse.ArgumentError' का उपयोग करना

मैं पाइथन में argparse मॉड्यूल में ArgumentError अपवाद का उपयोग करना चाहता हूं, लेकिन मैं इसका उपयोग कैसे नहीं कर सकता। हस्ताक्षर कहता है कि इसे ArgumentError (तर्क, संदेश) के रूप में जाना जाना चाहिए, लेकिन मैं यह नहीं समझ सकता कि argument क्या होना चाहिए। मुझे लगता है कि यह पार्सर ऑब्जेक्ट का कुछ हिस्सा होना चाहिए, लेकिन मुझे इसके लिए कोई दस्तावेज नहीं मिला।

35
आप इसे मौजूदा एक्शन क्लास के भीतर उपयोग कर सकते हैं, जैसे मौजूदा वर्ग करते हैं। लेकिन मैं पार्सर के बाहर ऐसा करने का कोई कारण नहीं सोच सकता। यह कुछ खास नहीं है - बस त्रुटि संदेश में कार्रवाई नाम जोड़ता है। कोड में इसका उपयोग अध्ययन करें।
जोड़ा लेखक hpaulj, स्रोत
जोड़ा लेखक DavidRR, स्रोत

2 उत्तर

स्रोत दस्तावेज़ से:

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

कन्स्ट्रक्टर का तर्क पैरामीटर एक्शन ऑब्जेक्ट है जिससे अपवाद उठाया जाता है। आम तौर पर इसे एक्शन </कोड> सबक्लास के बाहर उठाने की कोई आवश्यकता नहीं होती है, और जब इसे उप-वर्गीकरण करते हैं, तो इसे स्पष्ट रूप से बढ़ाने की आवश्यकता नहीं होती है; आप आमतौर पर ValueError (या जो कुछ भी उचित है) उठाते हैं।

0 और 1 के बीच मूल्यों को फ़्लोट करें

आपकी टिप्पणी के संबंध में, आप केवल 0 और 1 के बीच फ़्लोटिंग पॉइंट मान स्वीकार करना चाहते हैं। इसके लिए आपको कस्टम प्रकारों को परिभाषित करने की क्षमता का उपयोग करना चाहिए। उदाहरण के लिए आप इसे कर सकते हैं:

def percentFloat (string):
    value = float(string)
    if value < 0 or value > 1:
        raise argparse.ArgumentTypeError('Value has to be between 0 and 1')
    return value

parser = argparse.ArgumentParser()
parser.add_argument('test', type=percentFloat)
parser.parse_args()

ध्यान दें कि यह गैर-फ्लोट के खिलाफ भी सुरक्षित है क्योंकि float (string) गैर-फ़्लोट के लिए ValueError उठाएगा जो argparse द्वारा अमान्य प्रकार की त्रुटि को ट्रिगर करता है </कोड> मॉड्यूल। ArgumentTypeError निर्दिष्ट करने का एक तरीका है एक कस्टम त्रुटि संदेश।

परस्पर अनन्य पैरामीटर

For परस्पर अनन्य पैरामीटर, you should use argparse.add_mutually_exclusive_group.

पैरामीटर निर्भरता

पैरामीटर निर्भरता isn’t really something that should be done by the argument parser. For semantic details, you should instead simply do it yourself:

args = parser.parse_args()
if args.w and not args.p:
    parser.error('-p is required when -w is set.')

आप कस्टम बढ़ाने के लिए ArgumentParser.error का उपयोग कर सकते हैं त्रुटि संदेश जो प्रोग्राम को बाधित करेगा और कंसोल पर प्रिंट करेगा।

लेकिन निश्चित रूप से ऐसी मूल स्थिति में यह संभवतः -p अनुमानित होने पर अनुमान लगाने के लिए बहुत अधिक समझ में आ जाएगा।

49
जोड़ा
यह सही नहीं है। अगर मैं सिर्फ मूल्य भेजता हूं, तो मुझे विशेषताएँ त्रुटि: 'float' ऑब्जेक्ट में कोई विशेषता नहीं है 'option_strings'
जोड़ा लेखक asmeurer, स्रोत
और वैसे, मैं इसका उपयोग करना चाहता हूं क्योंकि मैं टाइपिंग करना चाहता हूं कि मॉड्यूल सीधे समर्थन नहीं करता है। उदाहरण के लिए, मुझे एक फ्लोटिंग पॉइंट वैल्यू चाहिए जो 0 और 1 के बीच है। Argparse आपको यह निर्दिष्ट करने देता है कि यह एक फ्लोट होना चाहिए, लेकिन मुझे सीमा को मैन्युअल रूप से जांचना होगा। यह मान गलत होने पर उत्सर्जित करने में सही त्रुटि की तरह लगता है।
जोड़ा लेखक asmeurer, स्रोत
डाउनवोट इसलिए है क्योंकि जवाब गलत है। ArgumentError (1.1, "सीमा से बाहर मूल्य") ऊपर वर्णित जैसा विशेषता एरर बढ़ाता है। यह किसी प्रकार की आंतरिक तर्क वस्तु होने की आवश्यकता है, लेकिन मैं यह नहीं समझ सकता कि क्या। और वैसे, जब आप ऐसा करना चाहते हैं तो एक और उदाहरण यह है कि जब आप तर्कों पर एक गैर-तुच्छ निर्भरता को परिभाषित करना चाहते हैं, जहां तक ​​मैं कह सकता हूं, Argparse मॉड्यूल सीधे समर्थन नहीं करता है। -w विकल्प की तरह कुछ -p विकल्प, या -n और -N परस्पर अनन्य हैं।
जोड़ा लेखक asmeurer, स्रोत
धन्यवाद। वह पार्सर। आतंक वह था जिसे मैं ढूंढ रहा था।
जोड़ा लेखक asmeurer, स्रोत
@asmeurer ने मुझे यह जवाब देने के लिए एक उत्तर देने के लिए अपना जवाब संपादित किया।
जोड़ा लेखक poke, स्रोत
मेरा जवाब अपडेट किया गया।
जोड़ा लेखक poke, स्रोत

जबकि parser.error() अधिकांश लोग शायद चाहते हैं, Argparse.ArgumentError() का उपयोग करना भी संभव है (जैसा सवाल पूछता है।) आपको तर्क के संदर्भ की आवश्यकता है, जैसे bar_arg नीचे दिए गए उदाहरण में:

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--foo')
bar_arg = parser.add_argument('--bar')

args = parser.parse_args()
if args.bar == 'xyzzy':
    raise argparse.ArgumentError(bar_arg, "Can't be 'xyzzy'")

if args.foo == 'xyzzy':
    parser.error("Can't be 'xyzzy'")

इसका परिणाम नीचे दिए गए जैसा होगा:

$ python argparse_test.py --foo xyzzy
usage: argparse_test.py [-h] [--foo FOO] [--bar BAR]
argparse_test.py: error: Can't be 'xyzzy'

$ python argparse_test.py --bar xyzzy
Traceback (most recent call last):
  File "argparse_test.py", line 10, in 
    raise argparse.ArgumentError(bar_arg, "Can't be 'xyzzy'")
argparse.ArgumentError: argument --bar: Can't be 'xyzzy'
11
जोड़ा
पार्सर के बाहर ArgumentError का उपयोग करने का यह एक अच्छा उदाहरण है, लेकिन शायद parser.error का उपयोग करने के लिए निम्न है।
जोड़ा लेखक hpaulj, स्रोत
खैर, अगर आप अपना त्रुटि संदेश अच्छी तरह से लिखते हैं, तो आप सुनिश्चित होंगे कि उल्लेख स्विच अपमानजनक था। प्रत्येक जोड़ा तर्क के लिए एक अलग चर बनाना बहुत बोझिल हो सकता है ...
जोड़ा लेखक Praveen, स्रोत
@ hpaulj, हाँ, लेकिन ArgumentError का एक लाभ है: यह आपको यह बताता है कि कौन सा स्विच अपराधी था।
जोड़ा लेखक ukrutt, स्रोत
@Praveen यह मुझे लगता है वरीयता का एक सवाल है। मैं खुद को '' - foo 'लिखने के लिए चर को पसंद करता हूं' xyzzy 'नहीं हो सकता है, क्योंकि मुझे तब याद रखना होगा कि स्विच का उचित नाम क्या था (यह आवश्यक नहीं है args के गुण के समान )। लेकिन ईमानदारी से, मुझे लगता है कि parser.error() में डिफ़ॉल्ट रूप से अपमानजनक स्विच का नाम शामिल होना चाहिए।
जोड़ा लेखक ukrutt, स्रोत