( Image (C) Tai Kedzierski )

Python ArgParse 빠른 참조

인수 구문 분석에 대한 빠른 참조 및 하위 명령 구현 모델에 대한 제안입니다.

구문 분석 - 빠른 참조

주석이 달린 일반 인수 정의(표준 문서에서).
type= 인수는 실제로 호출 가능한 처리기이며 모든 함수 또는 생성자일 수 있습니다. 이러한 방식으로 인수가 필요한 형식으로 즉시 변환되도록 보장할 수 있습니다. 그런 다음 해당 인수를 사용하는 모든 것은 인수 해석을 연기할 필요 없이 결과적으로 완전히 외삽된 인수를 얻을 수 있습니다.

parser.add_argument(
    'integers', # Argument name

    metavar='N', # will be actually accessed in  "parsed_args.N"
                 # instead of "parsed_args.integers"

    type=int,    # actually a type converter - the callable must take 1 argument,
                 #  the value, and return the value coerced to the correct type

    nargs='+',   # Specifies that there must be one to any number of these

    help='an integer for the accumulator'  # A help string for "--help" option
    )

인수 구문 분석 기능을 구현하는 기본 예:

def parse_app_args():
    # Create a top-level parse
    parser = argparse.ArgumentParser()

    # Immediately create a subparser holder for a sub-command.
    # The sub-command's string will be stored in "parsed_arguments.cmd"
    #   of the parsed arguments' namespeace object
    subparsers = parser.add_subparsers(dest="cmd")

    # Now we have the holder, add actual parsers to it

    # The first subcommand. When arguments are parsed, the value "power"
    #   would be found in "parsed_args.cmd" , because it is a named parser for the
    #   subparser collection with `dest="cmd"` from above
    subp_power = subparsers.add_parser("power")

    # Sub-arguments - uses the same function signature as described in documentation
    # for top-level "add_parser"
    # Note the use of `choice=` to force specific raw values
    subp_power.add_argument("state", choices=["on", "off"])

    return parser.parse_args(sys.argv[1:])

하위 명령-모듈 구현에 대한 제안

종종 응용 프로그램에 대해 여러 작업이 필요하다는 것을 알게 될 것입니다. 이때 하위 명령을 구현하고 하위 구문 분석기를 사용할 수 있습니다.

이 시점에서 크고 다루기 힘든 파일을 좋아하지 않거나 한 파일의 인수 파서와 다른 파일의 해당 모듈을 결합하려고 시도하지 않는 한 구현에 대해 좀 더 전략적인 것이 좋을 수 있습니다.

다음 예에서는 구현합니다.

main.py 파일의 기본 논리 및 기본 파서

그러나 구체적으로 모듈이

하위 명령에 대해 기대하는 인수

실제 구현.

, setup_args(subparser) 및 run(args) 메서드

를 모두 제공하는 모든 모듈 포함

main.py

#!/usr/bin/env python3

import sys
import argparse

# Some fictional machine API - split the logic into modules
import power
import engine


def parse_app_args(args=sys.argv[1:]):
    parser = argparse.ArgumentParser()

    subparsers = parser.add_subparsers(dest="cmd")

    # Farming out the subparser definitionss to their respective modules
    # So each module can define its parsing options itself
    power.setup_args(subparsers)
    engine.setup_args(subparsers)

    # The third argument
    # An example showing we can have a subcommand with no arguments
    # by just adding a named subparser
    subparsers.add_parser("break")

    return parser.parse_args(args)


def main():
    parsed_args = parse_app_args()

    # We make a point of moving subcommand implementations to their own files,
    #  to decluttrer this main file
    command_map = {
        "power": power.run,
        "engine": engine.run,
        "break": lambda _: print("Why are you trying to break things? :-'(") ,
        None: lambda _: parse_app_args(["--help"])
    }

    # Because the parser will only accept values for the named subparser,
    #  we can consider the check has already been done for us :-)
    command_map[parsed_args.cmd](parsed_args)


if __name__ == "__main__":
    main()

engine.py

def setup_args(subparsers):
    subp_engine = subparsers.add_parser("engine")
    subp_engine.add_argument("speed", type=int)


def run(args):
    print("Setting engine speed: {}".format(args.speed))

power.py

def setup_args(subparsers):
    subp_power = subparsers.add_parser("power")
    subp_power.add_argument("state", choices=["on", "off"])


def run(args):
    print("Setting power state: {}".format(args.state))