Приведи пример повторяющихся действий в Python

Примеры повторяющихся действий в Python

Итерация (повторяющиеся действия) — это один из базовых столпов Python. Покажу различные способы и кейсы.

1. Цикл for — базовая итерация

# Простой цикл по списку
fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

# Вывод:
# apple
# banana
# cherry

# Цикл с индексом
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# Вывод:
# 0: apple
# 1: banana
# 2: cherry

2. Цикл while — повтор до условия

# Повтор, пока условие истинно
count = 0
while count < 5:
    print(f"Итерация {count}")
    count += 1

# Вывод:
# Итерация 0
# Итерация 1
# Итерация 2
# Итерация 3
# Итерация 4

# Практический пример: переподключение к БД
attempts = 0
max_attempts = 3
while attempts < max_attempts:
    try:
        db.connect()
        break  # Успех, выходим
    except ConnectionError:
        attempts += 1
        print(f"Попытка {attempts} не удалась. Повтор...")
else:
    print("Не удалось подключиться после 3 попыток")

3. List Comprehension — компактная итерация

# Создание нового списка на основе существующего
numbers = [1, 2, 3, 4, 5]

# Способ 1: for цикл (старый стиль)
squares = []
for num in numbers:
    squares.append(num ** 2)

print(squares)  # [1, 4, 9, 16, 25]

# Способ 2: list comprehension (питонический стиль)
squares = [num ** 2 for num in numbers]
print(squares)  # [1, 4, 9, 16, 25]

# С условием
even_squares = [num ** 2 for num in numbers if num % 2 == 0]
print(even_squares)  # [4, 16]

# Вложенные list comprehensions (матрица)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

4. Dict Comprehension — итерация по словарям

# Создание словаря из списка
fruits = ["apple", "banana", "cherry"]
fruits_prices = {fruit: len(fruit) for fruit in fruits}
print(fruits_prices)
# {'apple': 5, 'banana': 6, 'cherry': 6}

# Преобразование словаря
scores = {"Alice": 85, "Bob": 92, "Charlie": 78}
scores_doubled = {name: score * 2 for name, score in scores.items()}
print(scores_doubled)
# {'Alice': 170, 'Bob': 184, 'Charlie': 156}

# Фильтрация
high_scores = {name: score for name, score in scores.items() if score > 80}
print(high_scores)
# {'Alice': 85, 'Bob': 92}

5. Map и Filter — функциональный подход

# Map: применить функцию ко всем элементам
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # [1, 4, 9, 16, 25]

# С реальной функцией
def double(x):
    return x * 2

doubled = list(map(double, numbers))
print(doubled)  # [2, 4, 6, 8, 10]

# Filter: оставить только элементы, прошедшие условие
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4, 6, 8, 10]

# Или через list comprehension (предпочтительнее)
evens = [x for x in numbers if x % 2 == 0]

6. Reduce — агрегация

from functools import reduce

# Сумма всех элементов
numbers = [1, 2, 3, 4, 5]
total = reduce(lambda a, b: a + b, numbers)
print(total)  # 15

# Или просто
total = sum(numbers)  # ✅ Проще

# Произведение
product = reduce(lambda a, b: a * b, numbers)
print(product)  # 120

# Практический пример: найти максимум
max_value = reduce(lambda a, b: a if a > b else b, numbers)
print(max_value)  # 5
# ✅ Но это именно то, зачем нужна встроенная функция max()

7. Generator Functions — ленивая итерация

# Обычная функция с return — выполняется полностью
def get_numbers_list(n):
    numbers = []
    for i in range(n):
        numbers.append(i)
    return numbers  # Возвращает весь список сразу

result = get_numbers_list(5)
print(result)  # [0, 1, 2, 3, 4]

# Generator функция с yield — ленивое выполнение
def get_numbers_generator(n):
    for i in range(n):
        yield i  # Возвращает по одному значению за раз

result = get_numbers_generator(5)
print(result)  # <generator object get_numbers_generator at 0x...>

