argparse --- 명령행 옵션, 인자와 부속 명령을 위한 파서

버전 3.2에 추가.

소스 코드: Lib/argparse.py


argparse 모듈은 사용자 친화적인 명령행 인터페이스를 쉽게 작성하도록 합니다. 프로그램이 필요한 인자를 정의하면, argparsesys.argv 를 어떻게 파싱할지 파악합니다. 또한 argparse 모듈은 도움말과 사용법 메시지를 자동 생성하고, 사용자가 프로그램에 잘못된 인자를 줄 때 에러를 발생시킵니다.

다음 코드는 정수 목록을 받아 합계 또는 최댓값을 출력하는 파이썬 프로그램입니다:

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

위의 파이썬 코드가 prog.py 라는 파일에 저장되었다고 가정할 때, 명령행에서 실행되고 유용한 도움말 메시지를 제공할 수 있습니다:

$ python prog.py -h
usage: prog.py [-h] [--sum] N [N ...]

Process some integers.

positional arguments:
 N           an integer for the accumulator

optional arguments:
 -h, --help  show this help message and exit
 --sum       sum the integers (default: find the max)

적절한 인자로 실행하면 명령행 정수의 합계 또는 최댓값을 인쇄합니다.:

$ python prog.py 1 2 3 4
4

$ python prog.py 1 2 3 4 --sum
10

잘못된 인자가 전달되면 에러가 발생합니다:

$ python prog.py a b c
usage: prog.py [-h] [--sum] N [N ...]
prog.py: error: argument N: invalid int value: 'a'

다음 절에서 이 예제를 자세히 살펴봅니다.

파서 만들기

argparse를 사용하는 첫 번째 단계는 ArgumentParser 객체를 생성하는 것입니다:

>>> parser = argparse.ArgumentParser(description='Process some integers.')

ArgumentParser 객체는 명령행을 파이썬 데이터형으로 파싱하는데 필요한 모든 정보를 담고 있습니다.

인자 추가하기

ArgumentParser 에 프로그램 인자에 대한 정보를 채우려면 add_argument() 메서드를 호출하면 됩니다. 일반적으로 이 호출은 ArgumentParser 에게 명령행의 문자열을 객체로 변환하는 방법을 알려줍니다. 이 정보는 저장되고, parse_args() 가 호출될 때 사용됩니다. 예를 들면:

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

나중에, parse_args() 를 호출하면 두 가지 어트리뷰트, integersaccumulate 를 가진 객체를 반환합니다. integers 어트리뷰트는 하나 이상의 int로 구성된 리스트가 될 것이고, accumulate 어트리뷰트는 명령행에 --sum 가 지정되었을 경우 sum() 함수가 되고, 그렇지 않으면 max() 함수가 될 것입니다.

인자 파싱하기

ArgumentParserparse_args() 메서드를 통해 인자를 파싱합니다. 이 메서드는 명령행을 검사하고 각 인자를 적절한 형으로 변환 한 다음 적절한 액션을 호출합니다. 대부분은, 이것은 간단한 Namespace 객체가 명령행에서 파싱 된 어트리뷰트들로 만들어진다는 것을 뜻합니다:

>>> parser.parse_args(['--sum', '7', '-1', '42'])
Namespace(accumulate=<built-in function sum>, integers=[7, -1, 42])

스크립트에서, parse_args() 는 일반적으로 인자 없이 호출되고, ArgumentParsersys.argv 에서 자동으로 명령행 인자를 결정합니다.

ArgumentParser 객체

class argparse.ArgumentParser(prog=None, usage=None, description=None, epilog=None, parents=[], formatter_class=argparse.HelpFormatter, prefix_chars='-', fromfile_prefix_chars=None, argument_default=None, conflict_handler='error', add_help=True, allow_abbrev=True)

새로운 ArgumentParser 객체를 만듭니다. 모든 매개 변수는 키워드 인자로 전달되어야 합니다. 매개 변수마다 아래에서 더 자세히 설명되지만, 요약하면 다음과 같습니다:

  • prog - 프로그램의 이름 (기본값: sys.argv[0])

  • usage - 프로그램 사용법을 설명하는 문자열 (기본값: 파서에 추가된 인자로부터 만들어지는 값)

  • description - 인자 도움말 전에 표시할 텍스트 (기본값: none)

  • epilog - 인자 도움말 후에 표시할 텍스트 (기본값: none)

  • parents - ArgumentParser 객체들의 리스트이고, 이 들의 인자들도 포함된다

  • formatter_class - 도움말 출력을 사용자 정의하기 위한 클래스

  • prefix_chars - 선택 인자 앞에 붙는 문자 집합 (기본값: '-').

  • fromfile_prefix_chars - 추가 인자를 읽어야 하는 파일 앞에 붙는 문자 집합 (기본값: None).

  • argument_default - 인자의 전역 기본값 (기본값: None)

  • conflict_handler - 충돌하는 선택 사항을 해결하기 위한 전략 (일반적으로 불필요함)

  • add_help - 파서에 -h/--help 옵션을 추가합니다 (기본값: True)

  • allow_abbrev - 약어가 모호하지 않으면 긴 옵션을 축약할 수 있도록 합니다. (기본값: True)

버전 3.5에서 변경: allow_abbrev 매개 변수가 추가되었습니다.

버전 3.8에서 변경: 이전 버전에서는, allow_abbrev-vv-v -v를 뜻하는 것과 같은 짧은 플래그의 그룹화도 비활성화했습니다.

다음 절에서는 이들 각각의 사용 방법에 관해 설명합니다.

prog

기본적으로, ArgumentParser 객체는 sys.argv[0] 을 사용하여 도움말 메시지에 프로그램의 이름을 표시하는 방법을 결정합니다. 이 기본값은 명령행에서 프로그램이 호출된 방법과 도움말 메시지를 일치시키기 때문에 거의 항상 바람직합니다. 예를 들어, 다음 코드가 들어있는 myprogram.py 라는 파일을 생각해보십시오:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', help='foo help')
args = parser.parse_args()

이 프로그램의 도움말은 (프로그램이 어디에서 호출되었는지에 관계없이) 프로그램 이름으로 myprogram.py 를 표시합니다:

$ python myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO   foo help
$ cd ..
$ python subdir/myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]

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

이 기본 동작을 변경하려면, prog= 인자를 ArgumentParser 에 사용하여 다른 값을 제공 할 수 있습니다:

>>> parser = argparse.ArgumentParser(prog='myprogram')
>>> parser.print_help()
usage: myprogram [-h]

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

프로그램 이름은 %(prog)s 포맷 지정자를 사용해서 도움말에 쓸 수 있습니다. sys.argv[0]prog= 인자 중 어떤 것으로부터 결정되든 상관없습니다.

>>> parser = argparse.ArgumentParser(prog='myprogram')
>>> parser.add_argument('--foo', help='foo of the %(prog)s program')
>>> parser.print_help()
usage: myprogram [-h] [--foo FOO]

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO   foo of the myprogram program

usage

기본적으로, ArgumentParser 는 포함 된 인자로부터 사용법 메시지를 계산합니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo', nargs='?', help='foo help')
>>> parser.add_argument('bar', nargs='+', help='bar help')
>>> parser.print_help()
usage: PROG [-h] [--foo [FOO]] bar [bar ...]

positional arguments:
 bar          bar help

optional arguments:
 -h, --help   show this help message and exit
 --foo [FOO]  foo help

기본 메시지는 usage= 키워드 인자로 재정의될 수 있습니다:

>>> parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')
>>> parser.add_argument('--foo', nargs='?', help='foo help')
>>> parser.add_argument('bar', nargs='+', help='bar help')
>>> parser.print_help()
usage: PROG [options]

positional arguments:
 bar          bar help

optional arguments:
 -h, --help   show this help message and exit
 --foo [FOO]  foo help

%(prog)s 포맷 지정자는 사용법 메시지에서 프로그램 이름을 채울 때 사용할 수 있습니다.

description

ArgumentParser 생성자에 대한 대부분의 호출은 description= 키워드 인자를 사용할 것입니다. 이 인자는 프로그램의 기능과 작동 방식에 대한 간략한 설명을 제공합니다. 도움말 메시지에서, 설명은 명령행 사용 문자열과 다양한 인자에 대한 도움말 메시지 사이에 표시됩니다:

>>> parser = argparse.ArgumentParser(description='A foo that bars')
>>> parser.print_help()
usage: argparse.py [-h]

A foo that bars

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

기본적으로, 설명은 주어진 공간에 맞도록 줄 바꿈 됩니다. 이 동작을 변경하려면 formatter_class 인자를 참조하십시오.

epilog

일부 프로그램은 인자에 대한 설명 뒤에 프로그램에 대한 추가 설명을 표시하려고 합니다. 이러한 텍스트는 epilog= 에 대한 인자를 ArgumentParser 에 사용하여 지정할 수 있습니다:

>>> parser = argparse.ArgumentParser(
...     description='A foo that bars',
...     epilog="And that's how you'd foo a bar")
>>> parser.print_help()
usage: argparse.py [-h]

A foo that bars

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

And that's how you'd foo a bar

description 인자와 마찬가지로, epilog= 텍스트가 기본적으로 줄 바꿈 됩니다만, 이 동작은 formatter_class 인자를 ArgumentParser 에 제공해서 조정할 수 있습니다.

parents

