Komut satırı argümanları ayrıştırmak için en iyi yolu nedir?

oy
145

Ne var en kolay , tersest ve en esnek Python komut satırı argümanları ayrıştırma yöntemi veya kütüphane?

Oluştur 21/08/2008 saat 15:24
kaynak kullanıcı
Diğer dillerde...                            


15 cevaplar

oy
126

Bu cevap da anlaşılacağı optparseeski Python sürümleri için uygun olan. Python 2.7 ve üzeri için, argparseyerini optparse. Bkz bu cevabı daha fazla bilgi için.

Başkalarının belirttiği gibi, sen getopt üzerinde optparse ile gidiş daha iyi. getopt hemen hemen (3) C kütüphanesi fonksiyonları ve kullanımı çok kolay değildir standart getopt bir bire-bir eşleme olduğunu.

biraz daha uzun olmakla olurken optparse, çok daha iyi yapılandırılmış ve daha basit daha sonra uzatmaktır.

İşte ayrıştırıcı için bir seçenek eklemek için tipik bir çizgi:

parser.add_option('-q', '--query',
            action="store", dest="query",
            help="query string", default="spam")

Hemen hemen kendini belli ediyor; işleme zamanda, -q kabul edecek ya da seçenek olarak --query, bir özelliği adı sorguda argüman kaydeder ve tekrar belirtmek yoksa varsayılan bir değere sahiptir. Orada seçeneğiyle - Aynı zamanda kendi kendini belgeleyen sen (yardım -h / ile çalıştırdığınızda kullanılacaktır) yardım argüman ilan ettiklerini içindedir.

Genellikle size argümanları ile ayrıştırmak:

options, args = parser.parse_args()

Bu, varsayılan olarak, komut geçirilen standart argümanları ayrıştırmak olacak (sys.argv [1:])

options.query o zaman komut dosyası geçirilen değere ayarlanacaktır.

Sen yaparak bir ayrıştırıcı basitçe oluşturmak

parser = optparse.OptionParser()

Bunlar size gerekli olan tüm temel bilgiler bulunmaktadır. İşte bu gösteriyor komple Python komut var:

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

temelleri göstermek pitonun 5 satır.

sample.py bunu kaydedin ve bir kez çalıştırın

python sample.py

ve bir kez

python sample.py --query myquery

Bunun ötesinde, uzatmak çok kolay optparse olduğunu göreceksiniz. Benim projelerinden biri olarak, ben kolayca bir komut ağacındaki yuva alt komutlar için olanak tanıyan bir komut sınıfını yarattı. Birlikte zincir komutlara ağır optparse kullanır. Ben kolayca birkaç hatlarında açıklamak ancak çekinmeyin bir şey değil benim depoda etrafı kolaçan ana sınıfına, hem de için o ve opsiyon ayrıştırıcı kullanan bir sınıfın

Cevap 25/08/2008 saat 22:11
kaynak kullanıcı

oy
101

Diğer cevaplar söz do argparseyeni Python için gitmek yoldur, ancak kullanım örneklerini vermeyin. Bütünlüğü sağlamak için, burada argparse nasıl kullanılacağına ilişkin kısa bir özetidir:

1) başlat

import argparse

# Instantiate the parser
parser = argparse.ArgumentParser(description='Optional app description')

2) Argümanlar ekle

# 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) Ayrıştırma

args = parser.parse_args()

4) Erişim

print("Argument values:")
print(args.pos_arg)
print(args.opt_pos_arg)
print(args.opt_arg)
print(args.switch)

5) Kontrol Değerleri

if args.pos_arg > 10:
    parser.error("pos_arg cannot be larger than 10")

kullanım

Doğru kullanımı:

$ ./app 1 2 --opt_arg 3 --switch

Argument values:
1
2
3
True

Yanlış argümanlar:

$ ./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

Tam yardım:

$ ./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 switch
Cevap 27/05/2015 saat 21:21
kaynak kullanıcı

oy
51

docopt kullanma

2012 yılından bu yana Python çok kolay, güçlü ve gerçekten sahiptir serin denilen argüman ayrıştırma için modül docopt . Bu 3.5'e Python 2.6 ile çalışır ve hiçbir kurulum (sadece kopya) ihtiyacı vardır. İşte 's belgelerine alınan bir örnek:

