Ввод данных в Python: проверка, защита и обработка ошибок

name = input("Введите ваше имя: ")
print(f"Привет, {name}!")

# Неправильно
age = input("Введите ваш возраст: ")
years_to_retirement = 65 – age # TypeError: unsupported operand type(s)

# Правильно
age = int(input("Введите ваш возраст: "))
years_to_retirement = 65 – age

try:
age = int(input("Введите ваш возраст: "))
years_to_retirement = 65 – age
print(f"До пенсии вам осталось {years_to_retirement} лет")
except ValueError:
print("Пожалуйста, введите корректное число")

# Преобразование в целое число
def get_integer_input(prompt):
while True:
try:
value = int(input(prompt))
return value
except ValueError:
print("Ошибка! Введите целое число.")

# Преобразование в число с плавающей точкой
def get_float_input(prompt):
while True:
try:
value = float(input(prompt))
return value
except ValueError:
print("Ошибка! Введите число.")

# Пример использования
age = get_integer_input("Введите ваш возраст: ")
height = get_float_input("Введите ваш рост в метрах: ")

def get_boolean_input(prompt):
while True:
value = input(prompt).lower().strip()
if value in ('да', 'yes', 'y', 'true', 't', '1'):
return True
elif value in ('нет', 'no', 'n', 'false', 'f', '0'):
return False
else:
print("Пожалуйста, введите 'да' или 'нет'.")

is_student = get_boolean_input("Вы студент? (да/нет): ")

from datetime import datetime

def get_date_input(prompt, format_str="%Y-%m-%d"):
while True:
date_str = input(prompt)
try:
return datetime.strptime(date_str, format_str)
except ValueError:
print(f"Ошибка! Используйте формат {format_str}")

birthday = get_date_input("Введите дату рождения (ГГГГ-ММ-ДД): ")
print(f"Вам {(datetime.now() – birthday).days // 365} лет")

# Ввод списка чисел
def get_number_list(prompt):
while True:
try:
input_str = input(prompt)
return [float(x.strip()) for x in input_str.split(',')]
except ValueError:
print("Ошибка! Введите числа, разделенные запятыми.")

grades = get_number_list("Введите ваши оценки через запятую: ")
print(f"Средний балл: {sum(grades) / len(grades)}")

import json

def get_json_input(prompt):
while True:
try:
input_str = input(prompt)
return json.loads(input_str)
except json.JSONDecodeError:
print("Ошибка! Введите корректный JSON.")

user_data = get_json_input("Введите данные пользователя в формате JSON: ")

import argparse

def calculate_area(length, width):
return length * width

parser = argparse.ArgumentParser(description='Вычисляет площадь прямоугольника.')
parser.add_argument('length', type=float, help='Длина прямоугольника')
parser.add_argument('width', type=float, help='Ширина прямоугольника')
parser.add_argument('--unit', type=str, default='м²', help='Единица измерения (по умолчанию: м²)')
parser.add_argument('--verbose', '-v', action='store_true', help='Подробный вывод')

args = parser.parse_args()
area = calculate_area(args.length, args.width)

if args.verbose:
print(f"Площадь прямоугольника с длиной {args.length} и шириной {args.width} равна {area} {args.unit}")
else:
print(f"Площадь: {area} {args.unit}")

python rectangle.py 5 3 --unit см² --verbose

import sys

# Чтение из stdin
for line in sys.stdin:
# Удаляем символ новой строки и обрабатываем данные
processed_line = line.strip().upper()
# Запись в stdout
sys.stdout.write(processed_line + '\n')
# Запись ошибок или информационных сообщений в stderr
sys.stderr.write(f"Обработана строка длиной {len(line)} символов\n")

cat file.txt | python process.py | grep "KEYWORD"

import readline

# Настройка автодополнения
def completer(text, state):
options = [i for i in ["help", "exit", "search", "download"] if i.startswith(text)]
if state < len(options):
return options[state]
else:
return None