때로는 여러 파서가 공통 인자 집합을 공유하는 경우가 있습니다. 이러한 인자의 정의를 반복하는 대신, 모든 공유 인자를 갖는 파서를 ArgumentParserparents= 인자로 전달할 수 있습니다. parents= 인자는 ArgumentParser 객체의 리스트를 취하여, 그것들로부터 모든 위치와 선택 액션을 수집해서 새로 만들어지는 ArgumentParser 객체에 추가합니다:

>>> parent_parser = argparse.ArgumentParser(add_help=False)
>>> parent_parser.add_argument('--parent', type=int)

>>> foo_parser = argparse.ArgumentParser(parents=[parent_parser])
>>> foo_parser.add_argument('foo')
>>> foo_parser.parse_args(['--parent', '2', 'XXX'])
Namespace(foo='XXX', parent=2)

>>> bar_parser = argparse.ArgumentParser(parents=[parent_parser])
>>> bar_parser.add_argument('--bar')
>>> bar_parser.parse_args(['--bar', 'YYY'])
Namespace(bar='YYY', parent=None)

대부분의 부모 파서는 add_help=False 를 지정합니다. 그렇지 않으면, ArgumentParser 는 (하나는 부모에, 하나는 자식에 있는) 두 개의 -h/--help 옵션을 보게 될 것이고, 에러를 발생시킵니다.

참고

parents= 를 통해 전달하기 전에 파서를 완전히 초기화해야 합니다. 자식 파서 다음에 부모 파서를 변경하면 자식에 반영되지 않습니다.

formatter_class

ArgumentParser 객체는 대체 포매팅 클래스를 지정함으로써 도움말 포매팅을 사용자 정의 할 수 있도록 합니다. 현재 네 가지 클래스가 있습니다:

class argparse.RawDescriptionHelpFormatter
class argparse.RawTextHelpFormatter
class argparse.ArgumentDefaultsHelpFormatter
class argparse.MetavarTypeHelpFormatter

RawDescriptionHelpFormatterRawTextHelpFormatter 는 텍스트 설명이 표시되는 방법을 더 제어할 수 있도록 합니다. 기본적으로, ArgumentParser 객체는 명령행 도움말 메시지에서 descriptionepilog 텍스트를 줄 바꿈 합니다.:

>>> parser = argparse.ArgumentParser(
...     prog='PROG',
...     description='''this description
...         was indented weird
...             but that is okay''',
...     epilog='''
...             likewise for this epilog whose whitespace will
...         be cleaned up and whose words will be wrapped
...         across a couple lines''')
>>> parser.print_help()
usage: PROG [-h]

this description was indented weird but that is okay

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

likewise for this epilog whose whitespace will be cleaned up and whose words
will be wrapped across a couple lines

RawDescriptionHelpFormatterformatter_class= 로 전달하는 것은 descriptionepilog 가 이미 올바르게 포맷되어 있어서 줄 바꿈 되어서는 안 된다는 것을 가리킵니다:

>>> parser = argparse.ArgumentParser(
...     prog='PROG',
...     formatter_class=argparse.RawDescriptionHelpFormatter,
...     description=textwrap.dedent('''\
...         Please do not mess up this text!
...         --------------------------------
...             I have indented it
...             exactly the way
...             I want it
...         '''))
>>> parser.print_help()
usage: PROG [-h]

Please do not mess up this text!
--------------------------------
   I have indented it
   exactly the way
   I want it

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

RawTextHelpFormatter 는 인자 설명을 포함하여 모든 종류의 도움말 텍스트에 있는 공백을 유지합니다. 그러나 여러 개의 줄 넘김은 하나로 치환됩니다. 여러 개의 빈 줄을 유지하려면, 줄 바꿈 사이에 스페이스를 추가하십시오.

ArgumentDefaultsHelpFormatter 는 기본값에 대한 정보를 각각의 인자 도움말 메시지에 자동으로 추가합니다:

>>> parser = argparse.ArgumentParser(
...     prog='PROG',
...     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
>>> parser.add_argument('--foo', type=int, default=42, help='FOO!')
>>> parser.add_argument('bar', nargs='*', default=[1, 2, 3], help='BAR!')
>>> parser.print_help()
usage: PROG [-h] [--foo FOO] [bar [bar ...]]

positional arguments:
 bar         BAR! (default: [1, 2, 3])

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO   FOO! (default: 42)

MetavarTypeHelpFormatter 는 각 인자 값의 표시 이름으로 (일반 포매터처럼 dest 를 사용하는 대신에) type 인자의 이름을 사용합니다:

>>> parser = argparse.ArgumentParser(
...     prog='PROG',
...     formatter_class=argparse.MetavarTypeHelpFormatter)
>>> parser.add_argument('--foo', type=int)
>>> parser.add_argument('bar', type=float)
>>> parser.print_help()
usage: PROG [-h] [--foo int] float

positional arguments:
  float

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

prefix_chars

대부분의 명령행 옵션은 -f/--foo 처럼 - 를 접두어로 사용합니다. +f/foo 같은 옵션과 같이, 다른 접두어 문자를 지원해야 하는 파서는 ArgumentParser 생성자에 prefix_chars= 인자를 사용하여 지정할 수 있습니다:

>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='-+')
>>> parser.add_argument('+f')
>>> parser.add_argument('++bar')
>>> parser.parse_args('+f X ++bar Y'.split())
Namespace(bar='Y', f='X')

prefix_chars= 인자의 기본값은 '-' 입니다. - 를 포함하지 않는 문자 집합을 제공하면 -f/--foo 옵션이 허용되지 않게 됩니다.

fromfile_prefix_chars

때로는, 예를 들어 특히 긴 인자 목록을 다룰 때, 인자 목록을 명령행에 입력하는 대신 파일에 보관하는 것이 좋습니다. fromfile_prefix_chars= 인자가 ArgumentParser 생성자에 주어지면, 지정된 문자로 시작하는 인자는 파일로 간주하고 파일에 포함된 인자로 대체됩니다. 예를 들면:

>>> with open('args.txt', 'w') as fp:
...     fp.write('-f\nbar')
>>> parser = argparse.ArgumentParser(fromfile_prefix_chars='@')
>>> parser.add_argument('-f')
>>> parser.parse_args(['-f', 'foo', '@args.txt'])
Namespace(f='bar')

파일에서 읽은 인자는 기본적으로 한 줄에 하나씩 있어야 하고 (하지만 convert_arg_line_to_args() 도 참조하십시오), 명령행에서 원래 파일을 참조하는 인자와 같은 위치에 있는 것처럼 처리됩니다. 위의 예에서 표현식 ['-f', 'foo', '@args.txt']['-f', 'foo', '-f', 'bar'] 와 동등하게 취급됩니다.

fromfile_prefix_chars= 인자의 기본값은 None 입니다. 이것은 인자가 절대로 파일 참조로 취급되지 않는다는 것을 의미합니다.

argument_default

일반적으로 인자의 기본값은 add_argument() 에 기본값을 전달하거나 특정 이름-값 쌍 집합을 사용하여 set_defaults() 메서드를 호출하여 지정됩니다. 그러나 때로는, 파서 전체에 적용되는 단일 기본값을 지정하는 것이 유용 할 수 있습니다. 이것은 argument_default= 키워드 인자를 ArgumentParser 에 전달함으로써 이루어질 수 있습니다. 예를 들어, parse_args() 호출에서 어트리뷰트 생성을 전역적으로 억제하려면, argument_default=SUPPRESS 를 제공합니다:

>>> parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)
>>> parser.add_argument('--foo')
>>> parser.add_argument('bar', nargs='?')
>>> parser.parse_args(['--foo', '1', 'BAR'])
Namespace(bar='BAR', foo='1')
>>> parser.parse_args([])
Namespace()

allow_abbrev

일반적으로 ArgumentParserparse_args() 메서드에 인자 리스트를 건네주면 긴 옵션의 약어를 인식합니다.

allow_abbrevFalse 로 설정하면 이 기능을 비활성화 할 수 있습니다:

>>> parser = argparse.ArgumentParser(prog='PROG', allow_abbrev=False)
>>> parser.add_argument('--foobar', action='store_true')
>>> parser.add_argument('--foonley', action='store_false')
>>> parser.parse_args(['--foon'])
usage: PROG [-h] [--foobar] [--foonley]
PROG: error: unrecognized arguments: --foon

버전 3.5에 추가.

conflict_handler

ArgumentParser 객체는 같은 옵션 문자열을 가진 두 개의 액션을 허용하지 않습니다. 기본적으로 ArgumentParser 객체는 이미 사용 중인 옵션 문자열로 인자를 만들려고 시도하면 예외를 발생시킵니다

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-f', '--foo', help='old foo help')
>>> parser.add_argument('--foo', help='new foo help')
Traceback (most recent call last):
 ..
ArgumentError: argument --foo: conflicting option string(s): --foo

때로는 (예를 들어 parents 를 사용하는 경우) 같은 옵션 문자열을 갖는 예전의 인자들을 간단히 대체하는 것이 유용 할 수 있습니다. 이 동작을 얻으려면, ArgumentParserconflict_handler= 인자에 'resolve' 값을 제공합니다:

>>> parser = argparse.ArgumentParser(prog='PROG', conflict_handler='resolve')
>>> parser.add_argument('-f', '--foo', help='old foo help')
>>> parser.add_argument('--foo', help='new foo help')
>>> parser.print_help()
usage: PROG [-h] [-f FOO] [--foo FOO]

optional arguments:
 -h, --help  show this help message and exit
 -f FOO      old foo help
 --foo FOO   new foo help

