✧ Принимаем аргументы командной строки ✧

🚀 Запускаем

Настоящие утилиты запускают из терминала и сразу говорят им, что делать: python resin.py 160 --have 40. Попробуем сделать такую. В песочнице терминала нет, поэтому «строку из терминала» мы передадим списком. Запусти:

import argparse

parser = argparse.ArgumentParser(description="Считает, сколько смолы нужно докопить")
parser.add_argument("need", type=int, help="сколько смолы нужно")
parser.add_argument("--have", type=int, default=0, help="сколько уже есть")

args = parser.parse_args(["160", "--have", "40"])

missing = args.need - args.have
print("Не хватает:", missing)
print("Ждать минут:", missing * 8)
Не хватает: 120
Ждать минут: 960

Каждая единица смолы набегает за 8 минут, поэтому 120 единиц — это 960 минут, то есть ровно 16 часов. Теперь замени в списке "--have", "40" на "--have", "100" и убери --have совсем: без него сработает значение по умолчанию, 0.

📜 Теория: argparse

Что приходит из терминала

Всё, что написано после имени файла, Python кладёт в список строк sys.argv. Для python resin.py 160 --have 40 он выглядит так: ['resin.py', '160', '--have', '40']. Разбирать такой список руками утомительно: надо превратить строки в числа, не перепутать порядок, придумать, что делать с ошибкой и как рассказать про все эти параметры пользователю. Модуль argparse берёт это на себя.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("need", type=int)

# parser.parse_args() — на своём компьютере читает sys.argv
args = parser.parse_args(["160"])        # а здесь список свой
print(args.need)                         # → 160

Второй вариант нужен нам в курсе (в песочнице нет терминала), а ещё в тестах: собрал список, передал, проверил результат.

Позиционные аргументы и опции

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("name")                          # позиционный: обязательный, важен порядок
parser.add_argument("--level", type=int, default=1)   # опция: можно не указывать
parser.add_argument("-v", "--verbose", action="store_true")   # флаг: есть или нет

args = parser.parse_args(["Эмбер", "--level", "80", "-v"])
print(args.name, args.level, args.verbose)     # → Эмбер 80 True

Название без дефисов — позиционный аргумент: он обязателен, и его значение определяется местом в строке. Название с -- — опция: её можно пропустить, тогда берётся default (если он не задан, будет None). action="store_true" делает опцию флагом без значения: есть в строке — True, нет — False. Через дефис в имени получается подчёркивание: --max-level попадёт в args.max_level.

Типы, варианты и списки значений

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--element", choices=["Пиро", "Гидро", "Крио"])
parser.add_argument("names", nargs="+")              # одно имя или больше
parser.add_argument("--level", type=int, default=1)

args = parser.parse_args(["Эмбер", "Лиза", "--element", "Пиро"])
print(args.names, args.element)     # → ['Эмбер', 'Лиза'] Пиро

type=int превращает строку в число сразу при разборе, а choices не пропустит ничего, кроме перечисленного. nargs="+" собирает в список все значения подряд ("*" — ноль или больше, "?" — необязательное одно). Типом может быть и своя функция: type=float, type=Path.

Справка и ошибки бесплатно

import argparse

parser = argparse.ArgumentParser(prog="resin", description="Считает, сколько смолы нужно докопить")
parser.add_argument("need", type=int, help="сколько смолы нужно")
parser.add_argument("--have", type=int, default=0, help="сколько уже есть")
parser.print_help()
usage: resin [-h] [--have HAVE] need

Считает, сколько смолы нужно докопить

positional arguments:
  need         сколько смолы нужно

options:
  -h, --help   show this help message and exit
  --have HAVE  сколько уже есть

Справка собралась из того, что мы написали в help=. Пользователь вызывает её так: python resin.py -h. А если он ошибся, argparse сам напишет понятное сообщение, например resin: error: argument need: invalid int value: 'abc', и завершит программу с кодом 2. Технически он бросает исключение SystemExit; если нужно сделать что-то своё, его можно перехватить:

import argparse

parser = argparse.ArgumentParser(prog="resin")
parser.add_argument("need", type=int)

