Освоение модуля argparse в Python: создание более эффективных интерфейсов командной строки

Учебники
Python

Python – это мощный язык программирования, который позволяет разработчикам создавать различные приложения, от простых скриптов до крупных программных систем. Одной из наиболее распространенных задач программирования является создание интерфейсов командной строки (CLIs), которые позволяют пользователям взаимодействовать с программами через терминал или командную строку. CLIs необходимы для написания сценариев, автоматизации и случаев, когда графический пользовательский интерфейс непрактичен.

Обработка параметров командной строки является важной частью проектирования CLIs. Эти аргументы позволяют пользователям влиять на поведение программы, предоставляя входные параметры во время ее выполнения. Без возможности оценки этих факторов программы были бы менее гибкими и сложнее настраивать для конкретных задач.

Python предоставляет несколько модулей для разбора аргументов командной строки, но модуль argparse выделяется своей простотой и полнотой. Модуль argparse упрощает разработку функциональных интерфейсов командной строки. Он автоматически обрабатывает разбор параметров, отображает полезные инструкции и предоставляет сообщения об ошибках, если пользователи предоставляют некорректную информацию.

В этом руководстве мы рассмотрим, как использовать пакет Python argparse. Мы начнем с обзора командных интерфейсов Python и важности разбора ввода с командной строки. Затем мы обсудим модуль argparse и его преимущества.

Обзор интерфейсов командной строки в Python

Интерфейсы командной строки – это программы, которые работают исключительно на основе текстовых команд. Пользователи вводят команды в терминал или командную строку, которые обычно включают аргументы и опции, изменяющие поведение программы. CLI полезны, поскольку их легко автоматизировать и интегрировать с другими технологиями.

На Python CLI создается путем разработки скрипта, который принимает ввод с командной строки. Этот ввод обычно представлен в виде списка аргументов, к которым скрипт может обращаться и интерпретировать. Для простых программ вручную обработка этих аргументов через список sys.argv может быть достаточной. Однако при увеличении сложности программы вручную обрабатывать аргументы становится неэффективно и подвержено ошибкам.

Важность разбора аргументов командной строки

Разбор аргументов командной строки необходим по многим причинам: 

  • Гибкость: Принимая параметры, программа может выполнять несколько задач или действовать на различных наборах данных без изменения кода. Пользователи могут указывать файлы для обработки, настраивать настройки и выбирать режимы работы.
  • Удобство использования: Правильный разбор аргументов позволяет программе отображать полезные сообщения, инструктировать пользователя о способах использования программы и грамотно обрабатывать ошибки.
  • Обслуживаемость: Использование специализированного модуля парсинга, такого как argparse, делает ваш код более понятным и легким в обслуживании. Он отделяет логику, используемую для разбора аргументов, от основной операции программы.

Введение в модуль argparse и его преимущества

Модуль argparse является частью стандартной библиотеки Python. Поэтому его можно использовать без установки дополнительных пакетов. Он предлагает простой и последовательный интерфейс для разбора входных данных с командной строки. Некоторые из преимуществ использования argparse включают:

  • Автоматическая генерация справки: Он генерирует сообщения справки и использования на основе аргументов кода.
  • Обработка ошибок: Он отображает полезные сообщения об ошибках, когда пользователи вводят недопустимые аргументы.
  • Преобразование типов: Он может автоматически преобразовывать строки параметров в соответствующий тип данных.
  • Он поддерживает как обязательные позиционные аргументы, так и необязательные аргументы с простотой.
  • Значения по умолчанию: Он позволяет задавать значения по умолчанию для параметров, которые пользователь не предоставляет.

argparse позволяет разработчикам сосредоточиться на основной функциональности своей программы, полагаясь на крепкое основание для управления вводом с командной строки.

Настройка argparse и основное использование

Теперь, когда мы рассмотрели важность разбора аргументов командной строки и преимущества использования argparse, давайте посмотрим, как его настроить и использовать в сценарии Python.

Установка и импорт argparse

Нет необходимости устанавливать что-либо отдельно, потому что argparse является частью стандартной библиотеки Python. Вы можете импортировать его прямо в начале вашего сценария.

import argparse

Эта строка загружает модуль argparse в ваш сценарий, позволяя вам использовать его функционал для разбора аргументов командной строки.

Создание простого парсера аргументов