readline.parse_and_bind("tab: complete")
readline.set_completer(completer)

# История команд
readline.read_history_file('.command_history')

while True:
try:
command = input("cli> ")
readline.write_history_file('.command_history')

if command.lower() == 'exit':
break
# Обработка команды
except KeyboardInterrupt:
print("\nПрограмма прервана пользователем")
break

import asyncio

async def get_user_input():
loop = asyncio.get_event_loop()
return await loop.run_in_executor(None, input, "Введите команду: ")

async def main():
print("Запуск программы...")

# Задача для обработки пользовательского ввода
input_task = asyncio.create_task(get_user_input())

# Другая асинхронная задача, которая не блокирует ввод
timer_task = asyncio.create_task(countdown(5))

# Ожидаем завершения ввода или таймера
done, pending = await asyncio.wait(
[input_task, timer_task],
return_when=asyncio.FIRST_COMPLETED
)

# Отменяем оставшиеся задачи
for task in pending:
task.cancel()

if input_task in done:
user_input = input_task.result()
print(f"Вы ввели: {user_input}")
else:
print("\nВремя истекло")

async def countdown(seconds):
for i in range(seconds, 0, -1):
print(f"\rОсталось {i} сек...", end="")
await asyncio.sleep(1)
return "Время истекло"

if __name__ == "__main__":
asyncio.run(main())

def process_input_file(filename):
try:
with open(filename, 'r', encoding='utf-8') as file:
for line_number, line in enumerate(file, 1):
try:
# Обработка строки
data = line.strip().split(',')
if len(data) < 2:
print(f"Предупреждение: строка {line_number} имеет неверный формат")
continue

name, age = data[0], int(data[1])
print(f"Обработка: {name}, {age} лет")
except Exception as e:
print(f"Ошибка в строке {line_number}: {e}")
except FileNotFoundError:
print(f"Файл {filename} не найден")
except PermissionError:
print(f"Нет доступа к файлу {filename}")

# Использование
process_input_file('users.csv')

import re

def validate_email(email):
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
if re.match(pattern, email):
return True
return False

def validate_password(password):
# Минимум 8 символов, хотя бы одна буква и одна цифра
pattern = r'^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$'
if re.match(pattern, password):
return True
return False

# Пример использования
email = input("Введите email: ")
if validate_email(email):
print("Email корректен")
else:
print("Неверный формат email")

class Validator:
def __init__(self):
self.errors = []

def validate_age(self, age_str):
try:
age = int(age_str)
if age < 0 or age > 120:
self.errors.append("Возраст должен быть от 0 до 120 лет")
return False
return True
except ValueError:
self.errors.append("Возраст должен быть целым числом")
return False

def validate_name(self, name):
if not name:
self.errors.append("Имя не может быть пустым")
return False
if len(name) < 2:
self.errors.append("Имя должно содержать минимум 2 символа")
return False
if not all(c.isalpha() or c.isspace() for c in name):
self.errors.append("Имя должно содержать только буквы и пробелы")
return False
return True

def get_errors(self):
return self.errors

# Использование
validator = Validator()
name = input("Введите ваше имя: ")
age = input("Введите ваш возраст: ")

name_valid = validator.validate_name(name)
age_valid = validator.validate_age(age)

if name_valid and age_valid:
print("Все данные корректны")
else:
print("Ошибки валидации:")
for error in validator.get_errors():
print(f"- {error}")

import sqlite3
import shlex
import subprocess

# Защита от SQL-инъекций
def safe_db_query(username):
conn = sqlite3.connect('users.db')
cursor = conn.cursor()

# Неправильно (уязвимо к SQL-инъекциям):
# cursor.execute(f"SELECT * FROM users WHERE username = '{username}'")

# Правильно (параметризованный запрос):
cursor.execute("SELECT * FROM users WHERE username = ?", (username,))

result = cursor.fetchall()
conn.close()
return result

# Защита от инъекций в командную строку
def safe_command_execution(filename):
# Неправильно (уязвимо к инъекциям):
# os.system(f"cat {filename}")

