जवाबों:
यह उत्तर बताता है optparseकि पुराने पायथन संस्करणों के लिए कौन उपयुक्त है। अजगर 2.7 के लिए और इसके बाद के संस्करण, argparseकी जगह optparse। अधिक जानकारी के लिए यह उत्तर देखें ।
जैसा कि अन्य लोगों ने बताया, आप गेटअप पर ऑप्टपर्स के साथ जाना बेहतर समझते हैं। getopt मानक गेटअप (3) C लाइब्रेरी फ़ंक्शंस का एक-से-एक मैपिंग बहुत अधिक है, और उपयोग करने के लिए बहुत आसान नहीं है।
ऑप्टपर्स, जबकि थोड़ा अधिक क्रियात्मक होने के बाद, बाद में विस्तार करने के लिए बेहतर संरचित और सरल है।
अपने पार्सर में एक विकल्प जोड़ने के लिए यहां एक विशिष्ट रेखा है:
parser.add_option('-q', '--query',
action="store", dest="query",
help="query string", default="spam")यह अपने आप में बहुत कुछ बोलता है; प्रसंस्करण समय पर, यह विकल्प के रूप में -q या --query को स्वीकार करेगा, क्वेरी नामक विशेषता में तर्क को संग्रहीत करेगा और यदि आप इसे निर्दिष्ट नहीं करते हैं तो इसका डिफ़ॉल्ट मान है। यह भी स्व-दस्तावेजीकरण है कि आप सहायता तर्क की घोषणा करते हैं (जो कि -h / - सहायता के साथ चलने पर उपयोग किया जाएगा) विकल्प के साथ वहीं पर होगा।
आमतौर पर आप अपने तर्कों के साथ:
options, args = parser.parse_args()यह, डिफ़ॉल्ट रूप से, स्क्रिप्ट को दिए गए मानक तर्कों (sys.argv [1:]) को पार्स कर देगा
options.query फिर स्क्रिप्ट में आपके द्वारा दिए गए मान पर सेट हो जाएगा।
आप बस एक पार्सर बनाकर करते हैं
parser = optparse.OptionParser()ये सभी मूल बातें हैं जिनकी आपको आवश्यकता है। यहाँ एक पूर्ण पायथन लिपि है जो यह दर्शाती है:
import optparse
parser = optparse.OptionParser()
parser.add_option('-q', '--query',
action="store", dest="query",
help="query string", default="spam")
options, args = parser.parse_args()
print 'Query string:', options.queryअजगर की 5 लाइनें जो आपको मूल बातें दिखाती हैं।
इसे नमूना-संग्रह में सहेजें, और इसे एक बार चलाएं
python sample.pyऔर एक बार साथ
python sample.py --query myqueryइसके अलावा, आप पाएंगे कि ऑप्टपर्स का विस्तार करना बहुत आसान है। मेरी एक परियोजना में, मैंने एक कमांड क्लास बनाया, जो आपको कमांड कमांड के पेड़ में आसानी से घोंसला बनाने की अनुमति देता है। यह ऑप्टपार्स को भारी रूप से एक साथ चेन कमांड के लिए उपयोग करता है। यह कुछ ऐसा नहीं है जिसे मैं आसानी से कुछ पंक्तियों में समझा सकता हूं, लेकिन मुख्य वर्ग के लिए मेरे भंडार में ब्राउज़ करने के लिए स्वतंत्र महसूस कर सकता हूं , साथ ही एक वर्ग जो इसे और विकल्प पार्सर का उपयोग करता है
-mcProfile -o program.profलेकिन एग्रीपेरेचर इन आर्ग्स को कैप्चर कर रहा है, मैं कैसे इन आर्ग्स को अजगर एक्साई पास करूं ???
argparseजाने का रास्ता है। यहाँ इसका उपयोग करने का एक संक्षिप्त सारांश दिया गया है:
1) प्रारंभिक
import argparse
# Instantiate the parser
parser = argparse.ArgumentParser(description='Optional app description')2) तर्क जोड़ें
# Required positional argument
parser.add_argument('pos_arg', type=int,
help='A required integer positional argument')
# Optional positional argument
parser.add_argument('opt_pos_arg', type=int, nargs='?',
help='An optional integer positional argument')
# Optional argument
parser.add_argument('--opt_arg', type=int,
help='An optional integer argument')
# Switch
parser.add_argument('--switch', action='store_true',
help='A boolean switch')3) पार्स
args = parser.parse_args()4) पहुंच
print("Argument values:")
print(args.pos_arg)
print(args.opt_pos_arg)
print(args.opt_arg)
print(args.switch)5) मान की जाँच करें
if args.pos_arg > 10:
parser.error("pos_arg cannot be larger than 10")सही उपयोग:
$ ./app 1 2 --opt_arg 3 --switch
Argument values:
1
2
3
Trueगलत तर्क:
$ ./app foo 2 --opt_arg 3 --switch
usage: convert [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
app: error: argument pos_arg: invalid int value: 'foo'
$ ./app 11 2 --opt_arg 3
Argument values:
11
2
3
False
usage: app [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
convert: error: pos_arg cannot be larger than 10पूरी मदद:
$ ./app -h
usage: app [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
Optional app description
positional arguments:
pos_arg A required integer positional argument
opt_pos_arg An optional integer positional argument
optional arguments:
-h, --help show this help message and exit
--opt_arg OPT_ARG An optional integer argument
--switch A boolean switch2012 के बाद से डॉक्सॉप नामक तर्क पार्सिंग के लिए एक बहुत आसान, शक्तिशाली और वास्तव में अच्छा मॉड्यूल है । यहाँ एक उदाहरण इसके प्रलेखन से लिया गया है:
"""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)तो यह है: कोड के 2 लाइनों के साथ साथ अपने दस्तावेज़ की स्ट्रिंग जो है आवश्यक और आप प्राप्त अपने तर्क पार्स और अपने तर्क वस्तु में उपलब्ध है।
2017 के बाद से एक और अच्छा मॉड्यूल है जिसे पायथन-फायर कहा जाता है । यह शून्य तर्क पार्सिंग करने के साथ आपके कोड के लिए एक CLI इंटरफ़ेस उत्पन्न कर सकता है । यहां प्रलेखन से एक सरल उदाहरण दिया गया है (यह छोटा प्रोग्राम फ़ंक्शन doubleको कमांड लाइन में लाता है):
import fire
class Calculator(object):
def double(self, number):
return 2 * number
if __name__ == '__main__':
fire.Fire(Calculator)कमांड लाइन से, आप चला सकते हैं:
> calculator.py double 10
20
> calculator.py double --number=15
30मुझे क्लिक पसंद है । यह विकल्पों के प्रबंधन को अमूर्त करता है और "(...) सुंदर कमांड लाइन इंटरफेस बनाता है जो कि आवश्यक रूप से छोटे कोड के साथ" "योग्य तरीके से होता है।"
यहाँ उदाहरण उपयोग है:
import click
@click.command()
@click.option('--count', default=1, help='Number of greetings.')
@click.option('--name', prompt='Your name',
help='The person to greet.')
def hello(count, name):
"""Simple program that greets NAME for a total of COUNT times."""
for x in range(count):
click.echo('Hello %s!' % name)
if __name__ == '__main__':
hello()यह स्वचालित रूप से अच्छी तरह से स्वरूपित सहायता पृष्ठ भी उत्पन्न करता है:
$ python hello.py --help
Usage: hello.py [OPTIONS]
Simple program that greets NAME for a total of COUNT times.
Options:
--count INTEGER Number of greetings.
--name TEXT The person to greet.
--help Show this message and exit.सुंदर हर कोई getopt का उपयोग कर रहा है
यहाँ डॉक्टर के लिए उदाहरण कोड है:
import getopt, sys
def main():
try:
opts, args = getopt.getopt(sys.argv[1:], "ho:v", ["help", "output="])
except getopt.GetoptError:
# print help information and exit:
usage()
sys.exit(2)
output = None
verbose = False
for o, a in opts:
if o == "-v":
verbose = True
if o in ("-h", "--help"):
usage()
sys.exit()
if o in ("-o", "--output"):
output = aतो एक शब्द में, यहाँ है कि यह कैसे काम करता है।
आपको दो प्रकार के विकल्प मिले हैं। जो लोग तर्क प्राप्त कर रहे हैं, और जो केवल स्विच की तरह हैं।
sys.argvchar** argvC. में आपका बहुत अधिक है जैसे C में आप पहले तत्व को छोड़ते हैं जो आपके प्रोग्राम का नाम है और केवल तर्कों को पार्स करें:sys.argv[1:]
Getopt.getopt आप तर्क में जो नियम देते हैं, उसके अनुसार इसे पार्स करेंगे।
"ho:v"यहां कम तर्क वर्णन करता है: -ONELETTER। वह :साधन जो -oएक तर्क को स्वीकार करता है।
अंत ["help", "output="]में लंबी बहस ( --MORETHANONELETTER) का वर्णन करता है । =उत्पादन के बाद एक बार फिर से है कि उत्पादन एक तर्क स्वीकार करता है मतलब है।
परिणाम युगल की एक सूची है (विकल्प, तर्क)
यदि कोई विकल्प किसी भी तर्क (जैसे --helpयहाँ) को स्वीकार नहीं करता हैarg भाग एक रिक्त स्ट्रिंग है। आप आमतौर पर इस सूची पर लूप करना चाहते हैं और उदाहरण के रूप में विकल्प नाम का परीक्षण करें।
मैं आशा करता हूं कि इससे आपको मदद मिली होगी।
getoptअजगर के नए संस्करण में इस उत्तर की तारीख से चला गया है बाहर है।
getoptअभी भी पदावनत नहीं किया गया है ... लेकिन इसके प्रलेखन में कहा गया है कि यह मुख्य रूप से C getopt()फ़ंक्शन से परिचित उपयोगकर्ताओं के लिए प्रदान किया गया है , और स्वीकार करता है कि अन्य उपयोगकर्ताओं के argparseलिए एक बेहतर समाधान हो सकता है, जो "कम कोड लिखने और प्राप्त करने की अनुमति देता है" बेहतर मदद और त्रुटि संदेश "।
उपयोग करें optparseजो मानक पुस्तकालय के साथ आता है। उदाहरण के लिए:
#!/usr/bin/env python
import optparse
def main():
p = optparse.OptionParser()
p.add_option('--person', '-p', default="world")
options, arguments = p.parse_args()
print 'Hello %s' % options.person
if __name__ == '__main__':
main()स्रोत: UNIX कमांड लाइन टूल बनाने के लिए पायथन का उपयोग करना
हालांकि पाइथन 2.7 ऑप्टपर्स के रूप में पदावनत किया जाता है, देखें: ऑप्टपर्स के बजाय क्यों argparse का उपयोग करें?
अगर आपको Win32 (2K, XP इत्यादि) पर यूनिकोड तर्कों को हथियाने की आवश्यकता हो, तो आपको इसमें मदद मिल सकती है :
from ctypes import *
def wmain(argc, argv):
print argc
for i in argv:
print i
return 0
def startup():
size = c_int()
ptr = windll.shell32.CommandLineToArgvW(windll.kernel32.GetCommandLineW(), byref(size))
ref = c_wchar_p * size.value
raw = ref.from_address(ptr)
args = [arg for arg in raw]
windll.kernel32.LocalFree(ptr)
exit(wmain(len(args), args))
startup()हल्के कमांड लाइन तर्क चूक
यद्यपि argparseमहान है और पूरी तरह से प्रलेखित कमांड लाइन स्विच और उन्नत सुविधाओं के लिए सही उत्तर है, तो आप बहुत सरलता से सीधे स्थिति संबंधी तर्कों को संभालने के लिए फ़ंक्शन तर्क चूक का उपयोग कर सकते हैं।
import sys
def get_args(name='default', first='a', second=2):
return first, int(second)
first, second = get_args(*sys.argv)
print first, second'नाम' तर्क स्क्रिप्ट नाम को पकड़ता है और इसका उपयोग नहीं किया जाता है। परीक्षण उत्पादन इस तरह दिखता है:
> ./test.py
a 2
> ./test.py A
A 2
> ./test.py A 20
A 20साधारण स्क्रिप्ट के लिए जहां मुझे कुछ डिफ़ॉल्ट मान चाहिए, मुझे यह काफी पर्याप्त लगता है। आप वापसी मानों में कुछ प्रकार के ज़बरदस्ती को भी शामिल करना चाह सकते हैं या कमांड लाइन के मूल्य सभी तार होंगे।
मैं ऑप्टपर्स करना पसंद करता हूँ। यह बहुत ही घोषणात्मक है: आप इसे उन विकल्पों के नाम और प्रभाव बता सकते हैं जो उनके पास होने चाहिए (जैसे, बूलियन फ़ील्ड सेट करना), और यह आपके विनिर्देशों के अनुसार पॉप्युलेट किए गए शब्दकोश को वापस सौंप देता है।
मुझे लगता है कि बड़ी परियोजनाओं के लिए सबसे अच्छा तरीका ऑप्टपर्स है, लेकिन अगर आप एक आसान तरीका ढूंढ रहे हैं, तो शायद http://werkzeug.pocoo.org/documentation/script आपके लिए कुछ है।
from werkzeug import script
# actions go here
def action_foo(name=""):
"""action foo does foo"""
pass
def action_bar(id=0, title="default title"):
"""action bar does bar"""
pass
if __name__ == '__main__':
script.run()तो मूल रूप से हर फंक्शन एक्शन_ * कमांड लाइन के संपर्क में है और मुफ्त में एक अच्छा मदद संदेश उत्पन्न होता है।
python foo.py
usage: foo.py <action> [<options>]
foo.py --help
actions:
bar:
action bar does bar
--id integer 0
--title string default title
foo:
action foo does foo
--name stringdeclarative_parser:। बेशक, अगर कोई werkzeug के साथ काम कर रहा है, तो इसे रखना बेहतर हो सकता है werkzung.script। वैसे भी, मैं इस तरह के दृष्टिकोण का बहुत बड़ा प्रशंसक हूं।
Argparse कोड वास्तविक कार्यान्वयन कोड से अधिक लंबा हो सकता है!
यह एक समस्या है जो मुझे सबसे लोकप्रिय तर्क पार्सिंग विकल्पों के साथ मिलती है, यह है कि यदि आपके पैरामीटर केवल मामूली हैं, तो उन्हें दस्तावेज करने के लिए कोड उनके द्वारा प्रदान किए जाने वाले लाभ के लिए बिल्कुल बड़े हो जाते हैं।
एक पार्सिंग दृश्य (मुझे लगता है) प्लेसी के तर्क के लिए एक नया-हास्य है ।
यह कुछ स्वीकार किए जाते हैं व्यापार के साथ argparse, लेकिन इनलाइन प्रलेखन का उपयोग करता है और बस main()प्रकार समारोह के आसपास wraps :
def main(excel_file_path: "Path to input training file.",
excel_sheet_name:"Name of the excel sheet containing training data including columns 'Label' and 'Description'.",
existing_model_path: "Path to an existing model to refine."=None,
batch_size_start: "The smallest size of any minibatch."=10.,
batch_size_stop: "The largest size of any minibatch."=250.,
batch_size_step: "The step for increase in minibatch size."=1.002,
batch_test_steps: "Flag. If True, show minibatch steps."=False):
"Train a Spacy (http://spacy.io/) text classification model with gold document and label data until the model nears convergence (LOSS < 0.5)."
pass # Implementation code goes here!
if __name__ == '__main__':
import plac; plac.call(main)यहाँ उल्लिखित किए जाने के योग्य हैं। यह इस्तेमाल में बहुत आसान है। इसकी जांच - पड़ताल करें:
from consoleargs import command
@command
def main(url, name=None):
"""
:param url: Remote URL
:param name: File name
"""
print """Downloading url '%r' into file '%r'""" % (url, name)
if __name__ == '__main__':
main()अब कंसोल में:
% python demo.py --help
Usage: demo.py URL [OPTIONS]
URL: Remote URL
Options:
--name -n File name
% python demo.py http://www.google.com/
Downloading url ''http://www.google.com/'' into file 'None'
% python demo.py http://www.google.com/ --name=index.html
Downloading url ''http://www.google.com/'' into file ''index.html''यहाँ एक विधि है, एक पुस्तकालय नहीं है, जो मेरे लिए काम करता है।
यहाँ लक्ष्यों को प्रतिसाद दिया जाना है, प्रत्येक तर्क को एक पंक्ति द्वारा पार्स किया गया है, पठनीयता के लिए args लाइन है, कोड सरल है और किसी विशेष मॉड्यूल (केवल os + sys) पर निर्भर नहीं करता है, गुम या अज्ञात तर्कों के बारे में सावधानी से चेतावनी देता है / रेंज () लूप के लिए एक सरल का उपयोग करें, और अजगर 2.x और 3.x पर काम करता है
दिखाए गए दो टॉगल झंडे (-d -v) हैं, और दो मान तर्क (-i xxx और -o xxx) द्वारा नियंत्रित हैं।
import os,sys
def HelpAndExit():
print("<<your help output goes here>>")
sys.exit(1)
def Fatal(msg):
sys.stderr.write("%s: %s\n" % (os.path.basename(sys.argv[0]), msg))
sys.exit(1)
def NextArg(i):
'''Return the next command line argument (if there is one)'''
if ((i+1) >= len(sys.argv)):
Fatal("'%s' expected an argument" % sys.argv[i])
return(1, sys.argv[i+1])
### MAIN
if __name__=='__main__':
verbose = 0
debug = 0
infile = "infile"
outfile = "outfile"
# Parse command line
skip = 0
for i in range(1, len(sys.argv)):
if not skip:
if sys.argv[i][:2] == "-d": debug ^= 1
elif sys.argv[i][:2] == "-v": verbose ^= 1
elif sys.argv[i][:2] == "-i": (skip,infile) = NextArg(i)
elif sys.argv[i][:2] == "-o": (skip,outfile) = NextArg(i)
elif sys.argv[i][:2] == "-h": HelpAndExit()
elif sys.argv[i][:1] == "-": Fatal("'%s' unknown argument" % sys.argv[i])
else: Fatal("'%s' unexpected" % sys.argv[i])
else: skip = 0
print("%d,%d,%s,%s" % (debug,verbose,infile,outfile))NextArg () का लक्ष्य लापता डेटा की जाँच करते समय अगला तर्क वापस करना है, और जब NextArg () का उपयोग किया जाता है, तो ध्वज को लूप से छोड़ देता है जब ध्वज को एक लाइनर पर रखा जाता है।
मैंने आवश्यक स्थिति संबंधी तर्कों के लिए और वैकल्पिक तर्कों के लिए एर्को के दृष्टिकोण को बढ़ाया। ये -d, -v आदि तर्कों से पहले होना चाहिए।
स्थिति और वैकल्पिक तर्क क्रमशः PosArg (i) और OptArg (i, डिफ़ॉल्ट) के साथ पुनर्प्राप्त किए जा सकते हैं। जब एक वैकल्पिक तर्क को विकल्प की खोज की शुरुआत की स्थिति मिल जाती है (जैसे -i) एक 'अप्रत्याशित' घातक होने से बचने के लिए 1 को आगे बढ़ाया जाता है।
import os,sys
def HelpAndExit():
print("<<your help output goes here>>")
sys.exit(1)
def Fatal(msg):
sys.stderr.write("%s: %s\n" % (os.path.basename(sys.argv[0]), msg))
sys.exit(1)
def NextArg(i):
'''Return the next command line argument (if there is one)'''
if ((i+1) >= len(sys.argv)):
Fatal("'%s' expected an argument" % sys.argv[i])
return(1, sys.argv[i+1])
def PosArg(i):
'''Return positional argument'''
if i >= len(sys.argv):
Fatal("'%s' expected an argument" % sys.argv[i])
return sys.argv[i]
def OptArg(i, default):
'''Return optional argument (if there is one)'''
if i >= len(sys.argv):
Fatal("'%s' expected an argument" % sys.argv[i])
if sys.argv[i][:1] != '-':
return True, sys.argv[i]
else:
return False, default
### MAIN
if __name__=='__main__':
verbose = 0
debug = 0
infile = "infile"
outfile = "outfile"
options_start = 3
# --- Parse two positional parameters ---
n1 = int(PosArg(1))
n2 = int(PosArg(2))
# --- Parse an optional parameters ---
present, a3 = OptArg(3,50)
n3 = int(a3)
options_start += int(present)
# --- Parse rest of command line ---
skip = 0
for i in range(options_start, len(sys.argv)):
if not skip:
if sys.argv[i][:2] == "-d": debug ^= 1
elif sys.argv[i][:2] == "-v": verbose ^= 1
elif sys.argv[i][:2] == "-i": (skip,infile) = NextArg(i)
elif sys.argv[i][:2] == "-o": (skip,outfile) = NextArg(i)
elif sys.argv[i][:2] == "-h": HelpAndExit()
elif sys.argv[i][:1] == "-": Fatal("'%s' unknown argument" % sys.argv[i])
else: Fatal("'%s' unexpected" % sys.argv[i])
else: skip = 0
print("Number 1 = %d" % n1)
print("Number 2 = %d" % n2)
print("Number 3 = %d" % n3)
print("Debug = %d" % debug)
print("verbose = %d" % verbose)
print("infile = %s" % infile)
print("outfile = %s" % outfile)