ArgumentParser 객체는 모든 옵션 문자열이 재정의된 경우에만 액션을 제거합니다. 위의 예에서, 이전의 -f/--foo 액션은 --foo 옵션 문자열만 재정의되었기 때문에 -f 액션으로 유지됩니다.

add_help

기본적으로, ArgumentParser 객체는 파서의 도움말 메시지를 표시하는 옵션을 추가합니다. 예를 들어, 다음 코드를 포함하는 myprogram.py 파일을 생각해보십시오:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', help='foo help')
args = parser.parse_args()

명령행에서 -h 또는 --help 가 제공되면, ArgumentParser 도움말이 출력됩니다 :

$ python myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]

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

때에 따라, 이 도움말 옵션을 추가하지 않도록 설정하는 것이 유용 할 수 있습니다. add_help= 인자를 FalseArgumentParser 에 전달하면 됩니다:

>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)
>>> parser.add_argument('--foo', help='foo help')
>>> parser.print_help()
usage: PROG [--foo FOO]

optional arguments:
 --foo FOO  foo help

도움말 옵션은 일반적으로 -h/--help 입니다. 예외는 prefix_chars= 가 지정되고 - 을 포함하지 않는 경우입니다. 이 경우 -h--help 는 유효한 옵션이 아닙니다. 이 경우, prefix_chars 의 첫 번째 문자가 도움말 옵션 접두어로 사용됩니다:

>>> parser = argparse.ArgumentParser(prog='PROG', prefix_chars='+/')
>>> parser.print_help()
usage: PROG [+h]

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

add_argument() 메서드

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

단일 명령행 인자를 구문 분석하는 방법을 정의합니다. 매개 변수마다 아래에서 더 자세히 설명되지만, 요약하면 다음과 같습니다:

  • name or flags - 옵션 문자열의 이름이나 리스트, 예를 들어 foo 또는 -f, --foo.

  • action - 명령행에서 이 인자가 발견될 때 수행 할 액션의 기본형.

  • nargs - 소비되어야 하는 명령행 인자의 수.

  • const - 일부 actionnargs 를 선택할 때 필요한 상숫값.

  • default - 인자가 명령행에 없는 경우 생성되는 값.

  • type - 명령행 인자가 변환되어야 할 형.

  • choices - 인자로 허용되는 값의 컨테이너.

  • required - 명령행 옵션을 생략 할 수 있는지 아닌지 (선택적일 때만).

  • help - 인자가 하는 일에 대한 간단한 설명.

  • metavar - 사용 메시지에 사용되는 인자의 이름.

  • dest - parse_args() 가 반환하는 객체에 추가될 어트리뷰트의 이름.

다음 절에서는 이들 각각의 사용 방법에 관해 설명합니다.

name or flags

add_argument() 메서드는 -f--foo 와 같은 선택 인자가 필요한지, 파일 이름의 리스트와 같은 위치 인자가 필요한지 알아야 합니다. 따라서 add_argument() 에 전달되는 첫 번째 인자는 일련의 플래그이거나 간단한 인자 이름이어야 합니다. 예를 들어 선택 인자는 이렇게 만들어질 수 있습니다:

>>> parser.add_argument('-f', '--foo')

반면에 위치 인자는 이렇게 만들어집니다:

>>> parser.add_argument('bar')

parse_args() 가 호출되면, 선택 인자는 - 접두사로 식별되고, 그 밖의 인자는 위치 인자로 간주합니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-f', '--foo')
>>> parser.add_argument('bar')
>>> parser.parse_args(['BAR'])
Namespace(bar='BAR', foo=None)
>>> parser.parse_args(['BAR', '--foo', 'FOO'])
Namespace(bar='BAR', foo='FOO')
>>> parser.parse_args(['--foo', 'FOO'])
usage: PROG [-h] [-f FOO] bar
PROG: error: the following arguments are required: bar

action

ArgumentParser 객체는 명령행 인자를 액션과 연관시킵니다. 대부분의 액션은 단순히 parse_args() 에 의해 반환된 객체에 어트리뷰트를 추가하기만 하지만, 액션은 관련된 명령행 인자로 무엇이든 할 수 있습니다. action 키워드 인자는 명령행 인자의 처리 방법을 지정합니다. 제공되는 액션은 다음과 같습니다:

  • 'store' - 인자 값을 저장합니다. 이것이 기본 액션입니다. 예를 들면:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('--foo')
    >>> parser.parse_args('--foo 1'.split())
    Namespace(foo='1')
    
  • 'store_const' - const 키워드 인자에 의해 지정된 값을 저장합니다. 'store_const' 액션은 어떤 종류의 플래그를 지정하는 선택 인자와 함께 사용하는 것이 가장 일반적입니다. 예를 들면:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('--foo', action='store_const', const=42)
    >>> parser.parse_args(['--foo'])
    Namespace(foo=42)
    
  • 'store_true''store_false' - 각각 TrueFalse 값을 저장하는 'store_const' 의 특별한 경우입니다. 또한, 각각 기본값 FalseTrue 를 생성합니다. 예를 들면:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('--foo', action='store_true')
    >>> parser.add_argument('--bar', action='store_false')
    >>> parser.add_argument('--baz', action='store_false')
    >>> parser.parse_args('--foo --bar'.split())
    Namespace(foo=True, bar=False, baz=True)
    
  • 'append' - 리스트를 저장하고 각 인자 값을 리스트에 추가합니다. 옵션을 여러 번 지정할 수 있도록 하는 데 유용합니다. 사용 예:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('--foo', action='append')
    >>> parser.parse_args('--foo 1 --foo 2'.split())
    Namespace(foo=['1', '2'])
    
  • 'append_const' - 리스트를 저장하고 const 키워드 인자로 지정된 값을 리스트에 추가합니다. (const 키워드의 기본값은 None 입니다.) 'append_const' 액션은 여러 개의 인자가 같은 리스트에 상수를 저장해야 할 때 유용합니다. 예를 들면:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('--str', dest='types', action='append_const', const=str)
    >>> parser.add_argument('--int', dest='types', action='append_const', const=int)
    >>> parser.parse_args('--str --int'.split())
    Namespace(types=[<class 'str'>, <class 'int'>])
    
  • 'count' - 키워드 인자가 등장한 횟수를 계산합니다. 예를 들어, 상세도를 높이는 데 유용합니다:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('--verbose', '-v', action='count')
    >>> parser.parse_args(['-vvv'])
    Namespace(verbose=3)
    
  • 'help' - 현재 파서의 모든 옵션에 대한 완전한 도움말 메시지를 출력하고 종료합니다. 기본적으로 help 액션은 자동으로 파서에 추가됩니다. 출력이 만들어지는 방법에 대한 자세한 내용은 ArgumentParser 를 보세요.

  • 'version' - add_argument() 호출에서 version= 키워드 인자를 기대하고, 호출되면 버전 정보를 출력하고 종료합니다:

    >>> import argparse
    >>> parser = argparse.ArgumentParser(prog='PROG')
    >>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')
    >>> parser.parse_args(['--version'])
    PROG 2.0
    
  • 'append' - 리스트를 저장하고 각 인자 값으로 리스트를 확장합니다. 사용 예:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument("--foo", action="extend", nargs="+", type=str)
    >>> parser.parse_args(["--foo", "f1", "--foo", "f2", "f3", "f4"])
    Namespace(foo=['f1', 'f2', 'f3', 'f4'])
    

Action 서브 클래스나 같은 인터페이스를 구현하는 다른 객체를 전달하여 임의의 액션을 지정할 수도 있습니다. 권장하는 방법은 Action 을 확장하여 __call__ 메서드와 선택적으로 __init__ 메서드를 재정의하는 것입니다.

사용자 정의 액션의 예:

>>> class FooAction(argparse.Action):
...     def __init__(self, option_strings, dest, nargs=None, **kwargs):
...         if nargs is not None:
...             raise ValueError("nargs not allowed")
...         super(FooAction, self).__init__(option_strings, dest, **kwargs)
...     def __call__(self, parser, namespace, values, option_string=None):
...         print('%r %r %r' % (namespace, values, option_string))
...         setattr(namespace, self.dest, values)
...
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action=FooAction)
>>> parser.add_argument('bar', action=FooAction)
>>> args = parser.parse_args('1 --foo 2'.split())
Namespace(bar=None, foo=None) '1' None
Namespace(bar='1', foo=None) '2' '--foo'
>>> args
Namespace(bar='1', foo='2')

자세한 내용은 Action 을 참조하십시오.

nargs

