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

버전 3.2에 추가.

**소스 코드:** Lib/argparse.py

======================================================================


자습서
^^^^^^

이 페이지는 API 레퍼런스 정보를 담고 있습니다. 파이썬 명령행 파싱에 대
한 더 친절한 소개를 원하시면, argparse 자습서 를 보십시오.

"argparse" 모듈은 사용자 친화적인 명령행 인터페이스를 쉽게 작성하도록
합니다. 프로그램이 필요한 인자를 정의하면, "argparse" 는 "sys.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()" 를 호출하면 두 가지 어트리뷰트, "integers" 와
"accumulate" 를 가진 객체를 반환합니다. "integers" 어트리뷰트는 하나
이상의 int로 구성된 리스트가 될 것이고, "accumulate" 어트리뷰트는 명령
행에 "--sum" 가 지정되었을 경우 "sum()" 함수가 되고, 그렇지 않으면
"max()" 함수가 될 것입니다.


인자 파싱하기
-------------

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

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

스크립트에서, "parse_args()" 는 일반적으로 인자 없이 호출되고,
"ArgumentParser" 는 "sys.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
-------

때로는 여러 파서가 공통 인자 집합을 공유하는 경우가 있습니다. 이러한
인자의 정의를 반복하는 대신, 모든 공유 인자를 갖는 파서를
"ArgumentParser" 에 "parents=" 인자로 전달할 수 있습니다. "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

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

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

"RawDescriptionHelpFormatter" 를 "formatter_class=" 로 전달하는 것은
description 과 epilog 가 이미 올바르게 포맷되어 있어서 줄 바꿈 되어서
는 안 된다는 것을 가리킵니다:

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

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

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

   >>> 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 를 사용하는 경우) 같은 옵션 문자열을 갖는 예
전의 인자들을 간단히 대체하는 것이 유용 할 수 있습니다. 이 동작을 얻으
려면, "ArgumentParser" 의 "conflict_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=" 인자를 "False" 로 "ArgumentParser" 에 전달하면
됩니다:

   >>> 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 - 일부 action 및 nargs 를 선택할 때 필요한 상숫값.

   * 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'" - 각각 "True" 와 "False" 값을 저장
  하는 "'store_const'" 의 특별한 경우입니다. 또한, 각각 기본값 "False"
  와 "True" 를 생성합니다. 예를 들면:

     >>> 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', default=0)
     >>> parser.parse_args(['-vvv'])
     Namespace(verbose=3)

  참고, 명시적으로 *0*으로 설정되지 않으면 *default*는 "None"이 됩니다
  .

* "'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'])

  버전 3.8에 추가.

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

모든 컨테이너는 *choices* 값으로 전달될 수 있기 때문에, "list" 객체,
"set" 객체, 사용자 정의 컨테이너 등이 모두 지원됩니다.


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: [-h] --foo FOO
   : error: the following arguments are required: --foo

예에서 보듯이, 옵션이 "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)s" 와 "add_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

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

"argparse" 는 "help" 값을 "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" 로 지칭됩니다. 하나의 명
령행 인자가 따라와야 하는 단일 선택 인자 "--foo" 는 "FOO" 라고 표시됩
니다. 예:

   >>> 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 값에 의해 결정됩니다.

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

