Как запускать функции Python из командной строки: полное руководство

def say_hello(name):
return f"Hello, {name}!"

# Код верхнего уровня
print(say_hello("World"))

def analyze_data(filename, threshold=0.5):
# Логика анализа данных
return results

def format_output(results, format_type="text"):
# Форматирование результатов
return formatted_data

def main():
# Координация выполнения программы
filename = "data.csv"
results = analyze_data(filename)
output = format_output(results)
print(output)

if __name__ == "__main__":
main()

#!/usr/bin/env python3
# Остальной код скрипта

chmod +x script.py
./script.py

import logging

logging.basicConfig(
level=logging.INFO,
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s',
filename='script.log'
)

def main():
logging.info("Script started")
try:
# Основная логика
logging.info("Processing completed successfully")
except Exception as e:
logging.error(f"Error occurred: {e}")
return 1
return 0

if __name__ == "__main__":
exit_code = main()
exit(exit_code)

import sys

def calculate(a, b, operation):
if operation == 'add':
return a + b
elif operation == 'subtract':
return a – b
elif operation == 'multiply':
return a * b
elif operation == 'divide':
if b == 0:
return "Error: Division by zero"
return a / b
else:
return "Unknown operation"

if __name__ == "__main__":
# Проверяем, достаточно ли аргументов
if len(sys.argv) != 4:
print("Usage: python calculator.py <number1> <number2> <operation>")
print("Operations: add, subtract, multiply, divide")
sys.exit(1)

# Получаем аргументы
try:
num1 = float(sys.argv[1])
num2 = float(sys.argv[2])
except ValueError:
print("Error: Arguments must be numbers")
sys.exit(1)

operation = sys.argv[3]

# Вызываем функцию и выводим результат
result = calculate(num1, num2, operation)
print(f"Result: {result}")

python calculator.py 10 5 multiply

Result: 50.0

import sys

def process_data(input_file, output_file=None, verbose=False, threshold=0.5):
# Обработка данных
if verbose:
print(f"Processing {input_file} with threshold {threshold}")
# ...
return "Data processed"

if __name__ == "__main__":
# Инициализация значений по умолчанию
output_file = None
verbose = False
threshold = 0.5

# Ручной парсинг аргументов
i = 1
while i < len(sys.argv):
if sys.argv[i] == "--output" or sys.argv[i] == "-o":
if i + 1 < len(sys.argv):
output_file = sys.argv[i+1]
i += 2
else:
print("Error: --output requires a file path")
sys.exit(1)
elif sys.argv[i] == "--verbose" or sys.argv[i] == "-v":
verbose = True
i += 1
elif sys.argv[i] == "--threshold" or sys.argv[i] == "-t":
if i + 1 < len(sys.argv):
try:
threshold = float(sys.argv[i+1])
i += 2
except ValueError:
print("Error: threshold must be a number")
sys.exit(1)
else:
print("Error: --threshold requires a value")
sys.exit(1)
elif i == 1: # Первый позиционный аргумент – входной файл
input_file = sys.argv[i]
i += 1
else:
print(f"Unknown argument: {sys.argv[i]}")
sys.exit(1)

# Проверка наличия обязательного аргумента
if 'input_file' not in locals():
print("Error: input file is required")
print("Usage: python script.py <input_file> [options]")
print("Options:")
print(" --output, -o <file> Output file path")
print(" --verbose, -v Enable verbose mode")
print(" --threshold, -t <float> Set processing threshold (default: 0.5)")
sys.exit(1)

result = process_data(input_file, output_file, verbose, threshold)
print(result)

import argparse

def main():
# Создаем парсер аргументов
parser = argparse.ArgumentParser(description='Description of your program')

# Добавляем аргументы
parser.add_argument('positional_arg', help='Description of positional argument')
parser.add_argument('--optional', '-o', help='Description of optional argument')

# Парсим аргументы
args = parser.parse_args()

# Используем аргументы
print(f"Positional arg: {args.positional_arg}")
if args.optional:
print(f"Optional arg: {args.optional}")

if __name__ == "__main__":
main()

import argparse

