Python Language
पार्सिंग कमांड लाइन तर्क

परिचय

नमस्कार, अर्गपर्स में संसार

निम्न प्रोग्राम उपयोगकर्ता को नमस्ते कहता है। यह एक स्थितिगत तर्क, उपयोगकर्ता का नाम लेता है, और इसे ग्रीटिंग भी कहा जा सकता है।

import argparse

parser = argparse.ArgumentParser()

parser.add_argument('name', 
    help='name of user'
)

parser.add_argument('-g', '--greeting', 
    default='Hello',
    help='optional alternate greeting'
)

args = parser.parse_args()

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

$ python hello.py --help
usage: hello.py [-h] [-g GREETING] name

positional arguments:
  name                  name of user

optional arguments:
  -h, --help            show this help message and exit
  -g GREETING, --greeting GREETING
                        optional alternate greeting

$ python hello.py world
Hello, world!
$ python hello.py John -g Howdy
Howdy, John!

अधिक जानकारी के लिए कृपया argparse प्रलेखन पढ़ें।

Docopt के साथ मूल उदाहरण

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

"""
Usage:
    script_name.py [-a] [-b] <path>

Options:
    -a            Print all the things.
    -b            Get more bees into the path.
"""
from docopt import docopt


if __name__ == "__main__":
    args = docopt(__doc__)
    import pprint; pprint.pprint(args)

नमूना चलता है:

$ python script_name.py
Usage:
    script_name.py [-a] [-b] <path>
$ python script_name.py something
{'-a': False,
 '-b': False,
 '<path>': 'something'}
$ python script_name.py something -a
{'-a': True,
 '-b': False,
 '<path>': 'something'}
$ python script_name.py -b something -a
{'-a': True,
 '-b': True,
 '<path>': 'something'}

अर्गपर्स के साथ परस्पर अनन्य तर्क स्थापित करना

यदि आप चाहते हैं कि दो या अधिक तर्क परस्पर अनन्य हों। आप फ़ंक्शन argparse.ArgumentParser.add_mutually_exclusive_group() उपयोग कर सकते हैं। नीचे दिए गए उदाहरण में, या तो फू या बार मौजूद हो सकता है लेकिन एक ही समय में दोनों नहीं।

import argparse

parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument("-f", "--foo")
group.add_argument("-b", "--bar")
args = parser.parse_args()
print "foo = ", args.foo
print "bar = ", args.bar

यदि आप स्क्रिप्ट को दोनों --foo और --bar तर्कों को निर्दिष्ट करने का प्रयास करते हैं, तो स्क्रिप्ट नीचे संदेश के साथ शिकायत करेगी।

error: argument -b/--bar: not allowed with argument -f/--foo

Argv के साथ कमांड लाइन तर्कों का उपयोग करना

जब भी एक पाइथन स्क्रिप्ट कमांड लाइन से मंगाई जाती है, तो उपयोगकर्ता अतिरिक्त कमांड लाइन तर्क की आपूर्ति कर सकता है जो स्क्रिप्ट पर पारित हो जाएगा। ये तर्क प्रोग्रामर को सिस्टम वेरिएबल sys.argv से उपलब्ध होंगे ("argv" एक पारंपरिक नाम है जिसका उपयोग अधिकांश प्रोग्रामिंग भाषाओं में किया जाता है, और इसका अर्थ है " arg ument v ector")।

अधिवेशन के द्वारा, sys.argv सूची में पहला तत्व पायथन लिपि का नाम है, जबकि बाकी तत्व लिपि को लागू करते समय उपयोगकर्ता द्वारा पारित टोकन हैं।

# cli.py
import sys
print(sys.argv)

$ python cli.py
=> ['cli.py']

$ python cli.py fizz
=> ['cli.py', 'fizz']

$ python cli.py fizz buzz
=> ['cli.py', 'fizz', 'buzz']

यहाँ कैसे argv का उपयोग करने का एक और उदाहरण है। हम पहले sys.argv के प्रारंभिक तत्व को हटा देते हैं क्योंकि इसमें स्क्रिप्ट का नाम होता है। फिर हम बाकी तर्कों को एक वाक्य में जोड़ते हैं, और अंत में उस वाक्य को प्रिंट करते हैं जो वर्तमान में लॉग-इन उपयोगकर्ता (ताकि यह एक चैट प्रोग्राम का अनुकरण करता है) के नाम को प्रस्तुत करता है।

import getpass
import sys

words = sys.argv[1:]
sentence = " ".join(words)
print("[%s] %s" % (getpass.getuser(), sentence))

एल्गोरिथ्म आमतौर पर "मैन्युअल रूप से" का उपयोग किया जाता है जब गैर-स्थिति संबंधी तर्कों की एक संख्या को sys.argv सूची पर पुनरावृति करना होता है। एक तरीका यह है कि सूची पर जाएं और इसके प्रत्येक तत्व को पॉप करें:

# reverse and copy sys.argv
argv = reversed(sys.argv)
# extract the first element
arg = argv.pop()
# stop iterating when there's no more args to pop()
while len(argv) > 0:
    if arg in ('-f', '--foo'):
        print('seen foo!')
    elif arg in ('-b', '--bar'):
        print('seen bar!')
    elif arg in ('-a', '--with-arg'):
        arg = arg.pop()
        print('seen value: {}'.format(arg))
    # get the next value
    arg = argv.pop()

कस्टम पार्सर एरगपर्स के साथ त्रुटि संदेश