Первый шаг в использовании argparse – создать объект парсера. Этот объект будет хранить информацию о аргументах, принимаемых вашей программой, и разбирать ввод с командной строки.

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

В этом примере мы создаем объект ArgumentParser() и описываем программу. Когда пользователь выбирает опцию помощи (-h или --help), будет отображено это описание.

Добавление позиционных и опциональных аргументов

Теперь, когда мы разработали парсер, мы можем указать аргументы, которые будет принимать наша программа.

Добавление позиционных аргументов

Позиционные аргументы необходимы и должны быть представлены в точном порядке. Например, рассмотрим сценарий, который складывает два числа. Мы можем определить два позиционных аргумента для чисел:

parser.add_argument('num1', type=int, help='The first number to add.')
parser.add_argument('num2', type=int, help='The second number to add.')

В этом коде num1 и num2 относятся к позиционным параметрам.

type=int указывает, что параметры должны быть преобразованы в целые числа. Аргумент справки определяет описание, которое будет отображаться в сообщении справки.

Добавление необязательных аргументов

Необязательные аргументы не являются обязательными и обычно предоставляют дополнительные опции или изменяют поведение программы. Обычно они предварены одним или двумя тире. Мы добавим необязательный аргумент для включения подробного вывода:

parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.')

Здесь:

  • Короткая опция – -v (например, -v). --verbose – длинная опция.
  • action='store_true' указывает, что если опция выбрана, атрибут verbose будет установлен в True; в противном случае он будет False.
  • Аргумент help определяет описание для сообщения справки.

Разбор аргументов и доступ к их значениям

После определения всех аргументов нам нужно разобрать ввод с командной строки. Используйте метод .parse_args() для этого.

args = parser.parse_args()

Разобранные параметры теперь хранятся в переменной args как атрибуты. Мы можем получить к ним доступ, используя точечную нотацию.

result = args.num1 + args.num2
print('The sum of {} and {} is {}'.format(args.num1, args.num2, result))
if args.verbose:
    print('Verbose mode is enabled.')

Собрав все вместе, вот полный скрипт, который складывает два числа и включает необязательный режим подробного вывода:

import argparse
parser = argparse.ArgumentParser(description='Add two integers.')
parser.add_argument('num1', type=int, help='The first number to add.')
parser.add_argument('num2', type=int, help='The second number to add.')
parser.add_argument('-v', '--verbose', action='store_true', help='Increase output verbosity.')
args = parser.parse_args()
result = args.num1 + args.num2
print('The sum of {} and {} is {}'.format(args.num1, args.num2, result))
if args.verbose:
    print('Calculation completed successfully.')

Вы можете запустить этот скрипт из командной строки и предоставить необходимые позиционные аргументы:

python add_numbers.py 3 5
The sum of 3 and 5 is 8

Если вы включите опцию -v или --verbose, скрипт выведет дополнительное подробное сообщение:

python add_numbers.py 3 5 --verbose
The sum of 3 and 5 is 8
Calculation completed successfully.

Если пользователь запустит скрипт с опцией -h или --help, argparse отобразит автоматически сгенерированное сообщение справки:

python add_numbers.py -h
usage: add_numbers.py [-h] [-v] num1 num2
Add two integers.
positional arguments:
  num1           The first number to add.
  num2           The second number to add.
optional arguments:
  -h, --help     show this help message and exit
  -v, --verbose  Increase output verbosity.

Эта функция делает вашу программу более удобной для пользователя, предоставляя четкие инструкции о ее использовании.

Расширенная обработка аргументов

При разработке командных программ на Python вы можете столкнуться с ситуациями, требующими более сложного разбора аргументов. Модуль argparse в Python включает несколько функций для решения этих сложных требований, позволяя разрабатывать гибкие и удобные интерфейсы.

Использование nargs для нескольких аргументов

Бывают ситуации, когда ваше приложение должно принимать множество значений для одного аргумента. Например, предположим, что вы хотите создать скрипт, который обрабатывает несколько файлов одновременно. Параметр nargs в argparse позволяет указать, сколько аргументов командной строки должно быть считано.

Вот как использовать nargs для приема нескольких имен файлов:

import argparse
parser = argparse.ArgumentParser(description='Process multiple files.')
parser.add_argument('filenames', nargs='+', help='List of files to process.')
args = parser.parse_args()
for filename in args.filenames:
    print(f'Processing file: {filename}')
    # Добавьте ваш код обработки файлов здесь

В этом случае nargs='+' указывает парсеру ожидать один или более аргументов в именах файлов. Пользователь может указать столько имен файлов, сколько необходимо, и они будут сохранены в списке с именем args.filenames.

Если вы хотите принять определенное количество аргументов, установите nargs на это число. Например, nargs=2 требует ровно два параметра.

Реализация выбора для ограничения значений аргументов

Иногда вам нужно ограничить аргумент в указанном диапазоне допустимых значений. Это гарантирует, что пользователь предоставляет допустимый ввод, тем самым избегая ошибок или неожиданных действий. Параметр options позволяет указать допустимые значения для аргумента.

Рассмотрим скрипт, который выполняет несколько действий в зависимости от выбранного пользователем режима.

import argparse
parser = argparse.ArgumentParser(description='Perform actions in different modes.')
parser.add_argument('--mode', choices=['backup', 'restore', 'delete'], required=True, help='Mode of operation.')
args = parser.parse_args()
if args.mode == 'backup':
    print('Backing up data...')
    # Код резервного копирования здесь
elif args.mode == 'restore':
    print('Restoring data...')
    # Код восстановления здесь
elif args.mode == 'delete':
    print('Deleting data...')
    # Код удаления здесь

В этом скрипте аргумент --mode должен быть одним из вариантов. Если пользователь вводит значение, которого нет в списке, argparse вернет сообщение об ошибке.

Обработка флагов и переключателей

Логические флаги – это выборы, которые включают или отключают определенные функции в вашем приложении. Они обычно определяются без значения, лишь включая флаг в команду. Вы можете обрабатывать эти флаги в argparse с помощью параметра action.

Например, давайте добавим режим отладки в скрипт:

import argparse
parser = argparse.ArgumentParser(description='A script with debug mode.')
parser.add_argument('--debug', action='store_true', help='Enable debug output.')
args = parser.parse_args()
if args.debug:
    print('Debug mode is enabled.')
    # Дополнительная отладочная информация здесь
else:
    print('Debug mode is disabled.')

Используя action='store_true', флаг --debug устанавливает args.debug в True, когда присутствует, и в False в противном случае.

Установка значений по умолчанию и обязательных аргументов

Необязательные аргументы часто имеют разумные значения по умолчанию. Это означает, что если пользователь не укажет аргумент, приложение будет использовать значение по умолчанию. Аргумент default позволяет указать значение по умолчанию.

Вот пример:

import argparse
parser = argparse.ArgumentParser(description='Adjust program settings.')
parser.add_argument('--timeout', type=int, default=30, help='Timeout in seconds.')
args = parser.parse_args()
print(f'Timeout is set to {args.timeout} seconds.')

В этом случае, если пользователь не укажет --timeout, значение по умолчанию составляет 30 секунд.

Чтобы сделать необязательный аргумент обязательным, используйте set required=True.

import argparse
parser = argparse.ArgumentParser(description='Send a message.')
parser.add_argument('--recipient', required=True, help='Recipient of the message.')
args = parser.parse_args()
print(f'Sending message to {args.recipient}.')

Теперь сценарий потребует аргумент --recipient.

Настройка справочных и сообщений об ошибках

Предоставление четких и полезных сообщений пользователям является важной частью разработки эффективной программы командной строки. Модуль argparse в Python автоматически создает справочные сообщения, но вы можете модифицировать их, чтобы они лучше соответствовали вашим потребностям.

Генерация автоматических справочных сообщений

По умолчанию argparse создает справочное сообщение, которое можно получить с помощью опций -h или --help. Это сообщение содержит использование программы, описание и информацию обо всех аргументах.

Например:

import argparse
parser = argparse.ArgumentParser(description='Calculate factorial of a number.')
parser.add_argument('number', type=int, help='The number to calculate the factorial for.')
args = parser.parse_args()

Когда пользователь запускает скрипт с помощью -h, он увидит:

usage: script.py [-h] number
Calculate factorial of a number.
positional arguments:
  number      The number to calculate the factorial for.
optional arguments:
  -h, --help  show this help message and exit

Это автоматическое справочное сообщение предоставляет полезную информацию без необходимости дополнительных усилий.

