Приведи пример генератора из стандартной библиотеки в Python

Примеры генераторов в стандартной библиотеке Python

Генераторы — это функции, которые возвращают значения по одному, сохраняя состояние между вызовами. В стандартной библиотеке есть множество встроенных генераторов, которые экономят память и повышают производительность.

1. range() — самый распространенный генератор

# range возвращает объект, который генерирует числа по требованию
for i in range(5):
    print(i)  # 0, 1, 2, 3, 4

# Это экономит память, особенно с большими числами
# range(1000000) не создает список из миллиона элементов
big_range = range(1000000)
print(type(big_range))  # <class 'range'>
print(big_range[999999])  # Доступ по индексу в O(1)

# В Python 2 это был список (очень затратно!)
# В Python 3 это генератор (эффективно)

2. enumerate() — генератор с индексами

words = ["apple", "banana", "cherry"]

# enumerate генерирует пары (индекс, значение)
for index, word in enumerate(words):
    print(f"{index}: {word}")
# 0: apple
# 1: banana
# 2: cherry

# Можно начать с другого индекса
for index, word in enumerate(words, start=1):
    print(f"{index}: {word}")
# 1: apple
# 2: banana
# 3: cherry

# Это не создает отдельный список, а генерирует значения на лету

3. zip() — генератор пар из нескольких итерируемых

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
cities = ["New York", "London", "Paris"]

# zip создает пары из элементов нескольких списков
for name, age, city in zip(names, ages, cities):
    print(f"{name}, {age}, живет в {city}")
# Alice, 25, живет в New York
# Bob, 30, живет в London
# Charlie, 35, живет в Paris

# zip генерирует по одной паре за раз
result = zip(names, ages)
print(type(result))  # <class 'zip'> — генератор

# Это очень полезно для больших наборов данных
data1 = range(1000000)
data2 = range(1000000)
zipped = zip(data1, data2)  # Не создает список из 2 млн элементов

4. map() — генератор для трансформации

numbers = [1, 2, 3, 4, 5]

# map применяет функцию к каждому элементу
def square(x):
    return x ** 2

squared = map(square, numbers)
print(type(squared))  # <class 'map'> — генератор
print(list(squared))  # [1, 4, 9, 16, 25]

# С lambda функциями
result = map(lambda x: x * 2, numbers)
print(list(result))  # [2, 4, 6, 8, 10]

# Очень эффективно для больших данных
big_numbers = range(1000000)
big_squared = map(lambda x: x ** 2, big_numbers)
first_10 = [next(big_squared) for _ in range(10)]  # Вычисляет только 10 значений

5. filter() — генератор для фильтрации

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# filter оставляет только элементы, для которых функция вернула True
def is_even(x):
    return x % 2 == 0

evens = filter(is_even, numbers)
print(type(evens))  # <class 'filter'> — генератор
print(list(evens))  # [2, 4, 6, 8, 10]

# С lambda
odds = filter(lambda x: x % 2 != 0, numbers)
print(list(odds))  # [1, 3, 5, 7, 9]

# Лучше использовать list comprehension (более Pythonic)
evens_list = [x for x in numbers if x % 2 == 0]

6. reversed() — генератор обратного порядка

words = ["apple", "banana", "cherry"]

# reversed генерирует элементы в обратном порядке
for word in reversed(words):
    print(word)
# cherry
# banana
# apple

print(type(reversed(words)))  # <class 'reversed'> — генератор

# Работает с любыми последовательностями
for char in reversed("hello"):
    print(char)  # o, l, l, e, h

7. itertools модуль — "игровая площадка" генераторов

import itertools

# itertools.count() — бесконечный генератор
counter = itertools.count(start=0, step=1)
first_10 = [next(counter) for _ in range(10)]
print(first_10)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# itertools.cycle() — повторяет последовательность бесконечно
colors = ["red", "green", "blue"]
cycled = itertools.cycle(colors)
first_9 = [next(cycled) for _ in range(9)]
print(first_9)  # ["red", "green", "blue", "red", "green", "blue", ...]

# itertools.repeat() — повторяет одно значение
repeated = itertools.repeat("x", 5)
print(list(repeated))  # ["x", "x", "x", "x", "x"]

# itertools.chain() — объединяет несколько итерируемых
list1 = [1, 2, 3]
list2 = [4, 5, 6]
chained = itertools.chain(list1, list2)
print(list(chained))  # [1, 2, 3, 4, 5, 6]

# itertools.combinations() и itertools.permutations()
from itertools import combinations, permutations

letters = ["a", "b", "c"]
combs = combinations(letters, 2)
print(list(combs))  # [("a", "b"), ("a", "c"), ("b", "c")]

perms = permutations(letters, 2)
print(list(perms))  # [("a", "b"), ("a", "c"), ("b", "a"), ...]

8. os.walk() — генератор для обхода директорий

import os

# os.walk() генерирует кортежи (directoryname, dirnames, filenames)
for dirpath, dirnames, filenames in os.walk("."): 
    print(f"Директория: {dirpath}")
    print(f"Поддиректории: {dirnames}")
    print(f"Файлы: {filenames}")
    print()

# Это экономит память при обходе больших директорий

9. dict.items(), dict.keys(), dict.values() — генераторы словарей

user = {"name": "Alice", "age": 25, "city": "New York"}

# .items() генерирует пары ключ-значение
for key, value in user.items():
    print(f"{key}: {value}")

# .keys() генерирует ключи
for key in user.keys():
    print(key)

# .values() генерирует значения
for value in user.values():
    print(value)

# В Python 3 это генераторы представлений, не списки
print(type(user.items()))  # <class 'dict_items'>

10. open() в Python — ленивый генератор файла

# Итерация по файлу не загружает весь файл в память
with open("large_file.txt") as f:
    for line in f:  # Файл генерирует по одной строке за раз
        print(line.strip())

# Это очень эффективно для больших файлов (гигабайты)
# Без генератора пришлось бы загружать весь файл в память

Сравнение: список vs генератор

import sys

# Список — занимает много памяти
big_list = [i for i in range(1000000)]
print(f"Размер списка: {sys.getsizeof(big_list)} байт")  # ~8 миллионов

# Генератор — почти не занимает памяти
big_range = range(1000000)
print(f"Размер range: {sys.getsizeof(big_range)} байт")  # ~48 байт

# Практически такой же результат, но в 166 раз меньше памяти!

Вывод

Генераторы в стандартной библиотеке (range, enumerate, zip, map, filter, reversed, itertools и другие) — это мощные инструменты для эффективной работы с данными. Они:

• Экономят память (ленивые вычисления)
• Повышают производительность
• Позволяют работать с бесконечными последовательностями
• Делают код более читаемым и Pythonic

Всегда выбирай генератор вместо списка, когда нужно итерировать по данным один раз.