ArgumentParser 객체는 일반적으로 하나의 명령행 인자를 하나의 액션과 결합합니다. nargs 키워드 인자는 다른 수의 명령행 인자를 하나의 액션으로 연결합니다. 지원되는 값은 다음과 같습니다:

  • N (정수). 명령행에서 N 개의 인자를 함께 모아서 리스트에 넣습니다. 예를 들면:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('--foo', nargs=2)
    >>> parser.add_argument('bar', nargs=1)
    >>> parser.parse_args('c --foo a b'.split())
    Namespace(bar=['c'], foo=['a', 'b'])
    

    nargs=1 은 하나의 항목을 갖는 리스트를 생성합니다. 이는 항목 그대로 생성되는 기본값과 다릅니다.

  • '?'. 가능하다면 한 인자가 명령행에서 소비되고 단일 항목으로 생성됩니다. 명령행 인자가 없으면 default 의 값이 생성됩니다. 선택 인자의 경우 추가적인 경우가 있습니다 - 옵션 문자열은 있지만, 명령행 인자가 따라붙지 않는 경우입니다. 이 경우 const 의 값이 생성됩니다. 이것을 보여주기 위해 몇 가지 예를 듭니다:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('--foo', nargs='?', const='c', default='d')
    >>> parser.add_argument('bar', nargs='?', default='d')
    >>> parser.parse_args(['XX', '--foo', 'YY'])
    Namespace(bar='XX', foo='YY')
    >>> parser.parse_args(['XX', '--foo'])
    Namespace(bar='XX', foo='c')
    >>> parser.parse_args([])
    Namespace(bar='d', foo='d')
    

    nargs='?' 의 흔한 사용법 중 하나는 선택적 입출력 파일을 허용하는 것입니다:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
    ...                     default=sys.stdin)
    >>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'),
    ...                     default=sys.stdout)
    >>> parser.parse_args(['input.txt', 'output.txt'])
    Namespace(infile=<_io.TextIOWrapper name='input.txt' encoding='UTF-8'>,
              outfile=<_io.TextIOWrapper name='output.txt' encoding='UTF-8'>)
    >>> parser.parse_args([])
    Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>,
              outfile=<_io.TextIOWrapper name='<stdout>' encoding='UTF-8'>)
    
  • '*'. 모든 명령행 인자를 리스트로 수집합니다. 일반적으로 두 개 이상의 위치 인자에 대해 nargs='*' 를 사용하는 것은 별로 의미가 없지만, nargs='*' 를 갖는 여러 개의 선택 인자는 가능합니다. 예를 들면:

    >>> parser = argparse.ArgumentParser()
    >>> parser.add_argument('--foo', nargs='*')
    >>> parser.add_argument('--bar', nargs='*')
    >>> parser.add_argument('baz', nargs='*')
    >>> parser.parse_args('a b --foo x y --bar 1 2'.split())
    Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])
    
  • '+'. '*' 와 같이, 존재하는 모든 명령행 인자를 리스트로 모읍니다. 또한, 적어도 하나의 명령행 인자가 제공되지 않으면 에러 메시지가 만들어집니다. 예를 들면:

    >>> parser = argparse.ArgumentParser(prog='PROG')
    >>> parser.add_argument('foo', nargs='+')
    >>> parser.parse_args(['a', 'b'])
    Namespace(foo=['a', 'b'])
    >>> parser.parse_args([])
    usage: PROG [-h] foo [foo ...]
    PROG: error: the following arguments are required: foo
    
  • argparse.REMAINDER. 남은 모든 명령행 인자를 리스트로 수집합니다. 이것은 일반적으로 다른 명령행 유틸리티를 호출하는 명령행 유틸리티에 유용합니다:

    >>> parser = argparse.ArgumentParser(prog='PROG')
    >>> parser.add_argument('--foo')
    >>> parser.add_argument('command')
    >>> parser.add_argument('args', nargs=argparse.REMAINDER)
    >>> print(parser.parse_args('--foo B cmd --arg1 XX ZZ'.split()))
    Namespace(args=['--arg1', 'XX', 'ZZ'], command='cmd', foo='B')
    

nargs 키워드 인자가 제공되지 않으면, 소비되는 인자의 개수는 action 에 의해 결정됩니다. 일반적으로 이는 하나의 명령행 인자가 소비되고 하나의 항목(리스트가 아닙니다)이 생성됨을 의미합니다.

const

add_argument()const 인자는 명령행에서 읽지는 않지만 다양한 ArgumentParser 액션에 필요한 상숫값을 저장하는 데 사용됩니다. 가장 흔한 두 가지 용도는 다음과 같습니다:

  • add_argument()action='store_const' 또는 action='append_const' 로 호출될 때. 이 액션은 parse_args() 에 의해 반환된 객체의 어트리뷰트 중 하나에 const 값을 추가합니다. 예제는 action 설명을 참조하십시오.

  • add_argument() 가 옵션 문자열(-f 또는 --foo 와 같은)과 nargs='?' 로 호출될 때. 이것은 0 또는 하나의 명령행 인자가 뒤따르는 선택 인자를 만듭니다. 명령행을 파싱할 때 옵션 문자열 뒤에 명령행 인자가 없으면 const 값이 대신 가정됩니다. 예제는 nargs 설명을 참조하십시오.

'store_const''append_const' 액션을 사용할 때는 const 키워드 인자를 반드시 주어야 합니다. 다른 액션의 경우, 기본값은 None 입니다.

default

모든 선택 인자와 일부 위치 인자는 명령행에서 생략될 수 있습니다. add_argument()default 키워드 인자는, 기본값은 None 입니다, 명령행 인자가 없을 때 어떤 값을 사용해야 하는지를 지정합니다. 선택 인자의 경우, 옵션 문자열이 명령행에 없을 때 default 값이 사용됩니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', default=42)
>>> parser.parse_args(['--foo', '2'])
Namespace(foo='2')
>>> parser.parse_args([])
Namespace(foo=42)

default 값이 문자열이면, 파서는 마치 명령행 인자인 것처럼 파싱합니다. 특히, 파서는 Namespace 반환 값에 어트리뷰트를 설정하기 전에, 제공된 모든 type 변환 인자를 적용합니다. 그렇지 않은 경우, 파서는 값을 있는 그대로 사용합니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--length', default='10', type=int)
>>> parser.add_argument('--width', default=10.5, type=int)
>>> parser.parse_args()
Namespace(length=10, width=10.5)

nargs? 또는 * 인 위치 인자의 경우, 명령행 인자가 없을 때 default 값이 사용됩니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('foo', nargs='?', default=42)
>>> parser.parse_args(['a'])
Namespace(foo='a')
>>> parser.parse_args([])
Namespace(foo=42)

default=argparse.SUPPRESS 를 지정하면 명령행 인자가 없는 경우 어트리뷰트가 추가되지 않습니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', default=argparse.SUPPRESS)
>>> parser.parse_args([])
Namespace()
>>> parser.parse_args(['--foo', '1'])
Namespace(foo='1')

type

기본적으로 ArgumentParser 객체는 명령행 인자를 간단한 문자열로 읽습니다. 그러나 꽤 자주 명령행 문자열은 float 또는 int와 같은 다른 형으로 해석되어야 합니다. add_argument()type 키워드 인자는 필요한 형 검사와 형 변환이 수행되도록 합니다. 일반적인 내장형과 함수는 type 인자의 값으로 직접 사용될 수 있습니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('foo', type=int)
>>> parser.add_argument('bar', type=open)
>>> parser.parse_args('2 temp.txt'.split())
Namespace(bar=<_io.TextIOWrapper name='temp.txt' encoding='UTF-8'>, foo=2)

언제 type 인자가 기본 인자에 적용되는지에 대한 정보는 default 키워드 인자 절을 참조하십시오.

다양한 형태의 파일을 사용하기 쉽게 하려고, argparse 모듈은 open() 함수의 mode=, bufsize=, encoding=, errors= 인자를 취하는 팩토리 FileType 을 제공합니다. 예를 들어, FileType('w') 은 쓰기 가능한 파일을 만드는 데 사용할 수 있습니다

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar', type=argparse.FileType('w'))
>>> parser.parse_args(['out.txt'])
Namespace(bar=<_io.TextIOWrapper name='out.txt' encoding='UTF-8'>)

type= 는 단일 문자열 인자를 취하고 변환된 값을 돌려주는 모든 콜러블을 받아들입니다:

>>> def perfect_square(string):
...     value = int(string)
...     sqrt = math.sqrt(value)
...     if sqrt != int(sqrt):
...         msg = "%r is not a perfect square" % string
...         raise argparse.ArgumentTypeError(msg)
...     return value
...
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('foo', type=perfect_square)
>>> parser.parse_args(['9'])
Namespace(foo=9)
>>> parser.parse_args(['7'])
usage: PROG [-h] foo
PROG: error: argument foo: '7' is not a perfect square

단순히 값의 범위를 검사하는 형 검사기로는 choices 키워드 인자가 더 편리할 수 있습니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('foo', type=int, choices=range(5, 10))
>>> parser.parse_args(['7'])
Namespace(foo=7)
>>> parser.parse_args(['11'])
usage: PROG [-h] {5,6,7,8,9}
PROG: error: argument foo: invalid choice: 11 (choose from 5, 6, 7, 8, 9)

자세한 내용은 choices 섹션을 참조하십시오.

choices

일부 명령행 인자는 제한된 값 집합에서 선택되어야 합니다. add_argument() 에 컨테이너 객체를 choices 키워드 인자로 전달하여 처리할 수 있습니다. 명령행을 파싱할 때, 인자의 값을 검사하고, 인자가 받아들일 수 없는 값이 아닌 경우 에러 메시지가 표시됩니다:

>>> parser = argparse.ArgumentParser(prog='game.py')
>>> parser.add_argument('move', choices=['rock', 'paper', 'scissors'])
>>> parser.parse_args(['rock'])
Namespace(move='rock')
>>> parser.parse_args(['fire'])
usage: game.py [-h] {rock,paper,scissors}
game.py: error: argument move: invalid choice: 'fire' (choose from 'rock',
'paper', 'scissors')

choices 컨테이너에 포함되는지는 type 변환이 수행된 후에 검사하므로, choices 컨테이너에 있는 객체의 형은 지정된 type 과 일치해야 합니다:

>>> parser = argparse.ArgumentParser(prog='doors.py')
>>> parser.add_argument('door', type=int, choices=range(1, 4))
>>> print(parser.parse_args(['3']))
Namespace(door=3)
>>> parser.parse_args(['4'])
usage: doors.py [-h] {1,2,3}
doors.py: error: argument door: invalid choice: 4 (choose from 1, 2, 3)