आप अपनी स्क्रिप्ट की जरूरतों के अनुसार पार्सर त्रुटि संदेश बना सकते हैं। यह argparse.ArgumentParser.error फ़ंक्शन के माध्यम से argparse.ArgumentParser.error है। उदाहरण के नीचे से पता चलता है स्क्रिप्ट एक के उपयोग और करने के लिए एक त्रुटि संदेश मुद्रण stderr जब --foo दिया जाता है लेकिन नहीं --bar ।

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("-f", "--foo")
parser.add_argument("-b", "--bar")
args = parser.parse_args()
if args.foo and args.bar is None:
    parser.error("--foo requires --bar. You did not specify bar.")

print "foo =", args.foo
print "bar =", args.bar

अपना स्क्रिप्ट नाम मान python sample.py --foo ds_in_fridge , और हम चलाते हैं: python sample.py --foo ds_in_fridge

स्क्रिप्ट निम्नलिखित के साथ शिकायत करेगी:

usage: sample.py [-h] [-f FOO] [-b BAR]
sample.py: error: --foo requires --bar. You did not specify bar.

Argparse.add_argument_group () के साथ तर्कों का वैचारिक समूहन

जब आप एक Argparse ArgumentParser () बनाते हैं और '-h' के साथ अपना प्रोग्राम चलाते हैं, तो आपको एक स्वचालित उपयोग संदेश मिलता है जिसमें बताया गया है कि आप किस तर्क के साथ अपना सॉफ़्टवेयर चला सकते हैं। डिफ़ॉल्ट रूप से, स्थिति संबंधी तर्क और सशर्त तर्क को दो श्रेणियों में विभाजित किया जाता है, उदाहरण के लिए, यहां एक छोटी स्क्रिप्ट (उदाहरण थिंकपैड) और आउटपुट है जब आप python example.py -h चलाते हैं।

import argparse

parser = argparse.ArgumentParser(description='Simple example')
parser.add_argument('name', help='Who to greet', default='World')
parser.add_argument('--bar_this')
parser.add_argument('--bar_that')
parser.add_argument('--foo_this')
parser.add_argument('--foo_that')
args = parser.parse_args()

usage: example.py [-h] [--bar_this BAR_THIS] [--bar_that BAR_THAT]
                        [--foo_this FOO_THIS] [--foo_that FOO_THAT]
                        name

Simple example

positional arguments:
  name                 Who to greet

optional arguments:
  -h, --help           show this help message and exit
  --bar_this BAR_THIS
  --bar_that BAR_THAT
  --foo_this FOO_THIS
  --foo_that FOO_THAT

ऐसी कुछ स्थितियाँ हैं जहाँ आप अपने तर्कों को अपने उपयोगकर्ता की सहायता के लिए आगे वैचारिक वर्गों में अलग करना चाहते हैं। उदाहरण के लिए, आप एक समूह में सभी इनपुट विकल्प और दूसरे में सभी आउटपुट स्वरूपण विकल्प रखना चाह सकते हैं। ऊपर के उदाहरण अलग करने के लिए समायोजित किया जा सकता --foo_* से आर्ग --bar_* तो जैसे आर्ग।

import argparse

parser = argparse.ArgumentParser(description='Simple example')
parser.add_argument('name', help='Who to greet', default='World')
# Create two argument groups
foo_group = parser.add_argument_group(title='Foo options')
bar_group = parser.add_argument_group(title='Bar options')
# Add arguments to those groups
foo_group.add_argument('--bar_this')
foo_group.add_argument('--bar_that')
bar_group.add_argument('--foo_this')
bar_group.add_argument('--foo_that')
args = parser.parse_args()

जब python example.py -h चलाया जाता है तो यह आउटपुट उत्पन्न करता है:

usage: example.py [-h] [--bar_this BAR_THIS] [--bar_that BAR_THAT]
                        [--foo_this FOO_THIS] [--foo_that FOO_THAT]
                        name

Simple example

positional arguments:
  name                 Who to greet

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

Foo options:
  --bar_this BAR_THIS
  --bar_that BAR_THAT

Bar options:
  --foo_this FOO_THIS
  --foo_that FOO_THAT

Docopt और docopt_dispatch के साथ उन्नत उदाहरण

Docopt के साथ, [docopt_dispatch] के साथ आप अपने प्रवेश-बिंदु मॉड्यूल के __doc__ चर में अपने --help को शिल्प करते हैं। वहां, आप डॉक्टर स्ट्रिंग को तर्क के रूप में dispatch कहते हैं, इसलिए यह उस पर पार्सर को चला सकता है।

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

यह dispatch.on है। इसके लिए डेकोरेटर है: आप इसे तर्क या तर्क देते हैं जो फ़ंक्शन को ट्रिगर करना चाहिए, और उस फ़ंक्शन को पैरामीटर के रूप में मिलान मूल्यों के साथ निष्पादित किया जाएगा।

"""Run something in development or production mode.

Usage: run.py --development <host> <port>
       run.py --production <host> <port>
       run.py items add <item>
       run.py items delete <item>

"""
from docopt_dispatch import dispatch

@dispatch.on('--development')
def development(host, port, **kwargs):
    print('in *development* mode')

@dispatch.on('--production')
def development(host, port, **kwargs):
    print('in *production* mode')

@dispatch.on('items', 'add')
def items_add(item, **kwargs):
    print('adding item...')

@dispatch.on('items', 'delete')
def items_delete(item, **kwargs):
    print('deleting item...')

if __name__ == '__main__':
    dispatch(__doc__)