간단한 인수 예제가 필요함 : 1 개의 인수, 3 개의 결과

문서 에 대한 argparse 파이썬 모듈 내 작은 초급 뇌가 지금 파악하기 위해 내가 확신이 우수하면서, 너무 많은입니다. 명령 줄에서 수학을 수행하거나 화면에서 형식 줄을 사용하거나 옵션 문자를 변경할 필요가 없습니다. 내가하고 싶은 것은 "arg가 A이면 B가 그렇게하면 위의 도움말이 표시되지 않고 종료하지 않으면이 작업을 수행하십시오" 입니다.

원래 질문에 대한 나의 이해는 두 가지입니다. 첫째, 가능한 가장 간단한 argparse 예제와 관련하여 여기서 보지 못했다는 것에 놀랐습니다. 물론, 간단 해지기 위해서는 약간의 힘만으로도 오버 헤드가 발생하지만 시작하게 될 수도 있습니다.

import argparse

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

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

그러나이 입장 논쟁이 이제 필요하다. 이 프로그램을 호출 할 때 빠져 나가면 누락 된 인수에 대한 오류가 발생합니다. 이것은 원래 질문의 두 번째 부분으로 연결됩니다. Matt Wilkie 는 명명 된 레이블 (--option 레이블)이없는 단일 선택적 인수 를 원하는 것 같습니다 . 내 제안은 다음과 같이 위의 코드를 수정하는 것입니다.

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

더 우아한 해결책이있을 수 있지만 이것은 효과가 있으며 미니멀리스트입니다.

여기 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

귀하의 경우 단순히 하나의 인수 만 추가하십시오.

argparse문서는 합리적으로 잘하지만 몇 가지 유용한 세부 사항 밖으로 잎은 분명하지 않을 수 있습니다. (@Diego Navarro는 이미이 중 일부를 언급했지만 그의 답변을 약간 확장하려고 노력할 것입니다.) 기본 사용법은 다음과 같습니다.

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대체합니다 '-'. 변수의 이름을 지정 밑줄과의 인수 이름에서)

많은 상황에서 인수를 단순히 가치가없는 플래그로 사용하고자 할 수 있습니다. 다음과 같이 argparse에 추가 할 수 있습니다.

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

위의 값은 각각 값이 True 인 'foo', 값이 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함수를 사용하여 인수를 쉽게 작성할 수 있다면 인수의 dict 구조를 작성할 수 있습니다.

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

보시다시피, vars인수 이름을 키로 사용하고 값을 값으로 사용하여 dict를 반환합니다.

다른 많은 옵션과 할 수있는 일이 있지만 가장 일반적인 일반적인 사용 시나리오를 다루어야합니다.

Matt는 argparse의 위치 매개 변수에 대해 묻고 있으며 Python 설명서 에이 측면이 부족하다는 데 동의합니다. ~ 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"로 유지되어 덜 명백한 방법입니다. 프로그램에서 사용하십시오.

내 예제의 끝 부분에있는 두 줄을 주목하십시오. 두 줄은 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

이 게시물 에서 영감을 얻은 또 다른 요약 소개 .

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 : --help사용될 때이 인수에 대한 설명 .
• default : arg가 생략 된 경우 기본값입니다.
• 유형 : float또는 int( 또는 그렇지 않으면)이 예상되는 경우 str.
• dest : 플래그와 다른 이름을 지정합니다 (예 :) '-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']
• required : 플래그가 필요하거나 위치 인수가 아닌 경우
• nargs : N args를 캡처하는 플래그
  ./myscript.py --foo a b => args.foo = ['a', 'b']
• choices : 가능한 입력을 제한합니다 (문자열 목록으로 지정하거나 int 인 경우 type=int).

Python HOWTOs 의 Argparse Tutorial 을 참고하십시오 . 다음과 같은 가장 기본적인 예에서 시작합니다.

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)

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

이것은 진화했을 수 있으며 온라인으로 제공됩니다 : command-line.py

이 코드에 연습을 제공하는 스크립트 : command-line-demo.sh

또한 plac (wrapper around 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'] )

선적 서류 비치:

plac 사용에 대한 자세한 내용은 훌륭한 설명서를 확인하십시오.

Plac : 쉬운 방법으로 커맨드 라인 파싱

다른 사람들이 언급 한 내용을 추가하려면 :

나는 일반적으로 'dest'매개 변수를 사용하여 변수 이름을 지정한 다음 'globals (). update ()'를 사용하여 해당 변수를 전역 네임 스페이스에 넣습니다.

용법:

$ 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!"

argparse를 사용하고 '-h'/ '--help'스위치를 수정하여 자신의 개인 코드 도움말 지시를 표시하는 간단한 방법은 기본 도움말을 False로 설정하는 것입니다. 원하는만큼 추가 .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()

python test.py -h를 실행하십시오.

산출:

usage: test.py [-h]

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

가장 간단한 답변!

추신 : argparse의 문서를 작성한 사람은 어리석은

파이썬 코드 :

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