in 연산자를 지원하는 모든 객체는 choices 값으로 전달될 수 있으므로, dict 객체, set 객체, 사용자 정의 컨테이너 등이 모두 지원됩니다.

flowdas

choicesnargs='*' 를 함께 쓰면 묘한 일이 일어납니다. 아무런 값도 주지 않으면 빈 튜플이 제공되는 대신, 에러를 일으킵니다:

>>> parser = argparse.ArgumentParser(prog='doors.py')
>>> parser.add_argument('door', type=int, nargs='*', choices=range(1, 4))
>>> parser.parse_args([])
usage: doors.py [-h] [{1,2,3} [{1,2,3} ...]]
doors.py: error: argument door: invalid choice: [] (choose from 1, 2, 3)

required

일반적으로 argparse 모듈은 -f--bar 같은 플래그가 명령행에서 생략될 수 있는 선택적 인자를 가리킨다고 가정합니다. 옵션을 필수로 만들기 위해, add_argument()required= 키워드 인자에 True 를 지정할 수 있습니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', required=True)
>>> parser.parse_args(['--foo', 'BAR'])
Namespace(foo='BAR')
>>> parser.parse_args([])
usage: argparse.py [-h] [--foo FOO]
argparse.py: error: option --foo is required

예에서 보듯이, 옵션이 required 로 표시되면, parse_args() 는 그 옵션이 명령행에 없을 때 에러를 보고합니다.

참고

필수 옵션은 사용자가 옵션선택적 일 것으로 기대하기 때문에 일반적으로 나쁜 형식으로 간주하므로 가능하면 피해야 합니다.

help

help 값은 인자의 간단한 설명이 들어있는 문자열입니다. 사용자가 도움말을 요청하면 (보통 명령행에서 -h 또는 --help 를 사용합니다), help 설명이 각 인자와 함께 표시됩니다:

>>> parser = argparse.ArgumentParser(prog='frobble')
>>> parser.add_argument('--foo', action='store_true',
...                     help='foo the bars before frobbling')
>>> parser.add_argument('bar', nargs='+',
...                     help='one of the bars to be frobbled')
>>> parser.parse_args(['-h'])
usage: frobble [-h] [--foo] bar [bar ...]

positional arguments:
 bar     one of the bars to be frobbled

optional arguments:
 -h, --help  show this help message and exit
 --foo   foo the bars before frobbling

help 문자열은 프로그램 이름이나 인자 default 와 같은 것들의 반복을 피하고자 다양한 포맷 지정자를 포함 할 수 있습니다. 사용할 수 있는 지정자는 프로그램 이름, %(prog)sadd_argument() 의 대부분의 키워드 인자, %(default)s, %(type)s 등을 포함합니다.:

>>> parser = argparse.ArgumentParser(prog='frobble')
>>> parser.add_argument('bar', nargs='?', type=int, default=42,
...                     help='the bar to %(prog)s (default: %(default)s)')
>>> parser.print_help()
usage: frobble [-h] [bar]

positional arguments:
 bar     the bar to frobble (default: 42)

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

도움말 문자열이 %-포매팅을 지원하기 때문에, 도움말 문자열에 리터럴 % 을 표시하려면, %% 로 이스케이프 처리해야 합니다.

argparsehelp 값을 argparse.SUPPRESS 로 설정함으로써 특정 옵션에 대한 도움말 엔트리를 감추는 것을 지원합니다:

>>> parser = argparse.ArgumentParser(prog='frobble')
>>> parser.add_argument('--foo', help=argparse.SUPPRESS)
>>> parser.print_help()
usage: frobble [-h]

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

metavar

ArgumentParser 가 도움말 메시지를 생성할 때, 기대되는 각 인자를 가리킬 방법이 필요합니다. 기본적으로 ArgumentParser 객체는 dest 값을 각 객체의 "이름"으로 사용합니다. 기본적으로 위치 인자 액션의 경우 dest 값이 직접 사용되고, 선택 인자 액션의 경우 dest 값의 대문자가 사용됩니다. 그래서, dest='bar' 인 단일 위치 인자는 bar 로 지칭됩니다. 하나의 명령행 인자가 따라와야 하는 단일 선택 인자 --fooFOO 라고 표시됩니다. 예:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.add_argument('bar')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage:  [-h] [--foo FOO] bar

positional arguments:
 bar

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

다른 이름은 metavar 로 지정할 수 있습니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', metavar='YYY')
>>> parser.add_argument('bar', metavar='XXX')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage:  [-h] [--foo YYY] XXX

positional arguments:
 XXX

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

metavar표시되는 이름 만 변경합니다 - parse_args() 객체의 어트리뷰트 이름은 여전히 dest 값에 의해 결정됩니다.

flowdas

하지만, 표시되는 이름이 없을 때 (가령 'store_false''store_true' 액션을 사용할 때) metavar 를 주면 에러를 일으킵니다.

nargs 값이 다르면 metavar 가 여러 번 사용될 수 있습니다. metavar 에 튜플을 제공하면 인자마다 다른 디스플레이가 지정됩니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x', nargs=2)
>>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))
>>> parser.print_help()
usage: PROG [-h] [-x X X] [--foo bar baz]

optional arguments:
 -h, --help     show this help message and exit
 -x X X
 --foo bar baz

dest

대부분 ArgumentParser 액션은 parse_args() 에 의해 반환된 객체의 어트리뷰트로 어떤 값을 추가합니다. 이 어트리뷰트의 이름은 add_argument()dest 키워드 인자에 의해 결정됩니다. 위치 인자 액션의 경우, dest 는 일반적으로 add_argument() 에 첫 번째 인자로 제공됩니다.:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar')
>>> parser.parse_args(['XXX'])
Namespace(bar='XXX')

flowdas

위치 인자의 경우 add_argument() 에 첫 번째 위치 인자가 제공되면, dest 키워드 인자를 줄 수 없습니다. dest 가 중복된 것으로 취급합니다. 선택 인자에서는 이런 일이 없기 때문에, 간혹 혼란스러울 수 있습니다.

선택 인자 액션의 경우, dest 의 값은 보통 옵션 문자열에서 유추됩니다. ArgumentParser 는 첫 번째 긴 옵션 문자열을 취하고 앞의 -- 문자열을 제거하여 dest 의 값을 만듭니다. 긴 옵션 문자열이 제공되지 않았다면 dest 는 첫 번째 짧은 옵션 문자열에서 앞의 - 문자를 제거하여 만듭니다. 문자열이 항상 유효한 어트리뷰트 이름이 되도록 만들기 위해 중간에 나오는 - 문자는 _ 문자로 변환됩니다. 아래 예제는 이 동작을 보여줍니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('-f', '--foo-bar', '--foo')
>>> parser.add_argument('-x', '-y')
>>> parser.parse_args('-f 1 -x 2'.split())
Namespace(foo_bar='1', x='2')
>>> parser.parse_args('--foo 1 -y 2'.split())
Namespace(foo_bar='1', x='2')

dest 는 사용자 정의 어트리뷰트 이름을 지정할 수 있게 합니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', dest='bar')
>>> parser.parse_args('--foo XXX'.split())
Namespace(bar='XXX')

Action 클래스

Action 클래스는 액션 API를 구현합니다. 액션 API는 명령행에서 인자를 처리하는 콜러블을 반환하는 콜러블 객체입니다. 이 API를 따르는 모든 객체는 add_argument()action 매개 변수로 전달될 수 있습니다.

class argparse.Action(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None)

Action 객체는 ArgumentParser에서 명령행의 하나 이상의 문자열에서 단일 인자를 파싱하는 데 필요한 정보를 나타내기 위해 사용됩니다. Action 클래스는 두 개의 위치 인자와 ArgumentParser.add_argument() 에 전달된 action 자신을 제외한 모든 키워드 인자들을 받아들여야 합니다.

Action 인스턴스(또는 action 매개 변수로 전달된 콜러블의 반환 값)는 "dest", "option_strings", "default", "type", "required", "help" 등의 어트리뷰트가 정의되어야 합니다. 이러한 어트리뷰트를 정의하는 가장 쉬운 방법은 Action.__init__ 를 호출하는 것입니다.

Action 인스턴스는 콜러블이어야 하므로, 서브 클래스는 네 개의 매개 변수를 받아들이는 __call__ 메서드를 재정의해야 합니다:

  • parser - 이 액션을 포함하는 ArgumentParser 객체.

  • namespace - parse_args() 에 의해 반환될 Namespace 객체. 대부분의 액션은 setattr() 을 사용하여 이 객체에 어트리뷰트를 추가합니다.

  • values - 형 변환이 적용된 연관된 명령행 인자. 형 변환은 add_argument() 에 전달된 type 키워드 인자로 지정됩니다.

  • option_string - 이 액션을 호출하는 데 사용된 옵션 문자열. option_string 인자는 선택적이며, 액션이 위치 인자와 관련되어 있으면 생략됩니다.

__call__ 메서드는 임의의 액션을 수행 할 수 있습니다만, 일반적으로 destvalues 에 기반하여 namespace 에 어트리뷰트를 설정합니다.

parse_args() 메서드

ArgumentParser.parse_args(args=None, namespace=None)

인자 문자열을 객체로 변환하고 namespace의 어트리뷰트로 설정합니다. 값들이 설정된 namespace를 돌려줍니다.

