CLI Program에서의 arguments - argparse모듈

0. CLI(Command Line Interface) Program (=CLI 명령어)에서 사용되는 arguments 대한 주요 용어

• Command: 실행할 프로그램/스크립트 이름.
  • POSIX 공식 용어로는 utility 임. 
  • 예) python, git, ls
• Argument: 명령 뒤에 오는 모든 인자의 총칭. Parameter라고도 불림.
  • POSIX용어에선 operands, options 를 선호하나, 일반적으로는 Argument 가 보다 많이 사용됨.
  • positional argument과 option, option argument를 모두 포함
• Positional Argument: 옵션 이름 없이 위치로 의미가 정해지는 인자
  • POSIX에서는 operand (피연산자) 라고도 불리며 보통 목표/대상 의 경로 등이 지정됨. 
  • 예) cp source.txt dest.txt 에서 source.txt, dest.txt.
• Option (or Named Parameter): - 또는 -- 로 시작하는 이름 있는 인자
  • 값을 받을 수도 있음.
  • 예) -o out.txt, --mode train
  • Short Option: - 하나 + 한 글자.
    • 예) -v, -n 3
  • Long Option: -- 두 개 + 전체 이름.
    • POSIX 표준 개념은 아니며 GNU 확장에서 제안.
      • 참고로, POSIX에선 -- 만 기재시, 이를 end-of-options 로 처리.
      • end-of-options가 나오면, 이후의 token을 모조리 operand로 간주 (hypen으로 시작해도 상관없이 operand로 간주). 
    • 예) --verbose, --output result.txt
• Option Argument: 옵션 뒤에 전달되는 실제 값.
  • 예) --output result.txt 에서 result.txt
• Flag (Boolean Option / Switch): 값 없이 존재 자체로 의미가 있는 옵션
  • 예) -v, --verbose
• Subcommand: 명령 안의 하위 명령
  • POSIX의 표준 개념은 아님. 
  • 예) git commit, docker run

Python에선 argparse 와 getopt를 통해 이를 보다 쉽게 구현하게 해 줌.

 

argparse 모듈에서의 지원을 표로 정리하면 다음과 같음 (GNU 스타일에 친화적임):

표기	의미	argparse	POSIX	GNU확장	비고
-a -b	분리된 short option	지원	허용	허용	권장
-ab	short option 묶기 (clustering)	미지원	허용	허용	POSIX/GNU는 허용
-o value	short option + 값 (띄어쓰기)	지원	허용	허용	권장
-ovalue	short option +값 (붙여쓰기)	미지원	허용	허용
-o=value	short option + 값 (= 로 연결)	미지원	불가	일부	POSIX에선 사용 불가, GNU 확장에서 사용.
--opt value	long option + 값 (띄어쓰기)	지원	비표준	널리 사용	일반적
--opt=value	long option + 값 (= 로 연결)	지원	비표준	널리 사용	자주 사용됨

• 위 테이블에서 값은 option argument로 부르기도 함.

---

1. Simple Example

#!/usr/bin/env python3
import argparse

def main():
    parser = argparse.ArgumentParser(
        prog="hello.py",                   # program의 이름. 기본은 sys.argv[0] 임.
        description="argparse 빠른 시작 예제" # --help 시 출력되는 description
    )
    parser.add_argument(
        "name", 
        help="인사할 대상 이름 (positional)",
    )
    args = parser.parse_args()
    print(f"Hello, {args.name}!")

if __name__ == "__main__":
    main()

실행 예:

python hello.py Alice
python hello.py -h

 

vscode에서 디버깅하려면 launch.json에 args 를 추가해줘야 함:

https://ds31x.tistory.com/353#5-8.-args-

[vscode] Debug 사용법 요약: Python + launch.json :

---

2. argparse.Namespace

parser.parse_args() 의 반환값은 파싱의 결과물인 Namespace 객체임: args

• 앞서 예제코드에서 args 는 argparse.Namespace 클래스의 객체이며,
  commnad line에서 입력받은 arguments를 각각 attribute형태로 저장함.
• dict와 비슷(내부적으로 __dict__ 사용)하나, dot(".")을 통한 attribute에 접근이 가능함.
• 중첩된 dest를 사용하면 마지막 것으로 덮어쓰기가 되니 주의할 것.
• argparse 외부에서도 attribute를 자유롭게 추가 및 수정 가능함.

