Основы алгоритмизации: первые шаги в Python

Расширенные примеры базового программирования на Python

1. Работа с датой и временем

from datetime import datetime, timedelta

now = datetime.now()
print('Текущая дата и время:', now)

# Добавить 7 дней
future = now + timedelta(days=7)
print('Через неделю:', future.strftime('%Y-%m-%d %H:%M'))

# Разница между датами
delta = future - now
print('Разница в секундах:', delta.total_seconds())

Текущая дата и время: 2025-01-15 10:30:45.123456
Через неделю: 2025-01-22 10:30
Разница в секундах: 604800.0

Пояснение: Модуль datetime предоставляет классы для работы с датами и временем. timedelta позволяет выполнять арифметику дат. Метод strftime форматирует дату в строку.

2. Чтение и запись файлов

# Запись в файл
with open('example.txt', 'w', encoding='utf-8') as f:
    f.write('Первая строка\nВторая строка')

# Чтение из файла
with open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print('Содержимое файла:')
    print(content)

Содержимое файла:
Первая строка
Вторая строка

Пояснение: Конструкция with автоматически закрывает файл после использования. Режимы: 'w' - перезапись, 'r' - чтение, 'a' - добавление. Указание encoding='utf-8' обязательно для корректной работы с кириллицей.

3. Обработка исключений

def safe_divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print('Ошибка: деление на ноль')
        return None
    except TypeError:
        print('Ошибка: аргументы должны быть числами')
        return None
    else:
        print('Деление выполнено успешно')
        return result
    finally:
        print('Блок finally выполняется всегда')

print(safe_divide(10, 2))
print(safe_divide(10, 0))
print(safe_divide(10, 'a'))

Деление выполнено успешно
Блок finally выполняется всегда
5.0
Ошибка: деление на ноль
Блок finally выполняется всегда
None
Ошибка: аргументы должны быть числами
Блок finally выполняется всегда
None

Пояснение: try-except перехватывает исключения. else выполняется, если исключений не было. finally - всегда, используется для очистки ресурсов (например, закрытие файла).

4. Сортировка списка по ключу (с использованием lambda)

students = [
    {'name': 'Иван', 'grade': 85},
    {'name': 'Мария', 'grade': 92},
    {'name': 'Пётр', 'grade': 78}
]

# Сортировка по оценке по возрастанию
sorted_students = sorted(students, key=lambda s: s['grade'])
print('Сортировка по оценке:')
for student in sorted_students:
    print(f"{student['name']}: {student['grade']}")

# Обратная сортировка
sorted_students_desc = sorted(students, key=lambda s: s['grade'], reverse=True)
print('\nОбратная сортировка:')
for student in sorted_students_desc:
    print(f"{student['name']}: {student['grade']}")

Сортировка по оценке:
Пётр: 78
Иван: 85
Мария: 92

Обратная сортировка:
Мария: 92
Иван: 85
Пётр: 78

Пояснение: Функция sorted() возвращает новый отсортированный список. Параметр key задаёт функцию, извлекающую критерий для сравнения. lambda - анонимная функция, удобная для коротких операций.

5. Рекурсивная функция (вычисление факториала)

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print('Факториал 5:', factorial(5))
print('Факториал 0:', factorial(0))

Факториал 5: 120
Факториал 0: 1

Пояснение: Рекурсия - вызов функции самой себя. Важно задать базовый случай (здесь n == 0), чтобы избежать бесконечной рекурсии. Глубина рекурсии ограничена (по умолчанию 1000), поэтому для больших чисел лучше использовать итеративный подход.

6. Работа с множествами (set)

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

print('Объединение:', set_a | set_b)
print('Пересечение:', set_a & set_b)
print('Разность (A - B):', set_a - set_b)
print('Симметрическая разность:', set_a ^ set_b)

# Проверка вхождения
print('Есть ли 2 в множестве A?', 2 in set_a)

Объединение: {1, 2, 3, 4, 5, 6}
Пересечение: {3, 4}
Разность (A - B): {1, 2}
Симметрическая разность: {1, 2, 5, 6}
Есть ли 2 в множестве A? True

Пояснение: Множества хранят уникальные элементы. Операции: объединение |, пересечение &, разность -, симметрическая разность ^. Множества неупорядочены и не индексируются.

7. Использование enumerate в цикле

colors = ['красный', 'зелёный', 'синий']
for index, color in enumerate(colors, start=1):
    print(f'{index}. {color}')

1. красный
2. зелёный
3. синий

Пояснение: enumerate возвращает пары (индекс, элемент). Параметр start задаёт начальное значение индекса.

8. Распаковка списка в переменные

numbers = [10, 20, 30, 40, 50]
first, second, *rest = numbers
print('first:', first)
print('second:', second)
print('rest:', rest)

first: 10
second: 20
rest: [30, 40, 50]

Пояснение: Оператор * (звёздочка) собирает оставшиеся элементы в список. Можно использовать в любом месте: first, *middle, last = numbers.

9. Комбинирование словарей (Python 3.9+)

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged = dict1 | dict2
print('Слияние словарей:', merged)

Слияние словарей: {'a': 1, 'b': 3, 'c': 4}

Пояснение: Оператор | создаёт новый словарь, при совпадении ключей значение берётся из второго словаря. Альтернатива: {**dict1, **dict2}.

10. Генератор (yield) - ленивые вычисления

def fibonacci(limit):
    a, b = 0, 1
    while a < limit:
        yield a
        a, b = b, a + b

for num in fibonacci(100):
    print(num, end=' ')

0 1 1 2 3 5 8 13 21 34 55 89

Пояснение: Функция-генератор использует yield вместо return. При каждом вызове next() или в цикле код выполняется до следующего yield, что экономит память (не хранит всю последовательность).