वैकल्पिक तर्कों के मनमानी सेट को कैप्चर करने के लिए argparse का उपयोग करना संभव है?

Question

वैकल्पिक तर्कों के मनमानी सेट को कैप्चर करने के लिए argparse का उपयोग करना संभव है?

उदाहरण के लिए दोनों को निम्नलिखित इनपुट के रूप में स्वीकार किया जाना चाहिए:

python script.py required_arg1 --var1 value1 --var2 value2 --var3 value3 

python script.py required_arg1 --varA valueA --var2 value2 --varB valueB 

एक प्रायोरी मैं क्या वैकल्पिक तर्क निर्दिष्ट किया जाएगा पता नहीं है प्राप्त होता है लेकिन उन्हें तदनुसार संभाल होगा।

Answer 1

यह एक hackish तरीका की तरह है, लेकिन यह बहुत अच्छी तरह से काम करता है:

जांचें, कौन से तर्क जोड़े नहीं गए हैं और उन्हें

जोड़ें

parser=argparse.ArgumentParser() 
parser.add_argument("foo") 
parser.add_argument("-bar", type=int) 
#parser can have any arguments, whatever you want! 

parsed, unknown = parser.parse_known_args() #this is an 'internal' method 
# which returns 'parsed', the same as what parse_args() would return 
# and 'unknown', the remainder of that 
# the difference to parse_args() is that it does not exit when it finds redundant arguments 

for arg in unknown: 
    if arg.startswith(("-", "--")): 
     #you can pass any arguments to add_argument 
     parser.add_argument(arg, type=<your type>, ...) 

args=parser.parse_args() 

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

python arbitrary_parser.py ha -bar 12 -lol huhu -rofl haha 

फिर परिणाम

args = Namespace(bar=12, foo='ha', lol='huhu', rofl='haha') 

Answer 2

संभव है? संभवतः, लेकिन मैं इसकी सिफारिश नहीं करता। argparse इस प्रकार के इनपुट को पार्स करने के लिए सबसे अच्छा टूल नहीं है, या इसके विपरीत, यह argparse परिप्रेक्ष्य से एक खराब तर्क विनिर्देश है।

क्या आपने सोचा है कि usage लाइन कैसा दिखना चाहिए? यह आपके उपयोगकर्ताओं को कैसे समझाएगा?

आप sys.argv से सीधे इस काम को कैसे पार्स करेंगे? ऐसा लगता है कि आप 3 टुकड़े एकत्र कर पाया:

prog = sys.argv[0] 
arg1 = sys.argv[1] 
keys = sys.argv[2::2] 
# maybe strip -- off each 
values = sys.argv[3::2] 
kvdict = {k:v for k, v in zip(keys, values)} 

अन्य अतः सामान्य key:value जोड़े के बारे में पूछ सवाल कर रहे हैं। चीजों की तरह:

--args key1:value1 key2:value2 

यह और nargs='*' से संभाला जा सकता है कि एक कार्रवाई key द्वारा : (या =) और दुकानों बातों पर प्रत्येक इनपुट स्ट्रिंग विभाजित होता है।

आपकी आवश्यकता कम से कम argparse उपयोग करने योग्य है क्योंकि इसे argv में स्ट्रिंग के साथ तर्क झंडे मिलान करने के पूरे विचार को छोड़ना आवश्यक है। इसके लिए, कुछ सामान्य argparse पार्सिंग को बंद करने की आवश्यकता है।

ऐसा लगता है कि मैं कुछ साल पहले एक ही बात का सुझाव दिया

Parse non-pre-defined argument

या उससे पहले

Using argparse to parse arguments of form "arg= val"