이전의 add_argument() 호출이 어떤 객체를 만들고 어떤 식으로 대입할지를 결정합니다. 자세한 내용은 add_argument() 설명서를 참조하십시오.

  • args - 구문 분석할 문자열 리스트. 기본값은 sys.argv 에서 취합니다.

  • namespace - 어트리뷰트가 대입될 객체. 기본값은 새로 만들어지는 빈 Namespace 객체입니다.

옵션값 문법

parse_args() 메서드는 (취할 것이 있다면) 옵션의 값을 지정하는 몇 가지 방법을 지원합니다. 가장 단순한 경우, 옵션과 그 값은 두 개의 독립적인 인자로 전달됩니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x')
>>> parser.add_argument('--foo')
>>> parser.parse_args(['-x', 'X'])
Namespace(foo=None, x='X')
>>> parser.parse_args(['--foo', 'FOO'])
Namespace(foo='FOO', x=None)

긴 옵션(단일 문자보다 긴 이름을 가진 옵션)의 경우, 옵션과 값을 = 로 구분하여 단일 명령행 인자로 전달할 수도 있습니다:

>>> parser.parse_args(['--foo=FOO'])
Namespace(foo='FOO', x=None)

짧은 옵션(한 문자 길이의 옵션)의 경우, 옵션과 해당 값을 이어붙일 수 있습니다:

>>> parser.parse_args(['-xX'])
Namespace(foo=None, x='X')

여러 개의 짧은 옵션은 마지막 옵션만 값을 요구하는 한 (또는 그들 중 아무것도 값을 요구하지 않거나), 하나의 - 접두어를 사용하여 함께 결합 할 수 있습니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x', action='store_true')
>>> parser.add_argument('-y', action='store_true')
>>> parser.add_argument('-z')
>>> parser.parse_args(['-xyzZ'])
Namespace(x=True, y=True, z='Z')

잘못된 인자

명령행을 파싱할 때, parse_args() 는 모호한 옵션, 유효하지 않은 형, 유효하지 않은 옵션, 잘못된 위치 인자의 수 등을 포함한 다양한 에러를 검사합니다. 이런 에러가 발생하면, 사용 메시지와 함께 에러를 인쇄합니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo', type=int)
>>> parser.add_argument('bar', nargs='?')

>>> # 유효하지 않은 형
>>> parser.parse_args(['--foo', 'spam'])
usage: PROG [-h] [--foo FOO] [bar]
PROG: error: argument --foo: invalid int value: 'spam'

>>> # 유효하지 않은 옵션
>>> parser.parse_args(['--bar'])
usage: PROG [-h] [--foo FOO] [bar]
PROG: error: no such option: --bar

>>> # 잘못된 인자 수
>>> parser.parse_args(['spam', 'badger'])
usage: PROG [-h] [--foo FOO] [bar]
PROG: error: extra arguments found: badger

- 를 포함하는 인자들

parse_args() 메서드는 사용자가 분명히 실수했을 때마다 에러를 주려고 하지만, 어떤 상황은 본질에서 모호합니다. 예를 들어, 명령행 인자 -1 은 옵션을 지정하려는 시도이거나 위치 인자를 제공하려는 시도일 수 있습니다. parse_args() 메서드는 이럴 때 신중합니다: 위치 인자는 음수처럼 보이고 파서에 음수처럼 보이는 옵션이 없을 때만 - 로 시작할 수 있습니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x')
>>> parser.add_argument('foo', nargs='?')

>>> # 음수 옵션이 없으므로, -1 은 위치 인자입니다
>>> parser.parse_args(['-x', '-1'])
Namespace(foo=None, x='-1')

>>> # 음수 옵션이 없으므로, -1 과 -5 는 위치 인자입니다
>>> parser.parse_args(['-x', '-1', '-5'])
Namespace(foo='-5', x='-1')

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-1', dest='one')
>>> parser.add_argument('foo', nargs='?')

>>> # 음수 옵션이 있으므로, -1 은 옵션입니다
>>> parser.parse_args(['-1', 'X'])
Namespace(foo=None, one='X')

>>> # 음수 옵션이 있으므로, -2 는 옵션입니다
>>> parser.parse_args(['-2'])
usage: PROG [-h] [-1 ONE] [foo]
PROG: error: no such option: -2

>>> # 음수 옵션이 있으므로, 두 -1 모두 옵션입니다
>>> parser.parse_args(['-1', '-1'])
usage: PROG [-h] [-1 ONE] [foo]
PROG: error: argument -1: expected one argument

- 로 시작해야 하고, 음수처럼 보이지 않는 위치 인자가 있는 경우, parse_args() 에 다음과 같은 의사 인자 '--' 를 삽입 할 수 있습니다. 그 이후의 모든 것은 위치 인자입니다:

>>> parser.parse_args(['--', '-f'])
Namespace(foo='-f', one=None)

인자 약어 (접두사 일치)

parse_args() 메서드는 기본적으로 약어가 모호하지 않으면 (접두사가 오직 하나의 옵션과 일치합니다) 긴 옵션을 접두사로 축약 할 수 있도록 합니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-bacon')
>>> parser.add_argument('-badger')
>>> parser.parse_args('-bac MMM'.split())
Namespace(bacon='MMM', badger=None)
>>> parser.parse_args('-bad WOOD'.split())
Namespace(bacon=None, badger='WOOD')
>>> parser.parse_args('-ba BA'.split())
usage: PROG [-h] [-bacon BACON] [-badger BADGER]
PROG: error: ambiguous option: -ba could match -badger, -bacon

둘 이상의 옵션과 일치하는 인자는 에러를 일으킵니다. 이 기능은 allow_abbrevFalse 로 설정함으로써 비활성화시킬 수 있습니다.

sys.argv 너머

때로는 ArgumentParser가 sys.argv 의 인자가 아닌 다른 인자를 파싱하는 것이 유용 할 수 있습니다. 문자열 리스트를 parse_args() 에 전달하면 됩니다. 대화식 프롬프트에서 테스트할 때 유용합니다:

>>> 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)')
>>> parser.parse_args(['1', '2', '3', '4'])
Namespace(accumulate=<built-in function max>, integers=[1, 2, 3, 4])
>>> parser.parse_args(['1', '2', '3', '4', '--sum'])
Namespace(accumulate=<built-in function sum>, integers=[1, 2, 3, 4])

Namespace 객체

class argparse.Namespace

parse_args() 가 어트리뷰트를 저장하고 반환할 객체를 만드는 데 기본적으로 사용하는 간단한 클래스.

이 클래스는 의도적으로 단순한데, 단지 가독성 있는 문자열 표현을 갖는 object 의 서브 클래스입니다. 어트리뷰트를 딕셔너리처럼 보기 원한다면, 표준 파이썬 관용구를 사용할 수 있습니다, vars():

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> args = parser.parse_args(['--foo', 'BAR'])
>>> vars(args)
{'foo': 'BAR'}

ArgumentParser 가 새 Namespace 객체가 아니라 이미 존재하는 객체에 어트리뷰트를 대입하는 것이 유용 할 수 있습니다. namespace= 키워드 인자를 지정하면 됩니다:

>>> class C:
...     pass
...
>>> c = C()
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.parse_args(args=['--foo', 'BAR'], namespace=c)
>>> c.foo
'BAR'

기타 유틸리티

부속 명령

ArgumentParser.add_subparsers([title][, description][, prog][, parser_class][, action][, option_string][, dest][, required][, help][, metavar])

많은 프로그램은 그 기능을 여러 개의 부속 명령으로 나눕니다. 예를 들어, svn 프로그램은 svn checkout, svn update, svn commit 과 같은 부속 명령을 호출 할 수 있습니다. 이런 식으로 기능을 나누는 것은, 프로그램이 다른 명령행 인자를 요구하는 여러 가지 다른 기능을 수행할 때 특히 좋은 생각일 수 있습니다. ArgumentParseradd_subparsers() 메서드로 그러한 부속 명령의 생성을 지원합니다. add_subparsers() 메서드는 보통 인자 없이 호출되고 특별한 액션 객체를 돌려줍니다. 이 객체에는 add_parser()라는 하나의 메서드가 있습니다. 이 메서드는 명령 이름과 ArgumentParser 생성자 인자를 받고 평소와 같이 수정할 수 있는 ArgumentParser 객체를 반환합니다.

매개 변수 설명:

  • title - 도움말 출력의 부속 파서 그룹 제목; description이 제공되면 기본적으로 "subcommands", 그렇지 않으면 위치 인자를 위한 제목을 사용합니다

  • description - 도움말 출력의 부속 파서 그룹에 대한 설명. 기본값은 None 입니다.

  • prog - 부속 명령 도움말과 함께 표시될 사용 정보. 기본적으로 프로그램 이름 및 부속 파서 인자 앞에 오는 위치 인자

  • parser_class - 부속 파서 인스턴스를 만들 때 사용할 클래스. 기본적으로, 현재 파서의 클래스 (예를 들어 ArgumentParser)

  • action - 이 인자를 명령행에서 만날 때 수행 할 액션의 기본형

  • dest - 부속 명령 이름을 저장하는 어트리뷰트의 이름. 기본적으로 None 이며 값은 저장되지 않습니다.

  • required - 부속 명령이 꼭 제공되어야 하는지 아닌지, 기본값은 False

  • help - 도움말 출력의 부속 파서 그룹 도움말, 기본적으로 None

  • metavar - 도움말에서 사용 가능한 부속 명령을 표시하는 문자열. 기본적으로 None 이며 {cmd1, cmd2, ..} 형식으로 부속 명령을 표시합니다.

