Аргументы командной строки в Python: создание CLI-интерфейсов

# simple_args.py
import sys

print(f"Имя скрипта: {sys.argv[0]}")
print(f"Аргументы: {sys.argv[1:]}")

if len(sys.argv) > 1:
print(f"Первый аргумент: {sys.argv[1]}")

python simple_args.py hello world

Имя скрипта: simple_args.py
Аргументы: ['hello', 'world']
Первый аргумент: hello

import argparse

parser = argparse.ArgumentParser(description='Демонстрация argparse')

# Позиционный аргумент
parser.add_argument('filename', help='Имя файла для обработки')

# Опциональный аргумент со значением
parser.add_argument('-o', '--output', help='Выходной файл (по умолчанию stdout)')

# Флаг (булево значение)
parser.add_argument('-v', '--verbose', action='store_true', help='Включить подробный вывод')

args = parser.parse_args()

print(f"Входной файл: {args.filename}")
print(f"Выходной файл: {args.output}")
print(f"Подробный режим: {args.verbose}")

usage: script.py [-h] [-o OUTPUT] [-v] filename

Демонстрация argparse

positional arguments:
filename Имя файла для обработки

optional arguments:
-h, --help show this help message and exit
-o OUTPUT, --output OUTPUT
Выходной файл (по умолчанию stdout)
-v, --verbose Включить подробный вывод

import argparse

def process_image(input_file, output_file, resize=None, rotate=0, grayscale=False):
print(f"Обработка {input_file}...")
# Логика обработки изображения

parser = argparse.ArgumentParser(description='Утилита для обработки изображений')

parser.add_argument('input', help='Входное изображение')
parser.add_argument('-o', '--output', help='Выходное изображение (по умолчанию "output_"+input)')
parser.add_argument('-r', '--resize', help='Новый размер в формате WIDTHxHEIGHT')
parser.add_argument('-t', '--rotate', type=int, default=0, help='Угол поворота в градусах')
parser.add_argument('-g', '--grayscale', action='store_true', help='Преобразовать в оттенки серого')

args = parser.parse_args()

# Установка значения по умолчанию для выходного файла
output = args.output if args.output else f"output_{args.input}"

# Вызов функции обработки с полученными аргументами
process_image(args.input, output, args.resize, args.rotate, args.grayscale)

import argparse

# Создаем основной парсер
parser = argparse.ArgumentParser(description='Система управления базой данных')
subparsers = parser.add_subparsers(dest='command', help='Доступные команды')

# Парсер для команды backup
backup_parser = subparsers.add_parser('backup', help='Создать резервную копию')
backup_parser.add_argument('--output', '-o', help='Путь для сохранения')
backup_parser.add_argument('--compress', action='store_true', help='Сжать архив')

# Парсер для команды restore
restore_parser = subparsers.add_parser('restore', help='Восстановить из копии')
restore_parser.add_argument('file', help='Файл резервной копии')
restore_parser.add_argument('--force', '-f', action='store_true', help='Принудительное восстановление')

# Парсер для команды verify
verify_parser = subparsers.add_parser('verify', help='Проверить целостность')
verify_parser.add_argument('file', help='Файл для проверки')

args = parser.parse_args()

# Логика работы в зависимости от команды
if args.command == 'backup':
print(f"Создаю резервную копию {'со сжатием' if args.compress else 'без сжатия'}")
print(f"Сохраняю в: {args.output or 'backup.db'}")
elif args.command == 'restore':
print(f"Восстанавливаю из: {args.file}")
if args.force:
print("Внимание: принудительное восстановление активировано")
elif args.command == 'verify':
print(f"Проверяю целостность файла: {args.file}")
else:
parser.print_help()

parser = argparse.ArgumentParser(description='Пример с исключающими группами')

# Создаем группу взаимоисключающих аргументов
output_group = parser.add_mutually_exclusive_group()
output_group.add_argument('--verbose', action='store_true', help='Подробный вывод')
output_group.add_argument('--quiet', action='store_true', help='Минимальный вывод')

# Еще одна группа
format_group = parser.add_mutually_exclusive_group(required=True)
format_group.add_argument('--json', action='store_true', help='Вывод в формате JSON')
format_group.add_argument('--xml', action='store_true', help='Вывод в формате XML')
format_group.add_argument('--yaml', action='store_true', help='Вывод в формате YAML')

args = parser.parse_args()

def positive_int(value):
ivalue = int(value)
if ivalue <= 0:
raise argparse.ArgumentTypeError(f"{value} не является положительным целым числом")
return ivalue

def file_exists(value):
if not os.path.isfile(value):
raise argparse.ArgumentTypeError(f"Файл {value} не существует")
return value

parser = argparse.ArgumentParser()
parser.add_argument('--count', type=positive_int, help='Положительное целое число')
parser.add_argument('--input', type=file_exists, help='Существующий файл')
args = parser.parse_args()