# Правильно (безопасное выполнение):
try:
result = subprocess.run(["cat", filename], capture_output=True, text=True, check=True)
return result.stdout
except subprocess.CalledProcessError as e:
return f"Ошибка выполнения команды: {e}"

from flask import Flask, request, jsonify
from marshmallow import Schema, fields, validate, ValidationError

app = Flask(__name__)

class UserSchema(Schema):
username = fields.Str(required=True, validate=[
validate.Length(min=3, max=50),
validate.Regexp('^[a-zA-Z0-9_]+$', error='Имя пользователя должно содержать только буквы, цифры и символ подчеркивания')
])
email = fields.Email(required=True)
age = fields.Integer(validate=validate.Range(min=18, max=100))

user_schema = UserSchema()

@app.route('/register', methods=['POST'])
def register():
try:
# Валидация входных данных
data = user_schema.load(request.json)

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

return jsonify({"message": "Пользователь зарегистрирован успешно"}), 201
except ValidationError as err:
return jsonify({"errors": err.messages}), 400

if __name__ == '__main__':
app.run(debug=True)

def display_menu():
menu_options = {
1: "Просмотр всех записей",
2: "Добавить запись",
3: "Изменить запись",
4: "Удалить запись",
5: "Выход"
}

print("\n" + "="*30)
print("ГЛАВНОЕ МЕНЮ".center(30))
print("="*30)

for key, value in menu_options.items():
print(f"{key}. {value}")

print("="*30)

def get_menu_choice(max_option):
while True:
display_menu()
try:
choice = int(input("\nВыберите действие: "))
if 1 <= choice <= max_option:
return choice
else:
print(f"Пожалуйста, выберите опцию от 1 до {max_option}")
except ValueError:
print("Введите число!")

# Использование
def main():
while True:
choice = get_menu_choice(5)

if choice == 1:
print("Выполняется: Просмотр всех записей")
# Код для просмотра записей
elif choice == 2:
print("Выполняется: Добавление записи")
# Код для добавления записи
elif choice == 3:
print("Выполняется: Изменение записи")
# Код для изменения записи
elif choice == 4:
print("Выполняется: Удаление записи")
# Код для удаления записи
elif choice == 5:
print("Выход из программы...")
break

if __name__ == "__main__":
main()

import threading
import time

def input_with_timeout(prompt, timeout):
result = {"value": None, "timedout": False}

def get_input():
result["value"] = input(prompt)

# Создаем поток для ввода
thread = threading.Thread(target=get_input)
thread.daemon = True
thread.start()

# Ждем определенное время или до завершения ввода
thread.join(timeout)

if thread.is_alive():
# Ввод не завершен, помечаем как timeout
result["timedout"] = True
# Возвращаем курсор на новую строку для следующего вывода
print()
# Поток daemon завершится при выходе из функции

return result

# Пример использования
result = input_with_timeout("У вас есть 5 секунд на ввод ответа: ", 5)

if result["timedout"]:
print("Время вышло!")
else:
print(f"Ваш ответ: {result['value']}")

def create_user_profile():
# Словарь для хранения данных пользователя
user = {}

# Функции валидации
def validate_name(name):
return bool(name) and all(c.isalpha() or c.isspace() for c in name)

def validate_email(email):
import re
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
return bool(re.match(pattern, email))

def validate_age(age):
try:
age = int(age)
return 18 <= age <= 120
except ValueError:
return False

# Пошаговый ввод с валидацией
steps = [
{
"field": "name",
"prompt": "Введите ваше имя: ",
"validate": validate_name,
"error": "Имя должно содержать только буквы и пробелы"
},
{
"field": "email",
"prompt": "Введите ваш email: ",
"validate": validate_email,
"error": "Неверный формат email"
},
{
"field": "age",
"prompt": "Введите ваш возраст: ",
"validate": validate_age,
"error": "Возраст должен быть числом от 18 до 120"
}
]