선택 인자 액션의 경우, "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__" 메서드는 임의의 액션을 수행 할 수 있습니다만, 일반적으로
"dest" 와 "values" 에 기반하여 "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='?')

   >>> # invalid type
   >>> parser.parse_args(['--foo', 'spam'])
   usage: PROG [-h] [--foo FOO] [bar]
   PROG: error: argument --foo: invalid int value: 'spam'

   >>> # invalid option
   >>> parser.parse_args(['--bar'])
   usage: PROG [-h] [--foo FOO] [bar]
   PROG: error: no such option: --bar

   >>> # wrong number of arguments
   >>> 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='?')

   >>> # no negative number options, so -1 is a positional argument
   >>> parser.parse_args(['-x', '-1'])
   Namespace(foo=None, x='-1')

   >>> # no negative number options, so -1 and -5 are positional arguments
   >>> 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='?')

   >>> # negative number options present, so -1 is an option
   >>> parser.parse_args(['-1', 'X'])
   Namespace(foo=None, one='X')

   >>> # negative number options present, so -2 is an option
   >>> parser.parse_args(['-2'])
   usage: PROG [-h] [-1 ONE] [foo]
   PROG: error: no such option: -2

   >>> # negative number options present, so both -1s are options
   >>> 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_abbrev를 "False" 로 설정함으로써 비활성화시킬 수 있습니다.


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

   매개 변수 설명:

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

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

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

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

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

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

   * required - 부속 명령이 꼭 제공되어야 하는지 아닌지, 기본값은
     "False" (3.7에서 추가)

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

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

   몇 가지 사용 예:

      >>> # create the top-level parser
      >>> parser = argparse.ArgumentParser(prog='PROG')
      >>> parser.add_argument('--foo', action='store_true', help='foo help')
      >>> subparsers = parser.add_subparsers(help='sub-command help')
      >>>
      >>> # create the parser for the "a" command
      >>> parser_a = subparsers.add_parser('a', help='a help')
      >>> parser_a.add_argument('bar', type=int, help='bar help')
      >>>
      >>> # create the parser for the "b" command
      >>> parser_b = subparsers.add_parser('b', help='b help')
      >>> parser_b.add_argument('--baz', choices='XYZ', help='baz help')
      >>>
      >>> # parse some argument lists
      >>> 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" 명령이 지정되면 "foo" 와
   "bar" 어트리뷰트 만 존재하고, "b" 명령이 지정되면 "foo" 와 "baz" 어
   트리뷰트만 존재합니다.

   마찬가지로, 도움말 메시지가 부속 파서에서 요청되면 해당 파서에 대한
   도움말만 인쇄됩니다. 도움말 메시지에는 상위 파서나 형제 파서 메시지
   는 포함되지 않습니다. (하지만 각 부속 파서 명령에 대한 도움말 메시
   지는 위와 같이 "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()" 메서드는 또한 "title" 과 "description" 키워드 인
   자를 지원합니다. 둘 중 하나가 있으면 부속 파서의 명령이 도움말 출력
   에서 자체 그룹으로 나타납니다. 예를 들면:

      >>> 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_parser" 는 "aliases" 인자를 추가로 지원하는데, 여러 개
   의 문자열이 같은 부속 파서를 참조 할 수 있게 해줍니다. 이 예는
   "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()" 호출과 결합하여, 각 부
   속 파서가 어떤 파이썬 함수를 실행해야 하는지 알 수 있도록 하는 것입
   니다. 예를 들면:

      >>> # sub-command functions
      >>> def foo(args):
      ...     print(args.x * args.y)
      ...
      >>> def bar(args):
      ...     print('((%s))' % args.z)
      ...
      >>> # create the top-level parser
      >>> parser = argparse.ArgumentParser()
      >>> subparsers = parser.add_subparsers()
      >>>
      >>> # create the parser for the "foo" command
      >>> 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)
      >>>
      >>> # create the parser for the "bar" command
      >>> parser_bar = subparsers.add_parser('bar')
      >>> parser_bar.add_argument('z')
      >>> parser_bar.set_defaults(func=bar)
      >>>
      >>> # parse the args and call whatever function was selected
      >>> args = parser.parse_args('foo 1 -x 2'.split())
      >>> args.func(args)
      2.0
      >>>
      >>> # parse the args and call whatever function was selected
      >>> 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')

   버전 3.7에서 변경: 새로운 *required* 키워드 인자


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에 추가: *encodings* 및 *errors* 키워드 인자


인자 그룹
---------

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()" 메서드는 이
   표시를 사용자 정의하는데 사용할 수 있는 *title* 과 *description* 인
   자를 받아들입니다:

      >>> 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()" 의 *title*
   및 *description* 인자를 지원하지 않습니다.


파서 기본값
-----------

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" 가 어떻게 명령행에서 호출되어야 하는지에 대한 간단
   한 설명을 인쇄합니다. *file* 이 "None" 이면, "sys.stdout" 이 가정됩
   니다.

ArgumentParser.print_help(file=None)

   프로그램 사용법과 "ArgumentParser" 에 등록된 인자에 대한 정보를 포
   함하는 도움말 메시지를 출력합니다. *file* 이 "None" 이면,
   "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* 가 주어지면 그 전에 인쇄합니다. 사용자는 이 단계를 다르게
   처리하기 위해 이 메서드를 재정의할 수 있습니다:

      class ErrorCatchingArgumentParser(argparse.ArgumentParser):
          def exit(self, status=0, message=None):
              if status:
                  raise Exception(f'Exiting because of an error: {message}')
              exit(status)

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개 이상 스타일의 인자 처리.

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

* 사용자 정의 "type" 과 "action" 을 위한 훨씬 간단한 인터페이스 제공.

"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.Values" 를 "Namespace" 로, "optparse.OptionError" 와
  "optparse.OptionValueError" 를 "ArgumentError" 로 대체하십시오.

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

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