몇 가지 사용 예:

>>> # 최상위 파서를 만듭니다
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo', action='store_true', help='foo help')
>>> subparsers = parser.add_subparsers(help='sub-command help')
>>>
>>> # "a" 명령을 위한 파서를 만듭니다
>>> parser_a = subparsers.add_parser('a', help='a help')
>>> parser_a.add_argument('bar', type=int, help='bar help')
>>>
>>> # "b" 명령을 위한 파서를 만듭니다
>>> parser_b = subparsers.add_parser('b', help='b help')
>>> parser_b.add_argument('--baz', choices='XYZ', help='baz help')
>>>
>>> # 인자 리스트를 파싱합니다
>>> parser.parse_args(['a', '12'])
Namespace(bar=12, foo=False)
>>> parser.parse_args(['--foo', 'b', '--baz', 'Z'])
Namespace(baz='Z', foo=True)

parse_args() 에 의해 반환된 객체는 주 파서와 명령행에 의해 선택된 부속 파서(다른 부속 파서는 아님)의 어트리뷰트만을 포함한다는 것에 주의하십시오. 그래서 위의 예에서, a 명령이 지정되면 foobar 어트리뷰트 만 존재하고, b 명령이 지정되면 foobaz 어트리뷰트만 존재합니다.

마찬가지로, 도움말 메시지가 부속 파서에서 요청되면 해당 파서에 대한 도움말만 인쇄됩니다. 도움말 메시지에는 상위 파서나 형제 파서 메시지는 포함되지 않습니다. (하지만 각 부속 파서 명령에 대한 도움말 메시지는 위와 같이 add_parser()help= 인자를 주어 지정할 수 있습니다.)

>>> parser.parse_args(['--help'])
usage: PROG [-h] [--foo] {a,b} ...

positional arguments:
  {a,b}   sub-command help
    a     a help
    b     b help

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

>>> parser.parse_args(['a', '--help'])
usage: PROG a [-h] bar

positional arguments:
  bar     bar help

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

>>> parser.parse_args(['b', '--help'])
usage: PROG b [-h] [--baz {X,Y,Z}]

optional arguments:
  -h, --help     show this help message and exit
  --baz {X,Y,Z}  baz help

add_subparsers() 메서드는 또한 titledescription 키워드 인자를 지원합니다. 둘 중 하나가 있으면 부속 파서의 명령이 도움말 출력에서 자체 그룹으로 나타납니다. 예를 들면:

>>> parser = argparse.ArgumentParser()
>>> subparsers = parser.add_subparsers(title='subcommands',
...                                    description='valid subcommands',
...                                    help='additional help')
>>> subparsers.add_parser('foo')
>>> subparsers.add_parser('bar')
>>> parser.parse_args(['-h'])
usage:  [-h] {foo,bar} ...

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

subcommands:
  valid subcommands

  {foo,bar}   additional help

게다가, add_parseraliases 인자를 추가로 지원하는데, 여러 개의 문자열이 같은 부속 파서를 참조 할 수 있게 해줍니다. 이 예는 svn 와 마찬가지로 checkout 의 약자로 co 라는 별칭을 만듭니다:

>>> parser = argparse.ArgumentParser()
>>> subparsers = parser.add_subparsers()
>>> checkout = subparsers.add_parser('checkout', aliases=['co'])
>>> checkout.add_argument('foo')
>>> parser.parse_args(['co', 'bar'])
Namespace(foo='bar')

부속 명령을 처리하는 특히 효과적인 방법의 하나는, add_subparsers() 메서드를 set_defaults() 호출과 결합하여, 각 부속 파서가 어떤 파이썬 함수를 실행해야 하는지 알 수 있도록 하는 것입니다. 예를 들면:

>>> # 부속 명령 함수들
>>> def foo(args):
...     print(args.x * args.y)
...
>>> def bar(args):
...     print('((%s))' % args.z)
...
>>> # 최상위 파서를 만듭니다
>>> parser = argparse.ArgumentParser()
>>> subparsers = parser.add_subparsers()
>>>
>>> # "foo" 명령을 위한 파서를 만듭니다
>>> parser_foo = subparsers.add_parser('foo')
>>> parser_foo.add_argument('-x', type=int, default=1)
>>> parser_foo.add_argument('y', type=float)
>>> parser_foo.set_defaults(func=foo)
>>>
>>> # "bar" 명령을 위한 파서를 만듭니다
>>> parser_bar = subparsers.add_parser('bar')
>>> parser_bar.add_argument('z')
>>> parser_bar.set_defaults(func=bar)
>>>
>>> # 인자를 파싱하고 선택된 함수를 호출합니다
>>> args = parser.parse_args('foo 1 -x 2'.split())
>>> args.func(args)
2.0
>>>
>>> # 인자를 파싱하고 선택된 함수를 호출합니다
>>> args = parser.parse_args('bar XYZYX'.split())
>>> args.func(args)
((XYZYX))

이렇게 하면 parse_args() 가 파싱이 완료된 후 적절한 함수를 호출하게 할 수 있습니다. 이처럼 액션과 함수를 연결하는 것이, 일반적으로 각 부속 파서가 서로 다른 액션을 처리하도록 하는 가장 쉬운 방법입니다. 그러나 호출된 부속 파서의 이름을 확인해야 하는 경우 add_subparsers() 호출에 dest 키워드 인자를 제공합니다:

>>> parser = argparse.ArgumentParser()
>>> subparsers = parser.add_subparsers(dest='subparser_name')
>>> subparser1 = subparsers.add_parser('1')
>>> subparser1.add_argument('-x')
>>> subparser2 = subparsers.add_parser('2')
>>> subparser2.add_argument('y')
>>> parser.parse_args(['2', 'frobble'])
Namespace(subparser_name='2', y='frobble')

FileType 객체

class argparse.FileType(mode='r', bufsize=-1, encoding=None, errors=None)

FileType 팩토리는 ArgumentParser.add_argument() 의 type 인자로 전달될 수 있는 객체를 만듭니다. type으로 FileType 객체를 사용하는 인자는 명령행 인자를 요청된 모드, 버퍼 크기, 인코딩 및 오류 처리의 파일로 엽니다 (자세한 내용은 open() 함수를 참조하세요):

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--raw', type=argparse.FileType('wb', 0))
>>> parser.add_argument('out', type=argparse.FileType('w', encoding='UTF-8'))
>>> parser.parse_args(['--raw', 'raw.dat', 'file.txt'])
Namespace(out=<_io.TextIOWrapper name='file.txt' mode='w' encoding='UTF-8'>, raw=<_io.FileIO name='raw.dat' mode='wb'>)

FileType 객체는 의사 인자 '-' 를 이해하고, 읽기 위한 FileType 객체는 sys.stdin 으로, 쓰기 위한 FileType 객체는 sys.stdout 으로 자동 변환합니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('infile', type=argparse.FileType('r'))
>>> parser.parse_args(['-'])
Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>)

버전 3.4에 추가: encodingserrors 키워드 인자

인자 그룹

ArgumentParser.add_argument_group(title=None, description=None)

기본적으로 ArgumentParser 는 도움말 메시지를 표시할 때 "positional arguments"(위치 인자)와 "optional arguments"(선택 인자)로 명령행 인자를 그룹화합니다. 이 기본 그룹보다 더 나은 개념적 인자 그룹이 있는 경우, add_argument_group() 메서드를 사용하여 적절한 그룹을 만들 수 있습니다.:

>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)
>>> group = parser.add_argument_group('group')
>>> group.add_argument('--foo', help='foo help')
>>> group.add_argument('bar', help='bar help')
>>> parser.print_help()
usage: PROG [--foo FOO] bar

group:
  bar    bar help
  --foo FOO  foo help

add_argument_group() 메서드는 ArgumentParser 처럼 add_argument() 메서드를 가진 인자 그룹 객체를 반환합니다. 인자가 그룹에 추가될 때, 파서는 일반 인자처럼 취급하지만, 도움말 메시지는 별도의 그룹에 인자를 표시합니다. add_argument_group() 메서드는 이 표시를 사용자 정의하는데 사용할 수 있는 titledescription 인자를 받아들입니다:

>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)
>>> group1 = parser.add_argument_group('group1', 'group1 description')
>>> group1.add_argument('foo', help='foo help')
>>> group2 = parser.add_argument_group('group2', 'group2 description')
>>> group2.add_argument('--bar', help='bar help')
>>> parser.print_help()
usage: PROG [--bar BAR] foo

group1:
  group1 description

  foo    foo help

group2:
  group2 description

  --bar BAR  bar help

사용자 정의 그룹에 없는 인자는 일반적인 "positional arguments" 및 "optional arguments" 섹션으로 들어갑니다.

상호 배제

ArgumentParser.add_mutually_exclusive_group(required=False)

상호 배타적인 그룹을 만듭니다. argparse 는 상호 배타적인 그룹에서 오직 하나의 인자만 명령행에 존재하는지 확인합니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> group = parser.add_mutually_exclusive_group()
>>> group.add_argument('--foo', action='store_true')
>>> group.add_argument('--bar', action='store_false')
>>> parser.parse_args(['--foo'])
Namespace(bar=True, foo=True)
>>> parser.parse_args(['--bar'])
Namespace(bar=False, foo=False)
>>> parser.parse_args(['--foo', '--bar'])
usage: PROG [-h] [--foo | --bar]
PROG: error: argument --bar: not allowed with argument --foo