# Проходим по каждому шагу
for step in steps:
while True:
value = input(step["prompt"])
if step["validate"](value):
# Если для поля age прошла валидация строки, преобразуем в число
if step["field"] == "age":
user[step["field"]] = int(value)
else:
user[step["field"]] = value
break
else:
print(step["error"])

# Подтверждение введенных данных
print("\nПроверьте введенные данные:")
for field, value in user.items():
print(f"{field.capitalize()}: {value}")

confirm = input("\nВсё верно? (да/нет): ").lower()
if confirm in ['да', 'yes', 'y']:
print("Профиль создан!")
return user
else:
print("Профиль не создан. Попробуйте снова.")
return None

# Использование
user_profile = create_user_profile()
if user_profile:
# Дальнейшая обработка данных пользователя
pass

import readline

# Список возможных команд
COMMANDS = ['help', 'status', 'start', 'stop', 'restart', 'config', 'exit']

def completer(text, state):
"""Функция автодополнения для readline"""
options = [cmd для cmd в COMMANDS, если cmd.startswith(text)]
если state < len(options):
return options[state]
else:
return None

# Настройка readline
readline.parse_and_bind("tab: complete")
readline.set_completer(completer)

def interactive_shell():
"""Простая интерактивная оболочка с автодополнением"""
print("Введите команду (используйте Tab для автодополнения):")
print("Доступные команды:", ", ".join(COMMANDS))

while True:
try:
command = input("$ ").strip()

if not command:
continue
elif command == 'exit':
print("Выход из программы...")
break
elif command == 'help':
print("Справка:")
for cmd in COMMANDS:
print(f" {cmd}")
elif command in COMMANDS:
print(f"Выполняется команда: {command}")
else:
print(f"Неизвестная команда: {command}")
except KeyboardInterrupt:
print("\nПрограмма прервана. Введите 'exit' для выхода.")
except EOFError:
print("\nВыход из программы...")
break

# Запуск интерактивной оболочки
interactive_shell()

import getpass
import hashlib

def login():
username = input("Имя пользователя: ")

# Ввод пароля без отображения на экране
password = getpass.getpass("Пароль: ")

# Хеширование пароля (в реальном приложении следует использовать более безопасные методы)
hashed_password = hashlib.sha256(password.encode()).hexdigest()

# Проверка учетных данных (пример)
if authenticate(username, hashed_password):
print("Вход выполнен успешно!")
return True
else:
print("Неверное имя пользователя или пароль")
return False

def authenticate(username, hashed_password):
# Здесь должна быть реальная проверка по базе данных
# Это просто пример
stored_credentials = {
"admin": "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918" # admin
}

return username in stored_credentials and stored_credentials[username] == hashed_password

# Использование
login()

import os

def select_file(directory='.', extension=None):
"""Позволяет пользователю выбрать файл из указанной директории"""
try:
# Получаем список файлов
files = os.listdir(directory)

# Фильтруем по расширению, если указано
if extension:
files = [f для f в files, если f.endswith(extension)]

if not files:
print(f"В директории {directory} нет" + 
(f" файлов с расширением {extension}" если extension иначе " файлов"))
return None

# Выводим список файлов
print(f"\nДоступные файлы в {directory}:")
for i, file in enumerate(files, 1):
print(f"{i}. {file}")

# Пользователь выбирает файл
while True:
try:
choice = int(input("\nВыберите номер файла (или 0 для отмены): "))
if choice == 0:
return None
if 1 <= choice <= len(files):
selected_file = os.path.join(directory, files[choice-1])
print(f"Выбран файл: {selected_file}")
return selected_file
else:
print(f"Пожалуйста, выберите номер от 1 до {len(files)} или 0")
except ValueError:
print("Введите число!")
except Exception as e:
print(f"Ошибка при работе с директорией: {e}")
return None

# Пример использования
filename = select_file('.', '.txt')
if filename:
with open(filename, 'r') as file:
content = file.read()
print(f"\nСодержимое файла:\n{content}")