सरल तर्कपूर्ण उदाहरण चाहते थे: 1 तर्क, 3 परिणाम

Question

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

Comments

तो बस sys.argvआप चाहते हैं कि तर्क के लिए जाँच करें ...

— JBernardo

कभी पीएसी की कोशिश की ? यह महान प्रलेखन के साथ argparse पर आवरण का उपयोग करना आसान है ।

— kirbyfan64sos

वो आप नहीं हैं। यह बड़ा मुश्किल है। यह आपको सितारों की यात्रा पर ले जाने की कोशिश कर रहा है और परवाह नहीं करता कि आप कहाँ थे।

— फ्लोरियन हीगल

पागल "

— पायथोनिक

हर जगह छोटे शुरुआती दिमाग के लिए खड़े होने के लिए आप मैट विल्की को आशीर्वाद दें।

— पोल्का

Answer 1

मूल प्रश्न के बारे में मेरी समझ दो-गुना है। सबसे पहले, सबसे सरल संभव विवाद उदाहरण के संदर्भ में, मुझे आश्चर्य है कि मैंने इसे यहां नहीं देखा है। बेशक, मृत-सरल होने के लिए, यह बहुत कम शक्ति के साथ सभी ओवरहेड है, लेकिन यह आपको शुरू कर सकता है।

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("a")
args = parser.parse_args()

if args.a == 'magic.name':
    print 'You nailed it!'

लेकिन इस स्थैतिक तर्क की अब आवश्यकता है। यदि आप इस कार्यक्रम को लागू करते समय इसे छोड़ देते हैं, तो आपको लापता तर्कों के बारे में एक त्रुटि मिलेगी। यह मुझे मूल प्रश्न के दूसरे भाग की ओर ले जाता है। मैट विल्की नामांकित लेबल (- गोद लेने वाले लेबल) के बिना एक ही वैकल्पिक तर्क चाहते हैं । मेरा सुझाव निम्नानुसार कोड को संशोधित करना होगा:

...
parser.add_argument("a", nargs='?', default="check_string_for_empty")
...
if args.a == 'check_string_for_empty':
    print 'I can tell that no argument was given and I can deal with that here.'
elif args.a == 'magic.name':
    print 'You nailed it!'
else:
    print args.a

अच्छी तरह से एक और अधिक सुंदर समाधान हो सकता है, लेकिन यह काम करता है और न्यूनतम है।

Comments

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

— मैट विल्की

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

— mightypile

Answer 2

यहाँ मैं इसके साथ argparse(कई आर्ग के साथ) कर रहा हूँ:

parser = argparse.ArgumentParser(description='Description of your program')
parser.add_argument('-f','--foo', help='Description for foo argument', required=True)
parser.add_argument('-b','--bar', help='Description for bar argument', required=True)
args = vars(parser.parse_args())

args एक शब्दकोश होगा जिसमें तर्क होंगे:

if args['foo'] == 'Hello':
    # code here

if args['bar'] == 'World':
    # code here

आपके मामले में केवल एक तर्क जोड़ें।

Comments

जैसा कि अन्य उत्तर के लिए मेरी टिप्पणी में उल्लेख किया गया है, मैं चाहता हूं कि आर्गैप्से की स्वचालित मदद स्वरूपण रखना चाहता हूं, लेकिन एक अनाम तर्क रखने का विकल्प प्रतीत नहीं होता है (अधिक संभावना है कि मुझे यह समझ में नहीं आता जब मैं इसे देखता हूं ), उदाहरण के लिए एक foo.py --action installया foo.py --action removeबस के बजाय की जरूरत हैfoo.py install

— मैट wilkie

@mattwilkie तब आपको इस तरह की स्थिति के तर्क को परिभाषित करना होगा: parser.add_argument('install', help='Install the app') (ध्यान दें कि आप एक स्थैतिक तर्क को परिभाषित नहीं कर सकते हैं required=True)

— डिएगो नवारो

बहस करने के लिए एक noob के रूप में, इस जवाब ने वास्तव में मदद की क्योंकि मुझे नहीं पता था कि वे पास होने के बाद विकल्पों को कहां ढूंढेंगे । दूसरे शब्दों में, मुझे यह समझने की जरूरत है argsकि ऊपर के रूप में तानाशाही कैसे उत्पन्न हुई।

— mrKelley

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

— ola

व्यक्तिगत तौर पर मैं यह पहुँच तर्क के रूप में क्लीनर को खोजने args.fooऔर args.barबजाय शब्दकोश वाक्य रचना की। किसी भी तरह से निश्चित रूप से ठीक है, लेकिन आर्ग्स वास्तव में एक शब्दकोष नहीं बल्कि एक argparse.Namespaceवस्तु है।