다음 예를 참고:

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--name", required=True)
parser.add_argument("--verbose", action="store_true")

# 다음과 같이 수동으로 넣어줄수도 있음.
args = parser.parse_args(["--name", "Alice", "--verbose",])
# args = parser.parse_args(["--name", "Alice", ])

print(args)          # Namespace(name='Alice', verbose=True)
print(type(args))    # <class 'argparse.Namespace'>
print(args.name)     # Alice
print(args.verbose)  # True
print(vars(args))    # {'name': 'Alice', 'verbose': True}  ← dict 변환

주요 특징:

• attribute 기반 접근: parser.add_argument("--precision") → args.precision
• dictionary로 변환 가능: vars(args) : __dict__가 내부에 있어야 사용가능.
• argparse 외부에서도 빈(empty) Namespace 객체 생성 및 속성 추가, 병합도 가능함.

from argparse import Namespace

# 빈 Namespace객체 생성.
ns1 = Namespace()
ns1.foo = 123
ns1.bar = "hi"
print(ns1)  # Namespace(foo=123, bar='hi')
print(f"{type(ns1) = }")
print(f"{vars(ns1)  = }")
print("-"*30)

# 속성을 가진 Namespace객체 생성 및 __dict__ 속성 확인.
ns2 = Namespace(a=1, b=2)
print(f"{type(ns2) = }")
print(ns2.__dict__)      # {'a': 1, 'b': 2}
print(f"{vars(ns2) = }") # __dict__ 속성의 dictionary 객체 반환: vars()
print("-"*30)

# 두개의 Namespace 병합하기: unpacking을 이용.
ns3 = Namespace(**vars(ns1), **vars(ns2))
print(ns3.__dict__)

# attribute를 얻는 다른 방법: hasattr과 getattr이용.
# vars처럼 __dict__의 내용을 바탕으로 처리.
# __getattr__()메서드를 오버라이딩하면 __dict__없이도 가능.
print(f"{hasattr(ns3, 'foo') = }")
print(f"{getattr(ns3, 'foo') = }")

결과는 다음과 같음:

Namespace(foo=123, bar='hi')
type(ns1) = <class 'argparse.Namespace'>
vars(ns1)  = {'foo': 123, 'bar': 'hi'}
------------------------------
type(ns2) = <class 'argparse.Namespace'>
{'a': 1, 'b': 2}
vars(ns2) = {'a': 1, 'b': 2}
------------------------------
{'foo': 123, 'bar': 'hi', 'a': 1, 'b': 2}
hasattr(ns3, 'foo') = True
getattr(ns3, 'foo') = 123

---

3. Option, Flag, Parameter 설정.

• Parameter: 프로그램 실행 시 전달되는 모든 인자를 가리킴.
• Positional Parameter: 옵션 이름 없이 위치로 의미가 정해지는 인자
• Option: - 또는 --로 시작하는 이름 있는 인자
  • Option Argument: 옵션 뒤에 오는 값
• Flag: 값이 없는 Potion(옵션 인자가 없음), 존재 여부로 기능 제어

#!/usr/bin/env python3
import argparse

"""
python your_script.py input.txt
python your_script.py input.txt --output result.txt
"""
def main():
    # ArgumentParser 객체 생성
    parser = argparse.ArgumentParser(description="POSIX 기준 Option/Flag/Parameter 예제")

    # 1. Positional Parameter
    # - 옵션 이름 없이 위치로 의미가 정해짐
    # - 예: cp source.txt dest.txt → source.txt, dest.txt
    parser.add_argument(
        "input",                    # positional parameter
        help="입력 파일 경로"          # 도움말 메시지
    )

    # 2. Option + Option Argument
    # - Option: 이름이 있는 인자 (--output 또는 -o)
    # - Option Argument: 해당 옵션 뒤에 전달되는 값
    #   예: --output result.txt → result.txt 가 option argument
    parser.add_argument(
        "-o", "--output",            # short option(-o), long option(--output)
        help="출력 파일 경로"           # 도움말 메시지
    )

    # 3. Flag
    # - 값이 없는 Option (option argument 없음)
    # - 존재 여부로 동작 제어
    #   예: --verbose
    parser.add_argument(
        "-v", "--verbose",            # short option(-v), long option(--verbose)
        action="store_true",          # 지정 시 True, 미지정 시 False
        help="자세한 로그 출력"           # 도움말 메시지
    )

    # 명령줄 인자 파싱
    args = parser.parse_args()

    # Flag 사용 예시
    if args.verbose:
        print("[VERBOSE] 시작")

    # Positional Parameter와 Option Argument 값 출력
    print(f"입력: {args.input}")
    print(f"출력: {args.output if args.output else '(지정 안 함)'}")