try:
    args = parser.parse_args(["abc"])
except SystemExit:
    print("Неверные аргументы")        # сообщение об ошибке argparse уже ушло в stderr

Как строки превращаются в аргументы

В терминале строку на слова делит оболочка: "Дикий кабан" 5 — это два слова, потому что кавычки склеили первое. В задачах курса мы читаем одну строку через input() и делим её сами. Для строк без кавычек хватает .split(); если внутри бывают кавычки, берут shlex.split(line), который понимает их так же, как оболочка:

import shlex
print(shlex.split('"Дикий кабан" 5'))       # → ['Дикий кабан', '5']
print('"Дикий кабан" 5'.split())            # → ['"Дикий', 'кабан"', '5']

🧪 Попробуй сам

★★★

🎯 Задача: Сколько ждать смолу

10 очков

Паймон пишет утилиту resin. В терминале её запускали бы так: resin 160 --have 40. У нас строку аргументов (всё, что идёт после имени программы) читает input().

Аргументы утилиты:

  • need — позиционный, целое: сколько смолы нужно;
  • --have — целое, по умолчанию 0: сколько уже есть;
  • --regen — целое, по умолчанию 8: сколько минут набегает одна единица.

Если смолы уже хватает (have не меньше need), выведи Смолы хватает. Иначе выведи две строки: Не хватает: <сколько> и Ждать: <часы> ч <минуты> мин (часы и остаток минут, без нулей впереди).

Пример. Ввод:

160 --have 40

Вывод:

Не хватает: 120
Ждать: 16 ч 0 мин

Второй пример. Ввод 200 --have 190 --regen 10, вывод:

Не хватает: 10
Ждать: 1 ч 40 мин

Заготовка (кнопка у блока отправит её в песочницу):

import argparse

line = input()      # строка аргументов, как её набрали бы в терминале

# 1. Создай разборщик и опиши аргументы need, --have и --regen

# 2. Разбери строку (разбить её на слова поможет split)

# 3. Если смолы хватает, выведи «Смолы хватает»; иначе посчитай ожидание
★★★

🎯 Задача: Состав отряда

25 очков

Утилита team собирает отряд. Строка аргументов приходит через input(), но имена бывают из двух слов («Бэй Доу»), поэтому в строке они стоят в кавычках, как в терминале. Разбивай строку так, как это делает оболочка (shlex.split).

Аргументы:

  • names — позиционный, одно имя или больше;
  • --element — одна из стихий: Пиро, Гидро, Электро, Крио, Дендро, Анемо, Гео; по умолчанию не задан;
  • --level — целое, по умолчанию 1.

Если argparse не принял аргументы (нет имён, стихия не из списка, уровень не число), выведи Ошибка в аргументах. Если имён больше четырёх, выведи В отряде не больше 4 персонажей. Иначе выведи Отряд (<стихия>, ур. <уровень>): <имена через запятую>; если стихия не задана, пиши вместо неё слово любая.

Пример. Ввод:

Эмбер Лиза --element Пиро --level 80

Вывод:

Отряд (Пиро, ур. 80): Эмбер, Лиза

Второй пример. Ввод "Бэй Доу" Кли, вывод:

Отряд (любая, ур. 1): Бэй Доу, Кли

Заготовка (кнопка у блока отправит её в песочницу):

import argparse
import shlex

line = input()      # строка аргументов, как её набрали бы в терминале

# 1. Опиши аргументы names, --element (choices) и --level

# 2. Разбери строку; если argparse завершил программу (SystemExit), выведи «Ошибка в аргументах»

# 3. Проверь число имён и выведи отряд

✅ Что мы узнали

Аргументы командной строки лежат в sys.argv как строки, а argparse превращает их в удобный объект: позиционные аргументы обязательны, опции (--имя) можно пропустить, флаги — это store_true. Типы, варианты (choices) и справку он проверяет и пишет сам; ошибки заканчиваются SystemExit с кодом 2. Для проверок список аргументов передают прямо в parse_args([...]).

Дальше сделаем программу с командами, как у git: у каждой свои аргументы.

⟵ Идём по деревьям и графам Делаем программу с командами ⟶