— माइकल जूनियर

Answer 3

argparseप्रलेखन यथोचित अच्छा है, लेकिन बाहर कुछ उपयोगी जानकारी के पत्ते जो स्पष्ट नहीं हो सकता है। (@ डिएगो नवारो ने पहले ही इसमें से कुछ का उल्लेख किया था, लेकिन मैं उनके उत्तर पर थोड़ा विस्तार करने की कोशिश करूंगा।) मूल उपयोग इस प्रकार है:

parser = argparse.ArgumentParser()
parser.add_argument('-f', '--my-foo', default='foobar')
parser.add_argument('-b', '--bar-value', default=3.14)
args = parser.parse_args()

जिस ऑब्जेक्ट से आप वापस आते हैं parse_args()वह एक 'नेमस्पेस' ऑब्जेक्ट है: एक ऑब्जेक्ट जिसका सदस्य चर आपके कमांड-लाइन तर्कों के नाम पर रखा गया है। Namespaceवस्तु कैसे आप अपने तर्क और उनके साथ जुड़े मानों तक पहुंच है:

args = parser.parse_args()
print args.my_foo
print args.bar_value

(ध्यान दें कि argparseचर का नामकरण करते समय आपके तर्क नामों में '-' बदल जाता है।)

कई स्थितियों में आप झंडे के रूप में तर्कों का उपयोग करना चाह सकते हैं, जिनका कोई मूल्य नहीं है। आप इसे इस तरह से तैयार कर सकते हैं:

parser.add_argument('--foo', action='store_true')
parser.add_argument('--no-foo', action='store_false')

उपरोक्त मूल्य सच के साथ 'फू' नाम के चर बनाएंगे, और क्रमशः मूल्य गलत के साथ 'no_foo':

if (args.foo):
    print "foo is true"

if (args.no_foo is False):
    print "nofoo is false"

ध्यान दें कि आप एक तर्क जोड़ते समय "आवश्यक" विकल्प का उपयोग कर सकते हैं:

parser.add_argument('-o', '--output', required=True)

इस तरह यदि आप कमांड लाइन पर इस तर्क को छोड़ देते argparseहैं, तो यह आपको बता देगा कि यह गायब है और आपकी स्क्रिप्ट का निष्पादन रोक देगा।

अंत में, ध्यान दें कि varsफ़ंक्शन का उपयोग करके अपने तर्कों की एक तानाशाही संरचना बनाना संभव है , यदि यह आपके लिए जीवन को आसान बनाता है।

args = parser.parse_args()
argsdict = vars(args)
print argsdict['my_foo']
print argsdict['bar_value']

जैसा कि आप देख सकते हैं, varsअपने तर्क नामों के साथ एक कुंजी देता है जैसे कि कुंजी और उनके मान, एर, मान।

बहुत सारे अन्य विकल्प और चीजें हैं जो आप कर सकते हैं, लेकिन यह सबसे आवश्यक, सामान्य उपयोग परिदृश्यों को कवर करना चाहिए।

Comments

का फ़ायदा क्या है '-f'और '-b'? आप इसे क्यों नहीं छोड़ सकते?

— user2763361

प्रत्येक रनटाइम विकल्प के लिए 'शॉर्ट फॉर्म' (एक डैश) और 'लॉन्ग फॉर्म' (दो डैश) संस्करण दोनों का होना बहुत पारंपरिक है। आप इसे देखेंगे, उदाहरण के लिए, लगभग हर मानक यूनिक्स / लिनक्स उपयोगिता में; करो man cpया man lsतुम पाओगे कि कई विकल्प दोनों स्वादों (जैसे -f, --force) में आते हैं । संभवतः व्यापक रूप से अलग-अलग कारण हैं कि लोग एक या दूसरे को क्यों पसंद करते हैं, लेकिन किसी भी मामले में यह आपके कार्यक्रम में दोनों रूपों को उपलब्ध कराने के लिए बहुत मानक है।

— DMH

Answer 4

मैट, चापलूसी में स्थितीय मापदंडों के बारे में पूछ रहा है, और मैं इस बात से सहमत हूं कि पायथन प्रलेखन में इस पहलू की कमी है। ~ 20 विषम पृष्ठों में एकल, पूर्ण उदाहरण नहीं है, जो स्थितिगत मापदंडों को पार्स करने और उपयोग करने दोनों को दर्शाता है ।