# entry point
if __name__ == "__main__":
    main()

 

위의 예제는 다음과 같이 실행해야 함.

python your_script.py input.txt
python your_script.py input.txt --output result.txt

---

4. 타입, 기본값, 필수, 선택지 제한

positional parameter, option, option argument를 구분하면서
argparse에서 다음의 기능을 제공함.

• 타입 강제(type),
• 기본값(default),
• 필수 지정(required),
• 선택지 제한(choices)

type=callable에서 검증 실패 시
argparse.ArgumentTypeError를 던지도록 구현 권장.
이 경우, 다른 예외 종류더라도 예외 발생시,
표준 형식의 에러/사용법이 자동으로 출력됨.

#!/usr/bin/env python3
import argparse

def positive_int(x: str) -> int:
    """
    커스텀 타입 변환 함수
    - 문자열 x를 int로 변환하고, 양의 정수인지 검증
    - 검증 실패 시 ArgumentTypeError를 발생시켜 argparse가
      표준적인 사용법 메시지와 함께 종료하도록 함
    """
    v = int(x)
    if v <= 0:
        raise argparse.ArgumentTypeError("양의 정수 필요")
    return v

def main():
    # ArgumentParser 생성
    # description: 사용법(help) 상단에 표시될 프로그램 설명
    parser = argparse.ArgumentParser(description="타입/기본값/필수/선택지 제한")

    # 1) Positional Parameter (Positional parameter는 필수 입력임.)
    # - 옵션 이름 없이 '위치'로 의미가 정해지는 인자
    # - 예: myprog DATA_DIR
    parser.add_argument(
        "path",               # positional parameter 이름
        help="데이터 경로"       # 도움말
    )

    # 2) Option + Option Argument: -n / --num-epochs 
    #    Option은 Pasitional Arg.와 달리 필수가 아님.
    #    
    # - Option Argument: 정수(양의 정수로 제한)
    # - default: 미지정 시 10 사용
    parser.add_argument(
        "-n", "--num-epochs",           # short option / long option
        type=positive_int,              # 커스텀 타입 검사 (양의 정수만 허용)
        default=10,                     # 기본값
        metavar="N",                    # 도움말에 표시될 자리표시자
        help="epoch 수(양의 정수, 기본: 10)",
    )

    # 3) Option + Option Argument: --mode / -m
    #    필수로 입력하는 Option의 예!
    # 
    # - required=True: 이 옵션의 option argument를 반드시 제공해야 함
    # - choices: 허용되는 option argument 집합을 한정
    parser.add_argument(
        "-m", "--mode",                 # short option / long option
        choices=["train", "eval"],      # 선택지 제한
        required=True,                  # 필수 option
        help="실행 모드 (train|eval)",    # %(choices)s 사용해볼것.
        # help="실행 모드 %(choices)s",
    )

    # 명령줄 인자 파싱
    args = parser.parse_args()

    # 결과 출력 (검증·변환 이후의 값 사용)
    print(f"path={args.path}, epochs={args.num_epochs}, mode={args.mode}")

if __name__ == "__main__":
    main()

• default=argparse.SUPRESS 의 경우, option 이 미지정된 경우 해당 속성자체를 만들지 않음.
• 기본값을 지정하지 않은 경우 대부분 None 임.

---

5. 여러 값 받기 (nargs)

Option에 대해 여러 개의 Option Argument를 받을 때 nargs 옵션을 사용:

• nargs="+"는 1개 이상,
• nargs="*"는 0개 이상 값을 받는다는 의미

#!/usr/bin/env python3
import argparse