Настройка описаний справки и сообщений об использовании

Хотя стандартные справочные сообщения полезны, иногда вы можете захотеть изменить их, чтобы предоставить дополнительную информацию или чтобы они лучше соответствовали конкретной структуре. Вы можете изменить описание, эпилог и текст использования в ArgumentParser.

Например, чтобы включить эпилог и настроить сообщение об использовании:

import argparse
parser = argparse.ArgumentParser(
    description='Convert temperatures between Celsius and Fahrenheit.',
    epilog='Enjoy using the temperature converter!',
    usage='%(prog)s [options] temperature')
parser.add_argument('temperature', type=float, help='Temperature value to convert.')
parser.add_argument('--to-fahrenheit', action='store_true', help='Convert Celsius to Fahrenheit.')
parser.add_argument('--to-celsius', action='store_true', help='Convert Fahrenheit to Celsius.')
args = parser.parse_args()

Теперь, когда пользователь проверяет сообщение справки, оно будет содержать настраиваемое описание, использование и эпилог:

python file.py --help

usage: p.py [options] temperature

Convert temperatures between Celsius and Fahrenheit.

positional arguments:
  temperature      Temperature value to convert.

options:
  -h, --help       show this help message and exit
  --to-fahrenheit  Convert Celsius to Fahrenheit.
  --to-celsius     Convert Fahrenheit to Celsius.

–to-fahrenheit Преобразовать Цельсий в Фаренгейт.

–to-celsius Преобразовать Фаренгейт в Цельсий.

Управление обработкой ошибок и обратной связью с пользователем

import argparse
import sys
class CustomArgumentParser(argparse.ArgumentParser):
    def error(self, message):
        print(f'Error: {message}')
        self.print_help()
        sys.exit(2)
parser = CustomArgumentParser(description='Divide two numbers.')
parser.add_argument('numerator', type=float, help='The numerator.')
parser.add_argument('denominator', type=float, help='The denominator.')
args = parser.parse_args()
if args.denominator == 0:
    parser.error('Denominator cannot be zero.')
result = args.numerator / args.denominator
print(f'Result: {result}')

Если пользователь вводит недопустимые аргументы, argparse отобразит сообщение об ошибке и завершит программу. Вы можете изменить это поведение, чтобы предоставить более полезную обратную связь или обрабатывать сбои по-другому.

Python file.py 6 0
Error: Denominator cannot be zero.
usage: file.py [-h] numerator denominator
Divide two numbers.
positional arguments:
  numerator    The numerator.
  denominator  The denominator.
options:
  -h, --help   show this help message and exit

Один из подходов – переопределить метод ошибки в подклассе ArgumentParser:

import argparse
import os
parser = argparse.ArgumentParser(description='Read a file and display its contents.')
parser.add_argument('filepath', help='Path to the file.')
args = parser.parse_args()
if not os.path.exists(args.filepath):
    parser.error(f"The file {args.filepath} does not exist.")
with open(args.filepath, 'r') as file:
    contents = file.read()
    print(contents)

Если пользователь попытается разделить на ноль в этом сценарии, приложение отобразит предупреждение об ошибке и текст помощи, направляя пользователя на предоставление допустимых данных.

python app..py file
usage: p.py [-h] filepath
app.py: error: The file file does not exist.

Вы также можете включить пользовательскую обработку ошибок в свой сценарий. Например, для управления недопустимыми путями к файлам:

Запуск скрипта с неверным путем приведет к отображению нижеуказанной ошибки:

Примеры из реальной жизни и сценарии использования

Понимание того, как использовать модуль argparse в реальных условиях, сделает его функциональность более понятной. Давайте рассмотрим несколько примеров того, как использовать argparse в реальных приложениях.

Создание калькулятора командной строки

import argparse
parser = argparse.ArgumentParser(description='Simple command-line calculator.')
parser.add_argument('num1', type=float, help='First number.')
parser.add_argument('operator', choices=['+', '-', '*', '/'], help='Operation to perform.')
parser.add_argument('num2', type=float, help='Second number.')
args = parser.parse_args()
if args.operator == '+':
    result = args.num1 + args.num2
elif args.operator == '-':
    result = args.num1 - args.num2
elif args.operator == '*':
    result = args.num1 * args.num2