अन्य उत्तरों में से कोई भी यहाँ स्थितीय मापदंडों का पूर्ण उदाहरण नहीं दिखाता है, इसलिए, यहाँ एक पूर्ण उदाहरण है:

# tested with python 2.7.1
import argparse

parser = argparse.ArgumentParser(description="An argparse example")

parser.add_argument('action', help='The action to take (e.g. install, remove, etc.)')
parser.add_argument('foo-bar', help='Hyphens are cumbersome in positional arguments')

args = parser.parse_args()

if args.action == "install":
    print("You asked for installation")
else:
    print("You asked for something other than installation")

# The following do not work:
# print(args.foo-bar)
# print(args.foo_bar)

# But this works:
print(getattr(args, 'foo-bar'))

जिस चीज ने मुझे फेंक दिया, वह यह है कि argparse नामित तर्क "--foo-bar" को "foo_bar" में बदल देगा, लेकिन "foo-bar" नाम का एक स्थितीय पैरामीटर "foo-bar" के रूप में रहता है, जिससे यह कम स्पष्ट हो जाता है कि कैसे इसे अपने प्रोग्राम में उपयोग करें।

मेरे उदाहरण के अंत के पास दो पंक्तियों को नोटिस करें - उनमें से कोई भी फू-बार स्थितीय परम के मूल्य को प्राप्त करने के लिए काम नहीं करेगा। पहला एक स्पष्ट रूप से गलत है (यह एक अंकगणितीय अभिव्यक्ति है args.foo माइनस बार), लेकिन दूसरा भी काम नहीं करता है:

AttributeError: 'Namespace' object has no attribute 'foo_bar'

यदि आप foo-barविशेषता का उपयोग करना चाहते हैं , तो आपको उपयोग करना होगा getattr, जैसा कि मेरे उदाहरण की अंतिम पंक्ति में देखा गया है। पागल क्या है कि अगर आपने dest=foo_barसंपत्ति के नाम को उस चीज़ में बदलने के लिए उपयोग करने का प्रयास किया है जिसे एक्सेस करना आसान है, तो आपको वास्तव में विचित्र त्रुटि मिलेगी:

ValueError: dest supplied twice for positional argument

यहां बताया गया है कि ऊपर का उदाहरण कैसे चलता है:

$ python test.py
usage: test.py [-h] action foo-bar
test.py: error: too few arguments

$ python test.py -h
usage: test.py [-h] action foo-bar

An argparse example

positional arguments:
  action      The action to take (e.g. install, remove, etc.)
  foo-bar     Hyphens are cumbersome in positional arguments

optional arguments:
  -h, --help  show this help message and exit

$ python test.py install foo
You asked for installation
foo

Comments

nargs='?'stackoverflow.com/questions/4480075/… के

— झुकाव है

तथ्य यह है कि एक स्थिति foo-barमें तब्दील नहीं किया foo_barजाता है कि Bugs.python.org/issue15125 में संबोधित किया गया है ।

— हंपुलज

मुझे लगता है कि इस बग के लिए एक आसान समाधान केवल "फू-बार" के बजाय "foo_bar" तर्क को कॉल करना है, फिर print args.foo_barकाम करता है। चूंकि यह एक स्थितिगत तर्क है, लिपि को कॉल करते समय आपको नाम निर्दिष्ट करने की आवश्यकता नहीं है, इसलिए यह उपयोगकर्ता के लिए कोई मायने नहीं रखता है।

— लूजर

@ ल्युटर आप सही हैं, तर्क का नाम बदलना आसान है, लेकिन बग रिपोर्ट के लेखक एक अच्छा मामला बनाते हैं कि अनावश्यक संज्ञानात्मक भार के कारण यह अभी भी एक मिसफिट है। अर्गपर्स का उपयोग करते समय, किसी को विकल्प और तर्कों के लिए अलग-अलग नामकरण सम्मेलनों को रोकना और वापस बुलाना चाहिए। Bugs.python.org/msg164968 देखें ।

— मार्क ई। हासे

@mehaase मैं पूरी तरह से सहमत हूं कि यह एक मिसफिट है जिसे ठीक किया जाना चाहिए। मुझे लगता है कि तर्क का नाम बदलना आसान और कम भ्रमित करने वाला वर्कअराउंड है getattr(यह अधिक लचीला भी है क्योंकि यह आपको वैकल्पिक से स्थिति के लिए तर्क को बदलने की अनुमति देता है बिना मूल्य को उपयोग किए कोड बदलने के लिए)।

— ल्युएटर

Answer 5