def main():
    # ArgumentParser 객체 생성
    parser = argparse.ArgumentParser(description="여러 값 받기")

    # 1) Option + Option Argument (여러 개)
    # - --images 뒤에 1개 이상의 파일 경로를 받음
    # - nargs="+": 1개 이상의 값 필수
    # - 예: prog.py -i img1.jpg img2.jpg img3.jpg
    parser.add_argument(
        "-i", "--images",        # short option / long option
        nargs="+",               # 1개 이상 값 필수
        required=True,           # 해당 option argument 제공 필수
        help="처리할 이미지들"       # 도움말 메시지
    )

    # 2) Option + Option Argument (0개 이상)
    # - --define 뒤에 0개 이상의 매크로 정의를 받음
    # - nargs="*": 0개 이상 가능 (없어도 에러 없음)
    # - default=[]: 미지정 시 빈 리스트
    # - 예: prog.py -D DEBUG LOGGING
    parser.add_argument(
        "-D", "--define",         # short option / long option
        nargs="*",                # 0개 이상 값 허용
        default=[],               # 기본값
        help="매크로 정의"           # 도움말 메시지
    )

    # 명령줄 인자 파싱
    args = parser.parse_args()

    # 받은 값 출력
    print(f"images={args.images}")
    print(f"define={args.define}")

if __name__ == "__main__":
    main()

---

6. 카운트형 플래그 (action 파라메터 사용하기)

Option(Flag)을 반복해서 지정할수록 값이 1씩 증가하여 로깅 레벨이나 디버그 강도를 조절할 때 유용한 "count" action의 사용법을 소개하는 예제는 다음과 같음:

#!/usr/bin/env python3
import argparse

def main():
    # ArgumentParser 객체 생성
    parser = argparse.ArgumentParser(description="카운트형 플래그 예제")

    # 1) Flag (값 없는 Option, Option Argument 없음)
    # - -v 또는 --verbose 를 반복 지정하면 verbose 값이 1씩 증가
    # - action="count": 지정된 횟수를 카운트하여 정수로 반환
    # - default=0: 지정하지 않으면 0
    # - 예:
    #   prog.py               → verbose=0
    #   prog.py -v            → verbose=1
    #   prog.py -vv           → verbose=2
    #   prog.py -v -v -v      → verbose=3
    parser.add_argument(
        "-v", "--verbose",              # short option / long option
        action="count",                 # 지정 횟수를 카운트
        default=0,                      # 미지정 시 0
        help="자세한 로그: -v, -vv, -vvv"  # 도움말 메시지
    )

    # 명령줄 인자 파싱
    args = parser.parse_args()

    # Flag 지정 횟수 출력
    print(f"verbose={args.verbose}")

if __name__ == "__main__":
    main()

argparse는 POSIX 스타일 short option 묶기(-a -b → -ab)는 지원하지 않지만,
-vv처럼 같은 short option을 반복 지정한 경우는 action="count"일 때만 지원함.

---

참고: 기본 제공되는 action 값들.

action 값	동작 설명	비고 / 예시
store (기본값)	인자의 값을 저장 넘어오지 않은 경우 None	--name Alice → args.name == "Alice"
store_const	미리 지정한 const 값을 저장 const 파라미터를 통해 값을 인자로 넘김.	--flag (const="ON") → args.flag == "ON"
store_true	지정 시 True, 없으면 False	--verbose → True / False
store_false	지정 시 False, 없으면 True	반대 동작
append	인자를 리스트에 추가	--tag a --tag b → ['a', 'b']
append_const	미리 지정한 const 값을 리스트에 추가 const 파라미터를 통해 값을 인자로 넘김.	const=1 → [1, 1, 1]
count	지정된 횟수를 정수로 저장	-v -v → 2
help	도움말 출력 후 종료	-h 또는 --help
version	버전 정보 출력 후 종료 기본적으로 추가되어 있음.	--version
callable 객체	사용자 정의 동작 실행	action=MyCustomAction (하위 클래스 정의)

 

예제 코드는 다음과 같음:

#!/usr/bin/env python3
import argparse