def process_image(input_file, output_file=None, resize=None, rotate=0, 
grayscale=False, quality=85, format=None, verbose=False):
"""
Обрабатывает изображение согласно заданным параметрам.

Args:
input_file (str): Путь к входному файлу
output_file (str, optional): Путь к выходному файлу
resize (tuple, optional): Новый размер (ширина, высота)
rotate (int, optional): Угол поворота в градусах
grayscale (bool, optional): Преобразовать в оттенки серого
quality (int, optional): Качество сжатия (1-100)
format (str, optional): Формат выходного файла (jpg, png, etc.)
verbose (bool, optional): Подробный вывод

Returns:
str: Путь к обработанному изображению
"""
if verbose:
print(f"Processing {input_file}...")
if resize:
print(f"Resizing to {resize[0]}x{resize[1]}")
if rotate:
print(f"Rotating by {rotate} degrees")
if grayscale:
print("Converting to grayscale")

# Здесь была бы реальная обработка изображения
# с использованием библиотеки типа Pillow

result = output_file or f"processed_{input_file}"
if verbose:
print(f"Image saved as {result}")
return result

def parse_size(size_str):
"""Преобразует строку вида '800x600' в кортеж (800, 600)"""
try:
width, height = map(int, size_str.split('x'))
return (width, height)
except ValueError:
raise argparse.ArgumentTypeError(
f"Size must be in format WIDTHxHEIGHT, got {size_str}"
)

def main():
# Создаем парсер с описанием программы
parser = argparse.ArgumentParser(
description='Image processing utility',
epilog='Example: python img_processor.py input.jpg -o output.png -r 800x600 --grayscale'
)

# Добавляем аргументы
parser.add_argument('input', help='Input image file')

parser.add_argument('-o', '--output', 
help='Output image file')

parser.add_argument('-r', '--resize', 
type=parse_size,
help='Resize image (format: WIDTHxHEIGHT, e.g. 800x600)')

parser.add_argument('--rotate', 
type=int, default=0,
help='Rotate image by degrees')

parser.add_argument('--grayscale', 
action='store_true',
help='Convert image to grayscale')

parser.add_argument('-q', '--quality', 
type=int, default=85,
choices=range(1, 101),
metavar="[1-100]",
help='JPEG quality (1-100)')

parser.add_argument('-f', '--format', 
choices=['jpg', 'png', 'gif', 'bmp', 'tiff'],
help='Output format')

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

# Парсим аргументы
args = parser.parse_args()

# Вызываем функцию обработки изображения
result = process_image(
args.input, 
args.output, 
args.resize, 
args.rotate, 
args.grayscale, 
args.quality, 
args.format, 
args.verbose
)

print(f"Done! Result: {result}")

if __name__ == "__main__":
main()

# Базовое использование
python img_processor.py image.jpg

# С дополнительными параметрами
python img_processor.py image.jpg -o result.png -r 1920x1080 --rotate 90 --grayscale -v

# Показать справку
python img_processor.py --help

import argparse
import csv
import sys
from datetime import datetime

def analyze_sales(filename, date_from=None, date_to=None, min_amount=0, 
category=None, output=None):
"""Анализирует данные о продажах из CSV-файла"""

# Преобразование строковых дат в объекты datetime
if date_from:
date_from = datetime.strptime(date_from, '%Y-%m-%d')
if date_to:
date_to = datetime.strptime(date_to, '%Y-%m-%d')

results = {
'total_sales': 0,
'total_amount': 0,
'avg_amount': 0,
'by_category': {}
}

with open(filename, 'r') as csvfile:
reader = csv.DictReader(csvfile)
sales_count = 0

for row in reader:
# Применяем фильтры
sale_date = datetime.strptime(row['date'], '%Y-%m-%d')
sale_amount = float(row['amount'])
sale_category = row['category']

if date_from and sale_date < date_from:
continue
if date_to and sale_date > date_to:
continue
if sale_amount < min_amount:
continue
if category and sale_category != category:
continue

# Обновляем статистику
results['total_sales'] += 1
results['total_amount'] += sale_amount

if sale_category in results['by_category']:
results['by_category'][sale_category]['count'] += 1
results['by_category'][sale_category]['total'] += sale_amount
else:
results['by_category'][sale_category] = {
'count': 1,
'total': sale_amount
}

sales_count += 1

# Вычисляем средний чек
if sales_count > 0:
results['avg_amount'] = results['total_amount'] / sales_count

# Добавляем средний чек по категориям
for category in results['by_category']:
cat_data = results['by_category'][category]
cat_data['avg'] = cat_data['total'] / cat_data['count']