फिर भी एक और सारांश परिचय, इस पोस्ट से प्रेरित है ।

import argparse

# define functions, classes, etc.

# executes when your script is called from the command-line
if __name__ == "__main__":

    parser = argparse.ArgumentParser()
    #
    # define each option with: parser.add_argument
    #
    args = parser.parse_args() # automatically looks at sys.argv
    #
    # access results with: args.argumentName
    #

तर्क निम्नलिखित के संयोजन के साथ परिभाषित किए गए हैं:

parser.add_argument( 'name', options... )              # positional argument
parser.add_argument( '-x', options... )                # single-char flag
parser.add_argument( '-x', '--long-name', options... ) # flag with long name

---

आम विकल्प हैं:

• मदद : जब --helpप्रयोग किया जाता है इस arg के लिए विवरण ।
• डिफ़ॉल्ट : यदि arg छोड़ दिया गया है तो डिफ़ॉल्ट मान।
• प्रकार : यदि आप उम्मीद करते हैं floatया int(अन्यथा str) है।
• भाग्य : एक ध्वज को एक अलग नाम दें (उदा '-x', '--long-name', dest='longName')।
  नोट: डिफ़ॉल्ट रूप --long-nameसे के साथ पहुँचा हैargs.long_name
• कार्रवाई : कुछ तर्कों की विशेष हैंडलिंग के लिए
  • store_true, store_false: बूलियन आर्ग्स के लिए
    '--foo', action='store_true' => args.foo == True
  • store_const: विकल्प के साथ उपयोग किया जाना हैconst
'--foo', action='store_const', const=42 => args.foo == 42
  • count: दोहराया विकल्पों के लिए, के रूप में./myscript.py -vv
'-v', action='count' => args.v == 2
  • append: दोहराया विकल्पों के लिए, के रूप में./myscript.py --foo 1 --foo 2
'--foo', action='append' => args.foo == ['1', '2']
• आवश्यकता है : यदि ध्वज की आवश्यकता है, या एक स्थितीय तर्क नहीं है।
• नर्ग : एक ध्वज के लिए एन आर्ग पर कब्जा करने के लिए
  ./myscript.py --foo a b => args.foo = ['a', 'b']
• विकल्प : संभव इनपुट को प्रतिबंधित करने के लिए (स्ट्रिंग की सूची के रूप में निर्दिष्ट करें, या अगर type=int)।

Answer 6

नोट Argparse ट्यूटोरियल में अजगर howtos । यह सबसे बुनियादी उदाहरणों से शुरू होता है, जैसे यह:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
args = parser.parse_args()
print(args.square**2)

और कम बुनियादी लोगों के लिए प्रगति करता है।

एक विकल्प के लिए पूर्वनिर्धारित विकल्प के साथ एक उदाहरण है, जैसे कि क्या पूछा जाता है:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2],
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print("the square of {} equals {}".format(args.square, answer))
elif args.verbosity == 1:
    print("{}^2 == {}".format(args.square, answer))
else:
    print(answer)

Comments

यह देखकर अच्छा लगा कि डॉक्स अपडेट कर दिए गए हैं। मैं आपको विश्वास दिलाता हूं कि जब ओपी ने 5 साल पहले सवाल पोस्ट किया था तब यह मामला नहीं था।

— ntwrkguru

Answer 7

यहाँ मैं अपने सीखने की परियोजना में मुख्य रूप से @DMH के लिए धन्यवाद के साथ आया हूँ ...

डेमो कोड:

import argparse

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-f', '--flag', action='store_true', default=False)  # can 'store_false' for no-xxx flags
    parser.add_argument('-r', '--reqd', required=True)
    parser.add_argument('-o', '--opt', default='fallback')
    parser.add_argument('arg', nargs='*') # use '+' for 1 or more args (instead of 0 or more)
    parsed = parser.parse_args()
    # NOTE: args with '-' have it replaced with '_'
    print('Result:',  vars(parsed))
    print('parsed.reqd:', parsed.reqd)

if __name__ == "__main__":
    main()

यह विकसित हो सकता है और ऑनलाइन उपलब्ध है: कमांड-line.py

इस कोड को वर्कआउट देने के लिए स्क्रिप्ट: कमांड-line-demo.sh

Comments

अंत में एक उदाहरण है कि समझ में आता है

— opentokix

Answer 8

आप प्लाक (चारों ओर एक आवरण argparse) का भी उपयोग कर सकते हैं ।

एक बोनस के रूप में यह स्वच्छ सहायता निर्देश उत्पन्न करता है - नीचे देखें।