# 사용자 정의 action 예제
class UppercaseAction(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        # option argument 값을 대문자로 변환하여 저장
        setattr(namespace, self.dest, values.upper())

def main():
    parser = argparse.ArgumentParser(description="argparse action 값 동작 확인 예제")

    # 1) store (기본값)
    # - Option + Option Argument
    # - 전달된 값을 그대로 저장
    parser.add_argument(
        "--store",
        help="store: 인자 값을 그대로 저장"
    )

    # 2) store_const
    # - Flag 역할 (값 없는 Option)
    # - 지정되면 const 값을 저장
    parser.add_argument(
        "--store-const",
        action="store_const",
        const="CONST_VALUE",           # 지정 시 저장할 값
        help="store_const: const 값 저장"
    )

    # 3) store_true / store_false
    # - Flag (값 없는 Option)
    # - 지정 시 True/False를 저장
    parser.add_argument(
        "--store-true",
        action="store_true",
        help="store_true: 지정 시 True"
    )
    parser.add_argument(
        "--store-false",
        action="store_false",
        help="store_false: 지정 시 False"
    )

    # 4) append
    # - Option + Option Argument
    # - 같은 옵션이 여러 번 등장하면 리스트에 값 추가
    parser.add_argument(
        "--append",
        action="append",
        help="append: 리스트에 값 추가"
    )

    # 5) append_const
    # - Flag (값 없는 Option)
    # - 지정 시 const 값을 리스트에 추가
    # - dest로 변수명 지정
    parser.add_argument(
        "--append-const",
        action="append_const",
        const=42,
        dest="append_list",
        help="append_const: const 값을 리스트에 추가"
    )

    # 6) count
    # - Flag (값 없는 Option, 반복 가능)
    # - 같은 옵션을 반복 지정하면 횟수를 세어 정수로 저장
    parser.add_argument(
        "-v", "--verbose",
        action="count",
        default=0,
        help="count: 지정 횟수를 정수로 반환. 기본은 %(defaults)s" # substition string.
    )

    # 7) help (자동 제공) → -h / --help
    # - Flag, 도움말 출력 후 프로그램 종료

    # 8) version
    # - Flag, 버전 정보 출력 후 프로그램 종료
    parser.add_argument(
        "--version",
        action="version",
        version="%(prog)s 1.0" # help 메시지에서 사용되는 substition string
    )

    # 9) callable (사용자 정의 action)
    # - Option + Option Argument
    # - 값을 원하는 방식으로 처리 가능
    parser.add_argument(
        "--upper",
        action=UppercaseAction,
        help="callable: 값을 대문자로 변환"
    )

    # 명령줄 인자 파싱
    args = parser.parse_args()

    # 결과 출력
    print(args)

if __name__ == "__main__":
    main()

---

7. Subcommnad(서브커맨드)

Subcommand는 상위 명령의 기능을 세분화하는 데 사용되며,
각 subcommand는 고유한 option과 동작함수를 설정할 수 있음.

---

방식은 다음과 같음:

parser = argparse.ArgumentParser()

# subcommand 만들기.
subparsers = parser.add_subparsers(dest="cmd") # 입력한 서브커맨드는 cmd 속성에 저장됨.
p_add = subparsers.add_parser("add")

# sub-subcommnad 만들기.
sub_subparsers = p_add.add_subparsers(dest="scmd") # 입력한 서브서브커맨드는 scmd 속성에 저장됨.
p_add_list = sub_subparsers.add_parser("list")

1. add_subparsers() → _SubParsersAction 객체 반환: subparsers
2. _SubParsersAction.add_parser() → ArgumentParser 객체(서브파서) 생성: p_add
3. 메인 파서에 _SubParsersAction이 등록되어, 입력된 서브커맨드에 따라 적절한 서브파서가 동작
4. conda env list 와 같이 subcommand 에서 subcommand 를 입력하려면, 생성된 서브 파서 (ArgumentParser 객체)에서 다시 add_subparseres()를 하여 _SubParsersAction 객체를 다시 생성시키고 해당 객체로 다시 서브파서를 생성시켜 처리.

---

하나의 Command 안에서 여러 Subcommand를 지원하는 argparse 사용법에 대한 예제코드임.

#!/usr/bin/env python3
import argparse

# ----- 서브커맨드 동작 함수 -----
def cmd_train(ns: argparse.Namespace) -> None:
    """
    'train' 서브커맨드 실행 함수
    - ns: argparse가 생성한 Namespace 객체
    """
    print(f"[{ns.command}] data={ns.data} epochs={ns.epochs}")

def cmd_eval(ns: argparse.Namespace) -> None:
    """
    'eval' 서브커맨드 실행 함수
    """
    print(f"[{ns.command}] data={ns.data} checkpoint={ns.ckpt}")

def main():
    # 메인 ArgumentParser 생성
    parser = argparse.ArgumentParser(description="서브커맨드 예제")

    # 서브파서(subparsers) 생성
    # - dest="command": 선택된 서브커맨드 이름을 저장할 변수명
    # - required=True: 서브커맨드 지정 필수
    subparsers = parser.add_subparsers(dest="command", required=True)

    # ----- train 서브커맨드 -----
    p_train = subparsers.add_parser("train", help="모델 학습")
    # Option + Option Argument (--data)
    p_train.add_argument("--data", required=True, help="학습 데이터 경로")
    # Option + Option Argument (--epochs)
    p_train.add_argument("--epochs", type=int, default=10, help="학습 epoch 수(기본: 10)")
    # # 이 서브커맨드 실행 시 호출할 함수 등록
    # p_train.set_defaults(func=cmd_train)

    # ----- eval 서브커맨드 -----
    p_eval = subparsers.add_parser("eval", help="모델 평가")
    p_eval.add_argument("--data", required=True, help="평가 데이터 경로")
    p_eval.add_argument("--ckpt", required=True, help="체크포인트 파일 경로")
    # p_eval.set_defaults(func=cmd_eval)

    # 명령줄 인자 파싱
    ns = parser.parse_args()

    # 선택된 서브커맨드의 실행 함수 호출
    # ns.func(ns) # set_defaults를 모두 설정시 이 방식이 일반적.
    # ------
    # set_defaults를 설정하지 않은 경우 아래와 같이 if문으로 처리할 수도 있음.
    if ns.command == "train":
        cmd_train(ns)
    elif ns.command == "eval":
        cmd_eval(ns)
    else:
        # control never reach here 
        # via parser.parse_args()!
        pass
    # -----

if __name__ == "__main__":
    main()

---

참고: 도움말 표기 관례에서의 심볼.

POSIX, GNU 에서 CLI 툴의 도움말 표기(or 표준 문서화 관례)에서 주로 사용되는 심볼들의 의미는 다음과 같음:

• curly bracket { } : 필수이고, 선택지는 내부에 나열된 것 중에 하나.
• square bracket [ ] : optional(선택)적인 옵션.
• vertical bar | : or 의 의미.
• ... : 앞의 인자가 여러번 반복해서 입력될 수 있음을 의미: ex) cp SOURCE... DEST = cp file1.txt file2.txt backup/
• brace ( ) : vertical bar와 같이 묶여서 여러 옵션이나 인자들의 OR관계를 명확히 표시: ex) usage: prog (-a | -b) FILE 