# Используем generator
for num in result:
    print(num)  # 0, 1, 2, 3, 4

# Практический пример: чтение больших файлов
def read_large_file(filepath, chunk_size=1024):
    """Читает файл порциями, не загружая всё в память"""
    with open(filepath, 'r') as file:
        while True:
            chunk = file.read(chunk_size)
            if not chunk:
                break
            yield chunk

# Использование
for chunk in read_large_file('/large/file.txt', chunk_size=4096):
    process(chunk)  # Обрабатываем по частям

8. Zip и Enumerate — комбинирование итераций

# Zip: объединение нескольких списков
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
cities = ["New York", "London", "Paris"]

# Итерируем сразу по трем спискам
for name, age, city in zip(names, ages, cities):
    print(f"{name} ({age}) живет в {city}")

# Вывод:
# Alice (25) живет в New York
# Bob (30) живет в London
# Charlie (35) живет в Paris

# Enumerate: индекс и значение одновременно
for index, name in enumerate(names):
    print(f"{index}: {name}")

# Вывод:
# 0: Alice
# 1: Bob
# 2: Charlie

# Можно задать стартовый индекс
for index, name in enumerate(names, start=1):
    print(f"{index}. {name}")

# Вывод:
# 1. Alice
# 2. Bob
# 3. Charlie

9. Практический пример: обработка данных

# Задача: обработать список заказов и вывести итоговые суммы

orders = [
    {"id": 1, "amount": 100},
    {"id": 2, "amount": 250},
    {"id": 3, "amount": 75},
    {"id": 4, "amount": 300},
]

# Способ 1: for цикл
total_amount = 0
for order in orders:
    total_amount += order["amount"]
print(f"Итого: ${total_amount}")  # Итого: $725

# Способ 2: sum с generator expression
total_amount = sum(order["amount"] for order in orders)
print(f"Итого: ${total_amount}")  # Итого: $725 (более питонический)

# Способ 3: map
total_amount = sum(map(lambda order: order["amount"], orders))
print(f"Итого: ${total_amount}")  # Итого: $725

# Найти средний размер заказа
average_order = sum(order["amount"] for order in orders) / len(orders)
print(f"Средний заказ: ${average_order}")  # Средний заказ: $181.25

# Найти заказы больше $100
large_orders = [order for order in orders if order["amount"] > 100]
print(large_orders)  # [{'id': 2, 'amount': 250}, {'id': 4, 'amount': 300}]

# Создать новый список с только ID и сумма
summary = [{"id": o["id"], "amount": o["amount"]} for o in orders]

10. Range — численная итерация

# Базовая численная итерация
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4

# С начальным и конечным значением
for i in range(1, 5):
    print(i)  # 1, 2, 3, 4

# С шагом
for i in range(0, 10, 2):
    print(i)  # 0, 2, 4, 6, 8

# В обратном порядке
for i in range(5, 0, -1):
    print(i)  # 5, 4, 3, 2, 1

# Практический пример: создание ID
for i in range(1, 101):
    print(f"USER-{i:04d}")  # USER-0001, USER-0002, ..., USER-0100

Ключевые выводы

Выбери правильный способ:

• for цикл — когда нужна полная контроль
• list comprehension — для преобразования списков (питонический стиль)
• map/filter — для функционального подхода
• generator — для работы с большими данными (экономия памяти)
• while — когда итерируешь до условия

Производительность:

import timeit

# List comprehension быстрее
print(timeit.timeit(lambda: [x**2 for x in range(1000)]))
# 0.041 сек

print(timeit.timeit(lambda: list(map(lambda x: x**2, range(1000)))))
# 0.048 сек (медленнее)

Читаемость:

# ✅ Питонический (list comprehension)
result = [x * 2 for x in numbers if x > 5]

# ❌ Менее читаемо (map + filter + lambda)
result = list(map(lambda x: x * 2, filter(lambda x: x > 5, numbers)))