उदाहरण लिपि:

#!/usr/bin/env python3
def main(
    arg: ('Argument with two possible values', 'positional', None, None, ['A', 'B'])
):
    """General help for application"""
    if arg == 'A':
        print("Argument has value A")
    elif arg == 'B':
        print("Argument has value B")

if __name__ == '__main__':
    import plac
    plac.call(main)

उदाहरण आउटपुट:

कोई तर्क नहीं दिया गया example.py : -

usage: example.py [-h] {A,B}
example.py: error: the following arguments are required: arg

अप्रत्याशित तर्क दिया गया - example.py C :

usage: example.py [-h] {A,B}
example.py: error: argument arg: invalid choice: 'C' (choose from 'A', 'B')

सही तर्क दिया गया - example.py A :

Argument has value A

पूर्ण मदद मेनू (स्वचालित रूप से उत्पन्न) - example.py -h :

usage: example.py [-h] {A,B}

General help for application

positional arguments:
  {A,B}       Argument with two possible values

optional arguments:
  -h, --help  show this help message and exit

संक्षिप्त विवरण:

तर्क का नाम आमतौर पर पैरामीटर नाम ( arg) के बराबर होता है ।

के बाद टपल का उद्घोष argपैरामीटर के के निम्नलिखित अर्थ हैं:

• विवरण (Argument with two possible values )
• तर्क का प्रकार - 'ध्वज', 'विकल्प' या 'स्थिति' में से एक ()positional )
• संक्षिप्तिकरण (None )
• तर्क मान का प्रकार - उदाहरण के लिए। फ्लोट, स्ट्रिंग (None )
• विकल्पों का प्रतिबंधित सेट (['A', 'B'] )

प्रलेखन:

पीएसी के उपयोग के बारे में अधिक जानने के लिए इसके महान दस्तावेज देखें:

प्लेक: कमांड लाइन को पार करना आसान तरीका

Answer 9

दूसरों ने जो कहा है उसे जोड़ने के लिए:

मैं आमतौर पर वैरिएबल नाम निर्दिष्ट करने के लिए 'डेस्ट' पैरामीटर का उपयोग करना पसंद करता हूं और फिर उन वैरिएबल को ग्लोबल नेमस्पेस में रखने के लिए 'ग्लोबल्स ()। अपडेट ()' का उपयोग करता हूं।

उपयोग:

$ python script.py -i "Hello, World!"

कोड:

...
parser.add_argument('-i', '--input', ..., dest='inputted_variable',...)
globals().update(vars(parser.parse_args()))
...
print(inputted_variable) # Prints "Hello, World!"

Comments

आंतरिक रूप से नामस्पेस में मूल्यों argparseका उपयोग getattrऔर उपयोग setattrकरने के लिए। इस तरह यह विचित्र रूप से गठित destमूल्यों से परेशान नहीं है ।

— हंपुलज

Answer 10

अपने स्वयं के व्यक्तिगत कोड सहायता निर्देशों को प्रदर्शित करने के लिए आर्गपर्स का उपयोग करने और '-h' / '--help' को बदलने के लिए एक बहुत ही सरल तरीका है फाल्स में डिफ़ॉल्ट मदद सेट करना, आप जितने चाहें उतने अतिरिक्त .add_arguments जोड़ सकते हैं। :

import argparse

parser = argparse.ArgumentParser(add_help=False)

parser.add_argument('-h', '--help', action='help',
                help='To run this script please provide two arguments')
parser.parse_args()

भागो: अजगर टेस्ट -एचडीएच -एच

आउटपुट:

usage: test.py [-h]

optional arguments:
  -h, --help  To run this script please provide two arguments

Answer 11

सबसे सरल उत्तर!

पीएस जिसने अर्गपर्स के दस्तावेज को लिखा है वह मूर्खतापूर्ण है

अजगर कोड:

import argparse
parser = argparse.ArgumentParser(description='')
parser.add_argument('--o_dct_fname',type=str)
parser.add_argument('--tp',type=str)
parser.add_argument('--new_res_set',type=int)
args = parser.parse_args()
o_dct_fname = args.o_dct_fname
tp = args.tp
new_res_set = args.new_res_set

कोड चल रहा है

python produce_result.py --o_dct_fname o_dct --tp father_child --new_res_set 1

Comments

यह उत्तर मौजूदा उत्तरों की तुलना में कुछ नया / अलग नहीं जोड़ता है।

— एनवीएस अभिलाष

मैं सबसे स्पष्ट हूँ, बात सस्ती है, कोड दिखाओ

— gouxute