parser = argparse.ArgumentParser(
description='Продвинутое приложение',
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Примеры использования:
%(prog)s --input data.csv --output result.json
%(prog)s --config config.ini

Дополнительная документация: https://example.com/docs
"""
)

import argparse
import logging
import sys

def configure_logging(level):
levels = {
0: logging.ERROR,
1: logging.WARNING,
2: logging.INFO,
3: logging.DEBUG
}
logging.basicConfig(
level=levels.get(level, logging.DEBUG),
format='%(levelname)s: %(message)s'
)

parser = argparse.ArgumentParser()
parser.add_argument('-v', '--verbose', action='count', default=0,
help='Увеличить подробность вывода (можно указать несколько раз)')

try:
args = parser.parse_args()
configure_logging(args.verbose)

# Основной код программы
logging.info("Программа запущена")
# ...

except Exception as e:
logging.error(f"Ошибка: {e}")
sys.exit(1)

pip install click

import click

@click.command()
@click.option('--count', default=1, help='Количество повторений')
@click.option('--name', prompt='Ваше имя', help='Имя для приветствия')
@click.option('--verbose', is_flag=True, help='Подробный вывод')
def hello(count, name, verbose):
"""Простая программа приветствия."""
if verbose:
click.echo(f"Запуск с параметрами: count={count}, name={name}")

for x in range(count):
click.echo(f"Привет, {name}!")

if __name__ == '__main__':
hello()

import click

@click.group()
def cli():
"""Утилита управления сервером."""
pass

@cli.command()
@click.option('--port', default=8000, help='Порт для запуска')
def start(port):
"""Запустить сервер."""
click.echo(f"Запуск сервера на порту {port}")

@cli.command()
def stop():
"""Остановить сервер."""
click.echo("Останавливаю сервер")

@cli.command()
@click.argument('filename')
def backup(filename):
"""Создать резервную копию."""
click.echo(f"Создаю резервную копию в {filename}")

if __name__ == '__main__':
cli()

pip install docopt

"""Морской бой.

Использование:
naval_fate.py ship create <name>...
naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
naval_fate.py ship shoot <x> <y>
naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
naval_fate.py (-h | --help)
naval_fate.py --version

Опции:
-h --help Показать эту справку.
--version Показать версию.
--speed=<kn> Скорость в узлах [по умолчанию: 10].
--moored Якорная мина.
--drifting Дрейфующая мина.
"""

from docopt import docopt

if __name__ == '__main__':
arguments = docopt(__doc__, version='Naval Fate 2.0')
print(arguments)

import argparse
import sys
from datetime import datetime

def parse_date(date_str):
try:
return datetime.strptime(date_str, '%Y-%m-%d')
except ValueError:
raise argparse.ArgumentTypeError(f"Недопустимый формат даты: {date_str}. Используйте YYYY-MM-DD")

parser = argparse.ArgumentParser(description='Анализатор лог-файлов')
parser.add_argument('file', nargs='?', type=argparse.FileType('r'), default=sys.stdin,
help='Файл логов (по умолчанию stdin)')

# Группа команд
subparsers = parser.add_subparsers(dest='command', required=True, help='Команда')

# Команда filter
filter_parser = subparsers.add_parser('filter', help='Фильтровать записи')
filter_parser.add_argument('--status', type=int, help='Код HTTP-статуса')
filter_parser.add_argument('--method', choices=['GET', 'POST', 'PUT', 'DELETE'], 
help='HTTP-метод')
filter_parser.add_argument('--from-date', type=parse_date, help='Начальная дата (YYYY-MM-DD)')
filter_parser.add_argument('--to-date', type=parse_date, help='Конечная дата (YYYY-MM-DD)')
filter_parser.add_argument('--min-time', type=float, help='Минимальное время ответа (мс)')

# Команда aggregate
agg_parser = subparsers.add_parser('aggregate', help='Агрегировать статистику')
agg_parser.add_argument('--by', choices=['hour', 'day', 'status', 'path', 'ip'], 
required=True, help='Группировка')
agg_parser.add_argument('--sort', choices=['count', 'avg_time', 'max_time'], 
default='count', help='Метрика для сортировки')

# Команда visualize
viz_parser = subparsers.add_parser('visualize', help='Визуализировать данные')
viz_parser.add_argument('--type', choices=['line', 'bar', 'heatmap'], 
required=True, help='Тип графика')
viz_parser.add_argument('--metric', choices=['requests', 'errors', 'response_time'],
required=True, help='Метрика для отображения')
viz_parser.add_argument('--output', help='Файл для сохранения (по умолчанию показывает график)')

args = parser.parse_args()

# Обработка команд
if args.command == 'filter':
print(f"Фильтрация логов по критериям: {args}")
elif args.command == 'aggregate':
print(f"Агрегация данных по {args.by}, сортировка по {args.sort}")
elif args.command == 'visualize':
print(f"Визуализация {args.metric} с использованием {args.type} графика")

import click
import os
import json
from datetime import datetime

# Базовые функции для работы с данными
def load_tasks():
if not os.path.exists('tasks.json'):
return []
with open('tasks.json', 'r') as f:
return json.load(f)

def save_tasks(tasks):
with open('tasks.json', 'w') as f:
json.dump(tasks, f, indent=2)

@click.group()
def cli():
"""Система управления задачами проекта."""
pass

@cli.command()
@click.argument('title')
@click.option('--description', '-d', help='Описание задачи')
@click.option('--priority', '-p', type=click.Choice(['low', 'medium', 'high']), 
default='medium', help='Приоритет задачи')
@click.option('--assignee', '-a', help='Исполнитель задачи')
def add(title, description, priority, assignee):
"""Добавить новую задачу."""
tasks = load_tasks()
task = {
'id': len(tasks) + 1,
'title': title,
'description': description,
'priority': priority,
'assignee': assignee,
'status': 'todo',
'created_at': datetime.now().isoformat()
}
tasks.append(task)
save_tasks(tasks)
click.echo(f"Задача #{task['id']} добавлена: {title}")

@cli.command()
@click.argument('task_id', type=int)
@click.argument('status', type=click.Choice(['todo', 'in_progress', 'review', 'done']))
def status(task_id, status):
"""Изменить статус задачи."""
tasks = load_tasks()
for task in tasks:
if task['id'] == task_id:
old_status = task['status']
task['status'] = status
save_tasks(tasks)
click.echo(f"Статус задачи #{task_id} изменен: {old_status} -> {status}")
return
click.echo(f"Задача #{task_id} не найдена", err=True)

@cli.command()
@click.option('--all', '-a', 'show_all', is_flag=True, help='Показать все задачи')
@click.option('--status', '-s', type=click.Choice(['todo', 'in_progress', 'review', 'done']), 
help='Фильтр по статусу')
@click.option('--assignee', help='Фильтр по исполнителю')
@click.option('--format', '-f', type=click.Choice(['table', 'json']), default='table',
help='Формат вывода')
def list(show_all, status, assignee, format):
"""Показать список задач."""
tasks = load_tasks()

# Применение фильтров
if not show_all:
if status:
tasks = [t for t in tasks if t['status'] == status]
if assignee:
tasks = [t for t in tasks if t.get('assignee') == assignee]

if not tasks:
click.echo("Задачи не найдены")
return

if format == 'json':
click.echo(json.dumps(tasks, indent=2))
else:
# Вывод в табличном формате
click.echo(f"{'ID':<4} {'ПРИОРИТЕТ':<10} {'СТАТУС':<12} {'ИСПОЛНИТЕЛЬ':<15} {'НАЗВАНИЕ'}")
click.echo("-" * 80)
for task in tasks:
click.echo(
f"{task['id']:<4} {task['priority']:<10} {task['status']:<12} "
f"{(task.get('assignee') or 'Не назначен'):<15} {task['title']}"
)

if __name__ == '__main__':
cli()

import click

@click.group()
def cli():
"""Утилита с автодополнением."""
pass

# Генерация скрипта завершения
# $ _MY_TOOL_COMPLETE=source_bash my_tool > my_tool-complete.sh
# $ source my_tool-complete.sh

if __name__ == '__main__':
cli()

import click

@click.command()
@click.option('--name', prompt=True, help='Имя пользователя')
@click.password_option()
@click.confirmation_option(prompt='Вы уверены, что хотите продолжить?')
@click.option('--type', type=click.Choice(['user', 'admin']), 
prompt='Выберите тип пользователя')
def create_user(name, password, type):
"""Создать нового пользователя."""
click.echo(f"Создание {type} пользователя: {name}")
# Логика создания пользователя

import click

@click.command()
def status():
"""Показать статус системы."""
# Использование цветов
click.echo(click.style("● ", fg="green") + "База данных: Доступна")
click.echo(click.style("● ", fg="red") + "Кэш: Недоступен")
click.echo(click.style("● ", fg="yellow") + "API: Высокая нагрузка")

# Таблицы
headers = ["Сервис", "Статус", "Время отклика"]
rows = [
["Web", "OK", "42ms"],
["Database", "OK", "123ms"],
["Cache", "ERROR", "N/A"]
]

# Вывод таблицы
click.echo()
click.echo(" | ".join(headers))
click.echo("-" * 40)
for row in rows:
status_color = "green" if row[1] == "OK" else "red"
formatted_row = [
row[0],
click.style(row[1], fg=status_color),
row[2]
]
click.echo(" | ".join(formatted_row))

import click
import time

@click.command()
@click.option('--count', default=100, help='Количество итераций')
def process(count):
"""Демонстрация индикатора прогресса."""
with click.progressbar(range(count), label='Обработка данных') as bar:
for i in bar:
# Имитация работы
time.sleep(0.05)
click.echo('Готово!')

@click.command()
def backup():
"""Демонстрация спиннера."""
with click.spinner(text='Создание резервной копии...') as spinner:
for _ in range(50):
time.sleep(0.1)
spinner.update()
click.echo('Резервная копия создана!')