elif args.operator == '/':
    if args.num2 == 0:
        print('Error: Division by zero is not allowed.')
        exit(1)
    result = args.num1 / args.num2
print(f'The result is: {result}')

Предположим, вам нужно разработать простой калькулятор, который может выполнять базовые арифметические операции из командной строки. Этот калькулятор должен принимать два числа и оператор для выполнения запрашиваемого вычисления.

python calculator.py 10 + 5
The result is: 15.0

Вот как подойти к этой задаче:

В этом скрипте модуль argparse используется для определения трех позиционных аргументов: двух чисел и оператора. Аргумент choices ограничивает оператор допустимыми арифметическими символами. Когда пользователь запускает скрипт, он может выполнять эти вычисления:

Этот базовый калькулятор показывает, как параметры командной строки могут повысить гибкость и интерактивность программы.

Создание скрипта обработки файлов с несколькими опциями

import argparse
parser = argparse.ArgumentParser(description='Process text files.')
parser.add_argument('input_file', help='Path to the input file.')
parser.add_argument('-o', '--output', help='Path to the output file.')
parser.add_argument('-m', '--mode', choices=['uppercase', 'lowercase'], default='uppercase', help='Processing mode.')
parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output.')
args = parser.parse_args()
Предположим, вам требуется скрипт, который обрабатывает текстовые файлы и предоставляет такие опции, как назначение выходного файла, выбор режима обработки и включение подробного вывода.
with open(args.input_file, 'r') as file:
    content = file.read()
if args.verbose:
    print(f'Reading from {args.input_file}')
Вот пример того, как вы могли бы это настроить:
if args.mode == 'uppercase':
    processed_content = content.upper()
else:
    processed_content = content.lower()
if args.verbose:
    print('Processing content')
# Чтение входного файла
if args.output:
    with open(args.output, 'w') as file:
        file.write(processed_content)
    if args.verbose:
        print(f'Writing output to {args.output}')
else:
    print(processed_content)

# Обработка содержимого

python text_processor.py input.txt -o output.txt --mode lowercase -v
Reading from input.txt
Processing content
Writing output to output.txt

# Запись в выходной файл или вывод на консоль

Этот скрипт принимает входной файл и имеет опции для выходного файла, режима обработки и подробного вывода. Пользователи могут изменять поведение скрипта, не изменяя код.

Разработка CLI-инструмента с подкомандами

import argparse
parser = argparse.ArgumentParser(description='Manage tasks.')
subparsers = parser.add_subparsers(dest='command', required=True)
В более сложных приложениях могут потребоваться подкоманды, аналогично тому, как это работает в git с использованием команд типа git commit и git push. Модуль argparse предоставляет подпарсеры для этой цели.
parser_add = subparsers.add_parser('add', help='Add a new task.')
parser_add.add_argument('name', help='Name of the task.')
parser_add.add_argument('-p', '--priority', type=int, choices=range(1, 6), default=3, help='Priority of the task.')
Вот как создать CLI-инструмент с подкомандами:
parser_list = subparsers.add_parser('list', help='List all tasks.')
parser_list.add_argument('-a', '--all', action='store_true', help='List all tasks, including completed ones.')
# Подкоманда 'add'
parser_complete = subparsers.add_parser('complete', help='Mark a task as completed.')
parser_complete.add_argument('task_id', type=int, help='ID of the task to complete.')
args = parser.parse_args()
if args.command == 'add':
    print(f"Adding task '{args.name}' with priority {args.priority}")
    # Подкоманда 'list'
elif args.command == 'list':
    print('Listing tasks')
    if args.all:
        print('Including completed tasks')
    # Подкоманда 'complete'
elif args.command == 'complete':
    print(f'Marking task {args.task_id} as completed')
    # Код для добавления задачи

# Код для отображения задач

# Код для завершения задачи

python task_manager.py add "Write report" -p 2
Adding task 'Write report' with priority 2

В этом примере скрипт имеет три подкоманды: add, list и complete. У каждой подкоманды есть свои аргументы. Когда пользователи запускают скрипт, они вводят подкоманду и любые другие параметры.

python task_manager.py list
Listing tasks

Например:

python task_manager.py complete 3
Marking task 3 as completed

Отображение задач

Отметка задач как завершенных:

subparsers позволяют создавать сложные инструменты командной строки, которые хорошо организованы и легко расширяются, позволяя вам создавать приложения, способные выполнять несколько действий в одном интерфейсе. 

Лучшие практики и советы по использованию Python argparse

Разработка консольных программ означает не только написание работающего кода, но и написание кода, который чист, поддерживаем и удобен для пользователя.

Вот некоторые лучшие практики при работе с модулем argparse.

Организация кода для удобства чтения и поддержки

Когда ваши сценарии становятся более сложными, важно держать ваш код организованным для лучшего понимания и обслуживания. Один из подходов для достижения этого – использовать функции и классы для организации отдельных разделов вашего кода.

Разбиение вашей программы на более мелкие, повторно используемые блоки упрощает ее управление и устраняет дублирование кода.

Например, в сценарии управления задачами вы можете определить различные функции для добавления задач, перечисления задач и завершения задач. Это разделение позволяет вам сосредоточиться на одном аспекте логики за раз, делая ваш код более понятным.

Еще одним эффективным приемом является отделение логики обработки аргументов от остальной части вашего кода. Размещение всех определений аргументов и их обработки в начале вашего сценария или в отдельной функции упрощает понимание другими, как ваша программа обрабатывает ввод.

Использование подходящих имен переменных также улучшает читаемость. Выбирайте имена переменных, отражающие их назначение, чтобы любой просматривающий ваш код мог понять, что происходит. Включение комментариев и docstrings для объяснения, что делают ваши функции и любые ключевые детали, может помочь повысить понимание.

Тестирование и отладка приложений с интерфейсом командной строки

Тестирование ваших приложений крайне важно для обеспечения их правильной работы и выявления ошибок на ранних этапах. Написание модульных тестов с использованием тестовых фреймворков Python, таких как unittest или pytest, является отличным подходом к тестированию вашего кода. Эти тесты позволяют имитировать различные входные данные и убедиться, что ваши функции работают правильно.

Например, вы можете тестировать несколько сценариев, подменяя ввод с командной строки, вместо запуска скрипта из командной строки. Эта стратегия позволяет убедиться, что ваш анализ аргументов работает ожидаемым образом и что ваше приложение правильно обрабатывает различные сценарии.

Также важно грамотно обрабатывать исключения. Используя блоки try-except, вы можете перехватывать ошибки и предоставлять полезные сообщения пользователю. Это делает ваше приложение более стабильным и удобным для пользователя.

Также рассмотрите возможность включить флаг отладки в свой скрипт. Этот флаг может включить дополнительный вывод, который позволит вам отслеживать выполнение программы, когда что-то идет не так. Наличие этой опции упрощает диагностику проблем на протяжении всего процесса разработки и поддержки.

Сравнение argparse с другими библиотеками анализа аргументов

Хотя argparse является ценным инструментом в стандартной библиотеке Python, существуют дополнительные библиотеки, которые предоставляют альтернативные методы анализа аргументов командной строки. Понимание этих вариантов поможет вам выбрать подходящий инструмент для вашего проекта.

Одной из таких библиотек является Click. Click – это сторонний пакет для создания интерфейсов командной строки с помощью декораторов. У него более интуитивный синтаксис и он идеально подходит для сложных приложений. Например, вы можете использовать декораторы Python для создания команд и опций, делая ваш код более компактным и понятным.

Docopt – еще один вариант, позволяющий определять интерфейс командной строки с помощью докстринга программы. Docopt автоматически разбирает справку и создает парсер аргументов, когда инструкции использования включены в докстринг. Этот подход элегантен и подходит для простых сценариев, требующих более человекочитаемой спецификации.

При выборе библиотеки для использования обдумайте требования вашего проекта. Если вы хотите избавиться от внешних зависимостей и хотите инструмент, который может справиться с большинством ситуаций, argparse – отличное решение. Если вам нужен более интуитивный синтаксис и вы работаете над сложным приложением, Click может быть более подходящим. Docopt – хороший выбор для небольших программ с простыми интерфейсами.

Заключение

На протяжении этой статьи мы изучали, как использовать модуль argparse в Python для разработки командной строки программ на Python. Работая над реальными примерами, мы узнали, как создавать реалистичные скрипты, которые принимают ввод пользователя и выполняют соответствующие задачи.

Source:
https://www.datacamp.com/tutorial/python-argparse