---

8. 요약

• short option
  • 값(value, option argument)은 띄어쓰기: -o value
  • argparse모듈에선 -o=value 미지원
  • 묶기 -ab 미지원 (-a -b만 가능)
• long option
  • --opt value 지원
  • --opt=value 지원
• flag
  • 값 없음, 존재하면 True
• 반복 플래그
  • action="count"로 구현 (-vvv 가능)

개념	POSIX 용어	GNU (주로 GNU getopt/문서)	Python argparse
실행 명령	Command	Program / Command	Program / Script
인자 상위 개념	Parameter	Argument(일반 용어)	Argument
옵션(이름 있는 인자)	Option (-o)	Option (-o, --long)	Optional argument (옵션)
짧은 옵션	Option (short option)	Short option (-o)	Short option (-o)
긴 옵션	(표준 없음, 확장)	Long option (--output)	Long option (--output)
옵션 뒤 값	Option argument	Option argument / value	Option argument (저장 대상 값)
위치 기반 값	Operand 또는 Positional parameter	Positional argument	Positional argument
값 없는 옵션	(값 없는 option)	Flag / Boolean option	Flag (store_true/false, count)
서브커맨드	(표준 용어 없음)	Subcommand(관용)	Subparsers / Subcommand
도움말	(명시 X, 유틸리티별)	--help(관례)	-h/--help (action="help")
버전	(명시 X)	--version(관례)	--version (action="version")

---

같이보면 좋은 자료들

https://dsaint31.tistory.com/477

[Python] argparse 사용하기.

2023.10.10 - [Python] - [Python] Example: input, sys.argv and argparse

[Python] Example: input, sys.argv and argparse

---

2024.07.24 - [Python] - [Python] 사용자와 상호작용: 입력받기: input, sys.argv and argparse

[Python] 사용자와 상호작용: 입력받기: input, sys.argv and argparse

---