python - कमांड लाइन तर्क कैसे पढ़/संसाधित करें?




command-line command-line-arguments (12)

कृपया ध्यान दें कि पाइथन के संस्करण 2.7 में ऑप्टपरसे को हटा दिया गया था:

http://docs.python.org/2/library/optparse.htmlArgparse प्रतिस्थापन है: http://docs.python.org/2/library/argparse.html#module-argparse

मानक पुस्तकालय में निम्नलिखित मॉड्यूल हैं:

  • getopt मॉड्यूल जीएनयू getopt के समान है।
  • optparse मॉड्यूल ऑब्जेक्ट उन्मुख कमांड लाइन विकल्प पार्सिंग प्रदान करता है।

यहां एक उदाहरण दिया गया है जो बाद वाले दस्तावेज़ों का उपयोग करता है:

from optparse import OptionParser

parser = OptionParser()
parser.add_option("-f", "--file", dest="filename",
                  help="write report to FILE", metavar="FILE")
parser.add_option("-q", "--quiet",
                  action="store_false", dest="verbose", default=True,
                  help="don't print status messages to stdout")

(options, args) = parser.parse_args()

optparse समर्थन करता है (अन्य चीजों के साथ):

  • किसी भी क्रम में एकाधिक विकल्प।
  • लघु और लंबे विकल्प।
  • डिफ़ॉल्ट मान।
  • उपयोग सहायता संदेश का निर्माण।

अगर आपको कुछ तेज और बहुत लचीला नहीं चाहिए

main.py:

import sys

first_name = sys.argv[1]
last_name = sys.argv[2]
print("Hello " + first_name + " " + last_name)

फिर python main.py James Smith

निम्नलिखित आउटपुट का उत्पादन करने के लिए:

हैलो जेम्स स्मिथ


ऐसा करने का एक तरीका sys.argv का उपयोग कर रहा है। यह स्क्रिप्ट नाम को पहला तर्क और आपके द्वारा पारित किए जाने वाले सभी अन्य पैरामीटर के रूप में प्रिंट करेगा।

import sys

for arg in sys.argv:
    print arg

जैसा कि आप optparse देख सकते हैं "ऑप्टपर मॉड्यूल को बहिष्कृत किया गया है और आगे विकसित नहीं किया जाएगा; विकास argparse मॉड्यूल के साथ जारी रहेगा।"


फिर भी एक और विकल्प argh । यह Argparse पर बनाता है, और आपको चीजों को लिखने देता है जैसे:

import argh

# declaring:

def echo(text):
    "Returns given word as is."
    return text

def greet(name, greeting='Hello'):
    "Greets the user with given name. The greeting is customizable."
    return greeting + ', ' + name

# assembling:

parser = argh.ArghParser()
parser.add_commands([echo, greet])

# dispatching:

if __name__ == '__main__':
    parser.dispatch()

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


बस argparse लिए सुसमाचार प्रचार के आसपास जा रहा है जो these कारणों से बेहतर है .. अनिवार्य रूप से:

(लिंक से कॉपी)

  • Argparse मॉड्यूल स्थितित्मक और वैकल्पिक तर्क संभाल सकता है, जबकि optparse केवल वैकल्पिक तर्क संभाल सकता है

  • Argparse आपके कमांड लाइन इंटरफ़ेस की तरह दिखने के बारे में डॉगमैटिक नहीं है - विकल्प विकल्प के रूप में -फाइल या फ़ाइल जैसे विकल्प समर्थित हैं। Optparse व्यावहारिकता पर शुद्धता पसंद करते हुए, इन सुविधाओं का समर्थन करने से मना कर दिया

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

  • Argparse कार्रवाई का समर्थन करता है जो कमांड लाइन तर्कों की एक चर संख्या का उपभोग करता है, जबकि optparse की आवश्यकता है कि तर्कों की सटीक संख्या (जैसे 1, 2, या 3) अग्रिम में जानी जाए

  • Argparse उप-आदेशों को प्रेषित पार्सर्स का समर्थन करता है, जबकि optparse को allow_interspersed_args को सेट करने और पार्सर प्रेषण मैन्युअल रूप से करने की आवश्यकता होती है

और मेरा निजी पसंदीदा:

  • Argparse टाइप और एक्शन पैरामीटर को सरल कॉलबेल के साथ निर्दिष्ट करने के लिए add_argument() को अनुमति देता है, जबकि ऑप्टपरसे को उचित तर्क जांच प्राप्त करने के लिए STORE_ACTIONS या CHECK_METHODS जैसे हैकिंग क्लास विशेषताओं की आवश्यकता होती है

मेरा समाधान entrypoint2 । उदाहरण:

from entrypoint2 import entrypoint
@entrypoint
def add(file, quiet=True): 
    ''' This function writes report.

    :param file: write report to FILE
    :param quiet: don't print status messages to stdout
    '''
    print file,quiet

मदद पाठ:

usage: report.py [-h] [-q] [--debug] file

This function writes report.

positional arguments:
  file         write report to FILE

optional arguments:
  -h, --help   show this help message and exit
  -q, --quiet  don't print status messages to stdout
  --debug      set logging level to DEBUG

मैं docopt को इन अन्य लोगों के लिए एक साधारण विकल्प के रूप में docopt की सलाह देता हूं।

डॉकोपेट एक नई परियोजना है जो आपको अपने सब कुछ लागू करने की आवश्यकता के बजाय अपने --help उपयोग संदेश को पार्स करके काम करती है। आपको बस अपना उपयोग संदेश POSIX प्रारूप में रखना होगा।


argparse stdlib मॉड्यूल भी है (stdlib के optparse मॉड्यूल पर एक "impovement")। Argparse के परिचय से उदाहरण:

# script.py
import argparse

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        'integers', metavar='int', type=int, choices=range(10),
         nargs='+', help='an integer in the range 0..9')
    parser.add_argument(
        '--sum', dest='accumulate', action='store_const', const=sum,
        default=max, help='sum the integers (default: find the max)')

    args = parser.parse_args()
    print(args.accumulate(args.integers))

उपयोग:

$ script.py 1 2 3 4
4

$ script.py --sum 1 2 3 4
10

docopt लाइब्रेरी वास्तव में चालाक है। यह आपके ऐप के उपयोग स्ट्रिंग से एक तर्क dict बनाता है।

डॉकॉप रीडेमे से:

"""Naval Fate.

Usage:
  naval_fate.py ship new <name>...
  naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
  naval_fate.py ship shoot <x> <y>
  naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
  naval_fate.py (-h | --help)
  naval_fate.py --version

Options:
  -h --help     Show this screen.
  --version     Show version.
  --speed=<kn>  Speed in knots [default: 10].
  --moored      Moored (anchored) mine.
  --drifting    Drifting mine.

"""
from docopt import docopt


if __name__ == '__main__':
    arguments = docopt(__doc__, version='Naval Fate 2.0')
    print(arguments)

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                   help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                   const=sum, default=max,
                   help='sum the integers (default: find the max)')

args = parser.parse_args()
print(args.accumulate(args.integers))

Assuming the Python code above is saved into a file called prog.py
$ python prog.py -h

Ref-link: https://docs.python.org/3.3/library/argparse.html

import sys

print "\n".join(sys.argv)

sys.argv एक सूची है जिसमें कमांड लाइन पर स्क्रिप्ट को पारित सभी तर्क शामिल हैं।

मूल रूप से,

import sys
print sys.argv[1:]




command-line-arguments