"""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)

Şimdilik bu kadar: 2 kod satırını artı doc dize olan esansiyel ve argümanlar nesne içinde size argümanlar ayrıştırılır ve mevcut olsun. Ben, önemli değil demiştim ben yapmadım ;-)

piton-ateşi kullanma

2017 yılından bu yana piton ateş yaptığınızı ile koduna bir CLI arayüzü verebilir başka serin modülüne sahip sıfır argüman ayrıştırılmasını. İşte belgelerinden basit bir örnek (bu küçük programın işlevini ortaya çıkarır var doublekomut satırına):

import fire

class Calculator(object):

  def double(self, number):
    return 2 * number

if __name__ == '__main__':
  fire.Fire(Calculator)

Komut satırından itibaren, çalıştırabilirsiniz:

> calculator.py double 10
20
> calculator.py double --number=15
30

Müthiş değil mi?

Cevap 04/05/2013 saat 18:51
kaynak kullanıcı

oy
35

Yeni kalça yoludur argparseiçin bu nedenlerden. argparse> optparse> getopt

güncelleştirmek: py2.7 itibariyle argparse standart kütüphanenin parçasıdır ve optparse kullanımdan kaldırılmıştır.

Cevap 11/06/2009 saat 08:54
kaynak kullanıcı

oy
15

Neredeyse herkes kullanıyor Getopt

İşte dokümana ilişkin örnek kodudur:

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

tek kelimeyle Yani, burada nasıl işliyor.

Sen seçeneklerden iki tür var. alıcı argümanlar olanlar ve sadece anahtarlar gibi olanlar.

sys.argvHemen hemen edilir char** argvC. Like C Eğer programın adıdır ilk elemanını atlayıp sadece argümanlar ayrıştırmak:sys.argv[1:]

Getopt.getopt Eğer argüman vermek kuralına göre ayrıştırmak olacaktır.

"ho:v"Burada kısa argümanları anlatır: -ONELETTER. :Aracı -obir bağımsız değişken kabul eder.

Son olarak ["help", "output="]uzun bağımsız değişkenler açıklanmaktadır ( --MORETHANONELETTER). =Sonra çıkış kez daha çıkış tek argüman kabul ettiği anlamına gelir.

Sonuç çiftin listesidir (opsiyon, argüman)

Bir seçenek (gibi herhangi bir argüman kabul etmezse --helpburada) argkısmı boş dizedir. Daha sonra genellikle bu listedeki döngü istiyoruz ve örnekte olduğu gibi opsiyon adını test edin.

Umarım bu sana yardımcı olmuştur.

Cevap 21/08/2008 saat 15:26
kaynak kullanıcı

oy
14

Kullanım optparsestandart kütüphane ile birlikte gelir. Örneğin:

#!/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()

Kaynak: UNIX komut satırı araçlarını oluşturmak için Python Kullanımı

2.7 optparse kullanımdan kaldırıldı Python Ancak, bkz: Neden argparse kullanmak yerine optparse?

Cevap 21/08/2008 saat 15:25
kaynak kullanıcı

oy
9

Ben tercih tıklayın . Bu yönetme seçenekleri soyutlar ve "gerektiği kadar küçük koduyla composable şekilde güzel komut satırı arayüzleri oluşturmak (...)" izin verir.

İşte örnek kullanımı:

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()

Aynı zamanda otomatik olarak güzel yardım sayfalarını biçimlendirilmiş oluşturur:

$ 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.
Cevap 21/11/2014 saat 20:00
kaynak kullanıcı

oy
6

Eğer gerekiyorsa Just in case, bu yardımcı olabilir gerekebilir kapmak Win32 (2K, XP vb) unicode argümanlar:


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()
Cevap 21/08/2008 saat 15:59
kaynak kullanıcı

oy
4

Ben daha büyük projeler için en iyi yol optparse olduğunu düşünüyorum, ama kolay bir yol arıyorsanız, belki http://werkzeug.pocoo.org/documentation/script sizin için bir şeydir.

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()

Yani temelde her fonksiyon action_ * komut satırına maruz ve güzel bir yardım mesajı ücretsiz olarak oluşturulur.

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                        string
Cevap 27/08/2008 saat 20:27
kaynak kullanıcı

oy
3

Ben optparse Getopt tercih ediyorum. bunu onlar olmalıdır seçenekler ve etkileri (örneğin, bir mantıksal bir alan ayarlama) isimlerini söylemek ve geri özelliklerine göre doldurulan bir sözlük sizi eller: Çok bildirim var.

http://docs.python.org/lib/module-optparse.html

Cevap 21/08/2008 saat 16:22
kaynak kullanıcı

oy
2

Hafif komut satırı argümanı varsayılan

Her ne kadar argparsebüyük ve tam olarak belgelenmiş komut satırı anahtarları ve gelişmiş özellikler için doğru cevaptır, çok basitçe kolları basit pozisyonel argümanları fonksiyon argüman varsayılan kullanabilirsiniz.

import sys

def get_args(name='default', first='a', second=2):
    return first, int(second)

first, second = get_args(*sys.argv)
print first, second

'Name' argümanı komut adını yakalar ve kullanılmaz. Test çıkışı şöyle görünür:

> ./test.py
a 2
> ./test.py A
A 2
> ./test.py A 20
A 20

Sadece biraz varsayılan değerleri istediğiniz basit komut dosyaları için bu oldukça yeterli buluyorum. Ayrıca tüm dizeleri olacak dönüş değerleri veya komut satırı değerlerinde bazı tip zorlama eklemek isteyebilirsiniz.

Cevap 05/04/2017 saat 14:26
kaynak kullanıcı

oy
2

consoleargs Burada sözü hak ediyor. Kullanımı çok kolaydır. Buna bir bak:

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()

konsolda Şimdi:

% 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''
Cevap 30/06/2012 saat 06:43
kaynak kullanıcı

oy
0

Ben gerekli konumsal argümanlar için ve isteğe bağlı bağımsız değişkenler için izin vermek ERCO yaklaşımını uzatıldı. Bunlar, -v vs argümanlar -d önce gelmelidir.

Konumsal ve isteğe bağlı argümanlar sırasıyla PosArg (i) ve OPTARG (i, varsayılan) ile alınabilir. İsteğe bağlı argüman (örn -i) seçenekleri için arama başlangıç ​​pozisyonunu bulunduğunda bir 'beklenmedik ölümcül görmesini engellemek takımını 1 taşınır.

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) 
Cevap 24/07/2018 saat 12:32
kaynak kullanıcı

oy
0

Argparse kod fiili uygulama kodundan daha uzun olabilir!

Bu senin parametreleri yalnızca mütevazı olursa, onları belgelemek için kod sağladıkları yarar orantısız büyük hale olmasıdır Ben en popüler argüman ayrıştırma seçenekleri ile bulmak bir problem.

Argümanı ayrıştırma sahnesi (Sanırım) göre A new-koşedır Plac .

Bu argparse bazı tanınmış dengeler yapar, ama satır içi belgeleri kullanır ve basitçe sarar main()tipi fonksiyon fonksiyonu:

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)
Cevap 05/07/2018 saat 07:17
kaynak kullanıcı

oy
0

İşte yöntem, benim için değil iş gibi görünüyor kütüphane, bu.

Burada gol veciz olmak vardır, tek bir çizgi ile çözümlenen her argüman, args okunabilmesi için sıraya, kod basittir ve herhangi bir özel modüllerin (sadece os + sys) bağlı değildir, eksik veya incelikle bilinmeyen argümanlar konusunda uyarıda için / aralık () döngü basit kullanın ve piton 2.x ve 3.x arasında çalışır

İki geçiş bayrakları gösterilmiştir (d, v) ve bağımsız değişken (i xxx ve -o xxx) tarafından kontrol edilen iki değer.

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 () amacı eksik veriler için kontrol ederken bir sonraki argüman dönün ve 'atlama' etmektir NextArg () bir gömlekleri aşağı ayrıştırma bayrağı tutarak, kullanılan döngü atlar.

Cevap 09/04/2016 saat 12:45
kaynak kullanıcı

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more