add_mutually_exclusive_group() 메서드는 상호 배타적 인자 중 적어도 하나가 필요하다는 것을 나타내기 위한 required 인자도 받아들입니다:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> group = parser.add_mutually_exclusive_group(required=True)
>>> group.add_argument('--foo', action='store_true')
>>> group.add_argument('--bar', action='store_false')
>>> parser.parse_args([])
usage: PROG [-h] (--foo | --bar)
PROG: error: one of the arguments --foo --bar is required

현재, 상호 배타적인 인자 그룹은 add_argument_group()titledescription 인자를 지원하지 않습니다.

파서 기본값

ArgumentParser.set_defaults(**kwargs)

대부분은, parse_args() 에 의해 반환된 객체의 어트리뷰트는 명령행 인자와 인자 액션을 검사하여 완전히 결정됩니다. set_defaults() 는 명령행을 검사하지 않고 결정되는 몇 가지 추가적인 어트리뷰트를 추가할 수 있도록 합니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('foo', type=int)
>>> parser.set_defaults(bar=42, baz='badger')
>>> parser.parse_args(['736'])
Namespace(bar=42, baz='badger', foo=736)

파서 수준의 기본값은 항상 인자 수준의 기본값보다 우선합니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', default='bar')
>>> parser.set_defaults(foo='spam')
>>> parser.parse_args([])
Namespace(foo='spam')

파서 수준의 기본값은 여러 파서로 작업 할 때 특히 유용 할 수 있습니다. 이 유형의 예제는 add_subparsers() 메서드를 참조하십시오.

ArgumentParser.get_default(dest)

add_argument() 또는 set_defaults() 에 의해 설정된 이름 공간 어트리뷰트의 기본값을 가져옵니다:

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', default='badger')
>>> parser.get_default('foo')
'badger'

도움말 인쇄

대부분의 일반적인 응용 프로그램에서 parse_args() 가 사용법이나 오류 메시지를 포매팅하고 인쇄하는 것을 담당합니다. 그러나 여러 가지 포매팅 방법이 제공됩니다:

ArgumentParser.print_usage(file=None)

ArgumentParser 가 어떻게 명령행에서 호출되어야 하는지에 대한 간단한 설명을 인쇄합니다. fileNone 이면, sys.stdout 이 가정됩니다.

ArgumentParser.print_help(file=None)

프로그램 사용법과 ArgumentParser 에 등록된 인자에 대한 정보를 포함하는 도움말 메시지를 출력합니다. fileNone 이면, sys.stdout 이 가정됩니다.

인쇄하는 대신 단순히 문자열을 반환하는, 이러한 메서드의 변형도 있습니다:

ArgumentParser.format_usage()

ArgumentParser 가 어떻게 명령행에서 호출되어야 하는지에 대한 간단한 설명을 담은 문자열을 반환합니다.

ArgumentParser.format_help()

프로그램 사용법과 ArgumentParser 에 등록된 인자에 대한 정보를 포함하는 도움말 메시지를 담은 문자열을 반환합니다.

부분 파싱

ArgumentParser.parse_known_args(args=None, namespace=None)

때에 따라 스크립트는 명령행 인자 중 일부만 파싱하고 나머지 인자를 다른 스크립트 나 프로그램에 전달할 수 있습니다. 이 경우 parse_known_args() 메서드가 유용 할 수 있습니다. parse_args() 와 매우 유사하게 작동하는데, 여분의 인자가 있을 때 에러를 발생시키지 않는 점이 다릅니다. 대신, 채워진 이름 공간과 여분의 인자 문자열 리스트를 포함하는 두 항목 튜플을 반환합니다.

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action='store_true')
>>> parser.add_argument('bar')
>>> parser.parse_known_args(['--foo', '--badger', 'BAR', 'spam'])
(Namespace(bar='BAR', foo=True), ['--badger', 'spam'])

경고

접두사 일치 규칙은 parse_known_args() 에 적용됩니다. 파서는 알려진 옵션 중 하나의 접두사 일지라도 여분의 인자 목록에 남기지 않고 옵션을 소비할 수 있습니다.

파일 파싱 사용자 정의

ArgumentParser.convert_arg_line_to_args(arg_line)

파일에서 읽은 인자는 (ArgumentParser 생성자의 fromfile_prefix_chars 키워드 인자를 참조하세요) 한 줄에 하나의 인자로 읽습니다. 이 동작을 변경하려면 convert_arg_line_to_args() 를 재정의합니다.

이 메서드는 하나의 인자 arg_line 를 받아들이는데, 인자 파일에서 읽어 들인 문자열입니다. 이 문자열에서 파싱된 인자 리스트를 반환합니다. 메서드는 인자 파일에서 읽어 들이는 대로 한 줄에 한 번씩 순서대로 호출됩니다.

이 메서드의 재정의하는 유용한 경우는 스페이스로 분리된 각 단어를 인자로 처리하는 것입니다. 다음 예제는 이렇게 하는 방법을 보여줍니다:

class MyArgumentParser(argparse.ArgumentParser):
    def convert_arg_line_to_args(self, arg_line):
        return arg_line.split()

종료 메서드

ArgumentParser.exit(status=0, message=None)

이 메서드는 지정된 status 상태 코드로 프로그램을 종료하고, message 가 주어지면 그 전에 인쇄합니다.

ArgumentParser.error(message)

이 메서드는 message 를 포함하는 사용법 메시지를 표준 에러에 인쇄하고, 상태 코드 2로 프로그램을 종료합니다.

혼합 파싱

ArgumentParser.parse_intermixed_args(args=None, namespace=None)
ArgumentParser.parse_known_intermixed_args(args=None, namespace=None)

많은 유닉스 명령은 사용자가 선택 인자와 위치 인자를 섞을 수 있도록 합니다. parse_intermixed_args()parse_known_intermixed_args() 메서드는 이런 파싱 스타일을 지원합니다.

이 파서들은 argparse 기능을 모두 지원하지는 않으며 지원되지 않는 기능이 사용되는 경우 예외를 발생시킵니다. 특히 부속 파서, argparse.REMAINDER, 그리고 옵션과 위치를 모두 포함하는 상호 배타적인 그룹은 지원되지 않습니다.

다음 예제는 parse_known_args()parse_intermixed_args() 의 차이점을 보여줍니다: 전자는 여분의 인자로 ['2', '3'] 을 반환하는 반면, 후자는 모든 위치 인자를 rest 로 모읍니다.

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.add_argument('cmd')
>>> parser.add_argument('rest', nargs='*', type=int)
>>> parser.parse_known_args('doit 1 --foo bar 2 3'.split())
(Namespace(cmd='doit', foo='bar', rest=[1]), ['2', '3'])
>>> parser.parse_intermixed_args('doit 1 --foo bar 2 3'.split())
Namespace(cmd='doit', foo='bar', rest=[1, 2, 3])

parse_known_intermixed_args() 는 채워진 이름 공간과 잔여 인자 문자열의 리스트를 포함하는 두 항목 튜플을 반환합니다. parse_intermixed_args() 는 파싱되지 않은 인자 문자열이 남아 있으면 에러를 발생시킵니다.

버전 3.7에 추가.

optparse 코드 업그레이드

원래, argparse 모듈은 optparse 와의 호환성을 유지하려고 시도했습니다. 그러나, optparse 는 투명하게 확장하기 어려운데, 특히 새로운 nargs= 지정자와 더 나은 사용법 메시지를 지원하는 데 필요한 변경에서 그렇습니다. optparse 에 있는 대부분이 복사-붙여넣기 되었거나 몽키 패치되었을 때, 더 하위 호환성을 유지하려고 노력하는 것이 실용적으로 보이지 않게 되었습니다.

argparse 모듈은 표준 라이브러리 optparse 모듈을 다음과 같은 여러 가지 방식으로 개선합니다:

  • 위치 인자 처리.

  • 부속 명령 지원.

  • +/ 와 같은 다른 옵션 접두사 허용.

  • 0개 이상 및 1개 이상 스타일의 인자 처리.

  • 더욱 유익한 사용법 메시지 생성.

  • 사용자 정의 typeaction 을 위한 훨씬 간단한 인터페이스 제공.

optparse 에서 argparse 로의 부분적인 업그레이드 경로:

  • 모든 optparse.OptionParser.add_option() 호출을 ArgumentParser.add_argument() 호출로 대체하십시오.

  • (options, args) = parser.parse_args()args = parser.parse_args() 로 대체하고, 위치 인자에 대한 ArgumentParser.add_argument() 호출을 추가하십시오. 이전에 options 라고 불렀던 것이 이제 argparse 문맥에서 args 라는 것을 명심하십시오.

  • optparse.OptionParser.disable_interspersed_args()parse_args() 대신 parse_intermixed_args() 를 사용하여 대체하십시오.

  • 콜백 액션과 callback_* 키워드 인자를 type 또는 action 인자로 대체하십시오.

  • type 키워드 인자를 위한 문자열 이름을 해당 type 객체(예를 들어, int, float, complex 등)로 대체하십시오.

  • optparse.ValuesNamespace 로, optparse.OptionErroroptparse.OptionValueErrorArgumentError 로 대체하십시오.

  • %default%prog 와 같은 묵시적인 인자를 포함하는 문자열을, 문자열 포맷에 딕셔너리를 사용하는 표준 파이썬 문법 대체하십시오, 즉 %(default)s%(prog)s.

  • OptionParser 생성자의 version 인자를 parser.add_argument('--version', action='version', version='<the version>') 호출로 대체하십시오.