# Выводим результаты
if output:
with open(output, 'w') as outfile:
outfile.write(f"Sales Analysis Report\n")
outfile.write(f"Total sales: {results['total_sales']}\n")
outfile.write(f"Total amount: ${results['total_amount']:.2f}\n")
outfile.write(f"Average sale: ${results['avg_amount']:.2f}\n\n")

outfile.write("By Category:\n")
for cat, data in results['by_category'].items():
outfile.write(f"{cat}:\n")
outfile.write(f" Sales: {data['count']}\n")
outfile.write(f" Total: ${data['total']:.2f}\n")
outfile.write(f" Average: ${data['avg']:.2f}\n")
else:
print(f"Total sales: {results['total_sales']}")
print(f"Total amount: ${results['total_amount']:.2f}")
print(f"Average sale: ${results['avg_amount']:.2f}")

print("\nBy Category:")
for cat, data in results['by_category'].items():
print(f"{cat}:")
print(f" Sales: {data['count']}")
print(f" Total: ${data['total']:.2f}")
print(f" Average: ${data['avg']:.2f}")

return results

def main():
parser = argparse.ArgumentParser(description='Sales data analyzer')
parser.add_argument('filename', help='CSV file with sales data')
parser.add_argument('--from', dest='date_from', 
help='Start date (YYYY-MM-DD)')
parser.add_argument('--to', dest='date_to', 
help='End date (YYYY-MM-DD)')
parser.add_argument('--min', type=float, default=0,
help='Minimum sale amount to include')
parser.add_argument('--category', 
help='Filter by specific category')
parser.add_argument('--output', '-o',
help='Output file for the report')

args = parser.parse_args()

try:
analyze_sales(args.filename, args.date_from, args.date_to,
args.min, args.category, args.output)
except FileNotFoundError:
print(f"Error: File {args.filename} not found")
return 1
except Exception as e:
print(f"Error: {e}")
return 1

return 0

if __name__ == "__main__":
sys.exit(main())

# Базовый анализ всех продаж
python sales_analyzer.py sales_data.csv

# Анализ продаж за определенный период
python sales_analyzer.py sales_data.csv --from 2023-01-01 --to 2023-03-31

# Анализ продаж с минимальной суммой и фильтрацией по категории
python sales_analyzer.py sales_data.csv --min 100 --category Electronics

# Сохранение результата в файл
python sales_analyzer.py sales_data.csv --output sales_report.txt

import argparse
import os
import subprocess
import sys

def format_code(files, check_only=False, fix_imports=False, verbose=False):
"""
Форматирует Python-код с использованием black и isort.

Args:
files: Список файлов или директорий для форматирования
check_only: Только проверка без внесения изменений
fix_imports: Сортировка импортов с помощью isort
verbose: Подробный вывод

Returns:
bool: True если все проверки прошли успешно, иначе False
"""
success = True

# Команда для black
black_args = ['black']
if check_only:
black_args.append('--check')
if verbose:
black_args.append('--verbose')
black_args.extend(files)

# Запускаем black
if verbose:
print(f"Running black with args: {' '.join(black_args)}")

black_result = subprocess.run(black_args, capture_output=not verbose)
if black_result.returncode != 0:
success = False
if not verbose:
print("Black found formatting issues:")
print(black_result.stdout.decode())
print(black_result.stderr.decode())

# Запускаем isort если требуется
if fix_imports:
isort_args = ['isort']
if check_only:
isort_args.append('--check')
if verbose:
isort_args.append('--verbose')
isort_args.extend(files)

if verbose:
print(f"Running isort with args: {' '.join(isort_args)}")

isort_result = subprocess.run(isort_args, capture_output=not verbose)
if isort_result.returncode != 0:
success = False
if not verbose:
print("isort found import ordering issues:")
print(isort_result.stdout.decode())
print(isort_result.stderr.decode())

return success

def main():
parser = argparse.ArgumentParser(description='Python code formatter')
parser.add_argument('files', nargs='+', help='Files or directories to format')
parser.add_argument('--check', action='store_true', 
help='Check only without modifying files')
parser.add_argument('--fix-imports', action='store_true',
help='Also sort imports using isort')
parser.add_argument('-v', '--verbose', action='store_true',
help='Verbose output')

args = parser.parse_args()

try:
success = format_code(args.files, args.check, args.fix_imports, args.verbose)
return 0 if success else 1
except Exception as e:
print(f"Error: {e}")
return 1

if __name__ == "__main__":
sys.exit(main())