Итераторы и генераторы в Python

Итераторы — это объекты в Python, которые позволяют перебирать элементы коллекции или последовательности по одному.

Коллекции — это объекты, которые хранятся в памяти целиком. Например: списки, кортежи, множества, строки, словари.

# Создание списка с миллионами чисел
big_list = range(1, 1000001)

# Использование итератора для подсчета суммы элементов
total = 0
for num in big_list:
    total += num

print("Сумма элементов списка:", total)

Использование итераторов

for переменная in итератор:
    # Код, выполняемый для каждого элемента итератора

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

1. Переменная: Переменная, указанная после ключевого слова for, будет принимать значение каждого элемента итератора на каждой итерации цикла. На каждой итерации значение этой переменной обновляется. Например:

   my_list = [1, 2, 3, 4, 5]
   
   for item in my_list:
       print(item)  # Здесь переменная item принимает значения 1, 2, 3, 4, 5 поочередно.
   

2. Итератор: Итератор — это объект, который поддерживает итерацию. Это может быть любой итерируемый объект в Python, такой как строка, список, множество, словарь, пользовательский класс, который реализует методы __iter__() и __next__() или функция-генератор, реализующая внутри инструкцию yield.

my_string = "Hello"

for char in my_string:
    print(char)  # Здесь итератор для строки перемещается по символам "H", "e", "l", "l", "o".

Перебор стандартных последовательностей

my_string = "Hello, Python!"

for char in my_string:
    print(char)

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

for item in my_list:
    print(item)

my_set = {1, 2, 3, 4, 5}

for item in my_set:
    print(item)

• Перебор ключей:

my_dict = {"a": 1, "b": 2, "c": 3}

for key in my_dict:
    print(key)

• Перебор значений:

for value in my_dict.values():
    print(value)

• Перебор пар ключ-значение:

for key, value in my_dict.items():
    print(key, value)

Задания на закрепление

Задание 1. Напишите программу, которая принимает строку от пользователя и подсчитывает количество гласных букв (букв «a», «e», «i», «o», «u») в этой строке.

# Получаем строку от пользователя
input_string = input("Введите строку: ")

# Инициализируем счетчик гласных
count = 0

# Перебираем символы строки
for char in input_string:
    # Проверяем, является ли символ гласной буквой
    if char.lower() in "aeiou":
        count += 1

# Выводим результат
print("Количество гласных букв в строке:", count)

Задание 2.Дан список чисел. Найдите сумму всех чисел в этом списке. Функцию sum()не используйте.

# Заданный список чисел
numbers = [5, 10, 15, 20]

# Инициализируем переменную для суммы
total = 0

# Перебираем числа в списке и добавляем их к сумме
for num in numbers:
    total += num

# Выводим результат
print("Сумма чисел в списке:", total)

Задание 3. Дано множество чисел. Найдите наименьшее и наибольшее число в этом множестве. Функции min() и max() не используйте.

# Заданное множество чисел
numbers_set = {15, 7, 32, 44, 10}

# Инициализируем переменные для наименьшего и наибольшего числа
min_num = float('inf')  # Изначально устанавливаем наименьшее число как бесконечность
max_num = float('-inf')  # Изначально устанавливаем наибольшее число как отрицательную бесконечность

# Перебираем числа в множестве
for num in numbers_set:
    if num < min_num:
        min_num = num  # Обновляем наименьшее число, если нашли меньшее
    if num > max_num:
        max_num = num  # Обновляем наибольшее число, если нашли большее

# Выводим результат
print("Наименьшее число:", min_num)
print("Наибольшее число:", max_num)

Стандартные итераторы и итерируемые объекты

1. Итератор range(): Используется для создания последовательности чисел в заданном диапазоне.

   # Создание итератора range с шагом 2 от 0 до 10
   my_range = range(0, 10, 2)
   
   # Использование итератора range в цикле
   for num in my_range:
       print(num)
   

    
2. Итератор enumerate(): Позволяет получать индекс каждого элемента в последовательности.

   # Создание списка
   my_list = ['apple', 'banana', 'cherry']
   
   # Использование итератора enumerate для получения индекса и значения
   for index, value in enumerate(my_list):
       print(f"Index: {index}, Value: {value}")
   

    
3. Итератор zip(): Позволяет объединить несколько последовательностей в кортежи.

   # Создание списков
   names = ['Alice', 'Bob', 'Charlie']
   scores = [85, 92, 78]
   
   # Использование итератора zip для объединения списков
   for name, score in zip(names, scores):
       print(f"Name: {name}, Score: {score}")
   

    
4. Итератор reversed(): Используется для перебора элементов последовательности в обратном порядке.

   # Создание списка
   my_list = [1, 2, 3, 4, 5]
   
   # Использование итератора reversed для обратного перебора списка
   for num in reversed(my_list):
       print(num)
   

    
5. Итератор sorted(): Позволяет перебирать элементы последовательности в отсортированном порядке.

   # Создание списка
   my_list = [5, 2, 9, 1, 7]
   
   # Использование итератора sorted для перебора отсортированного списка
   for num in sorted(my_list):
       print(num)
   

Задание на закрепление

Задание 4. Даны два списка одинаковой длины, содержащие числа. Создайте новый список, в котором каждый элемент будет равен сумме соответствующих элементов из первых двух списков, используя итератор zip.

# Заданные списки
list1 = [1, 2, 3, 4, 5]
list2 = [10, 20, 30, 40, 50]

# Используем zip для объединения элементов из двух списков и сложения их
result_list = [a + b for a, b in zip(list1, list2)]

# Выводим результат
print("Результат сложения списков:", result_list)

Итераторы модулей collections и itertools

Класс collections.Counter

from collections import Counter

text = "hello, world"

letter_count = Counter(text)

print(letter_count)

Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ',': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

from collections import Counter

list1 = [1, 2, 2, 3, 4, 5]
list2 = [2, 3, 3, 4, 5, 6]

counter1 = Counter(list1)
counter2 = Counter(list2)

if counter1 == counter2:
    print("Списки имеют одинаковые элементы с одинаковыми частотами.")
else:
    print("Списки имеют разные элементы или разные частоты элементов.")

Модуль itertools

1. Бесконечные итераторы:
   • count(start, step): Создает бесконечную арифметическую прогрессию начиная с start с шагом step.
   • cycle(iterable): Бесконечно повторяет элементы из итерируемого объекта.
   • repeat(element, times): Бесконечно повторяет элемент указанное количество раз.
2. Итераторы для комбинаторики:
   • permutations(iterable, r): Генерирует все возможные перестановки длины r из элементов итерируемого объекта.
   • combinations(iterable, r): Генерирует все возможные сочетания длины r из элементов итерируемого объекта.
   • combinations_with_replacement(iterable, r): Генерирует все возможные сочетания с повторениями длины r.
   • product (iterable,repeat): Генерирует все возможные слова из алфавита последовательности iterable длиной repeat.
3. Итераторы для фильтрации и группировки данных:
   • filterfalse(predicate, iterable): Возвращает элементы, для которых функция predicate возвращает False.
   • groupby(iterable, key=None): Группирует элементы в итерируемом объекте на основе ключевой функции key.
4. Итераторы для объединения и повторения данных:
   • chain(iterable1, iterable2, ...): Объединяет несколько итерируемых объектов в один.
   • zip_longest(iterable1, iterable2, fillvalue=None): Объединяет несколько итерируемых объектов, дополняя недостающие элементы значением fillvalue.
5. Итераторы для вычислений и агрегации:
   • accumulate(iterable, func=None): Вычисляет накопительные значения, применяя функцию func к элементам.
   • starmap(function, iterable): Применяет функцию function к каждому элементу итерируемого объекта, передавая элементы как аргументы.
6. Итераторы для комбинирования и фильтрации:
   • islice(iterable, start, stop, step): Возвращает итератор, который выбирает элементы из итерируемого объекта с указанным срезом.

Примеры применения itertools

from itertools import count

for num in count(start=1, step=2):
    print(num)

from itertools import cycle

colors = ['red', 'green', 'blue']
for color in cycle(colors):
    print(color)

from itertools import permutations

letters = ['a', 'b', 'c']
perms = permutations(letters, 2)
for perm in perms:
    print(perm)

from itertools import combinations

letters = ['a', 'b', 'c']
combs = combinations(letters, 2)
for comb in combs:
    print(comb)

from itertools import groupby

words = ['apple', 'banana', 'cherry', 'date', 'fig', 'grape']
grouped = groupby(words, key=lambda x: x[0])

for key, group in grouped:
    print(key, list(group))

from itertools import accumulate

numbers = [1, 2, 3, 4, 5]
accum = accumulate(numbers)

for result in accum:
    print(result)

from itertools import chain

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = chain(list1, list2)

for item in combined:
    print(item)

Задания для закрепления

Задание 5. Напишите программу, которая принимает строку от пользователя и выводит частоту каждой буквы в строке (без учета регистра). Используйте итератор collections.Counter для этой задачи.

from collections import Counter

# Получаем строку от пользователя
input_string = input("Введите строку: ")

# Используем Counter для подсчета частоты букв
letter_count = Counter(input_string.lower())

# Выводим результат
for letter, count in letter_count.items():
    if letter.isalpha():
        print(f"Буква '{letter}': {count} раз")

Задание 6. Дан список списков, где каждый вложенный список содержит числа. Найдите наименьшее число в этом списке списков, используя итератор itertools.chain.

from itertools import chain

# Заданный список списков
list_of_lists = [[5, 8, 1], [3, 7, 2], [9, 4, 6]]

# Используем itertools.chain для объединения всех списков в один
flat_list = list(chain.from_iterable(list_of_lists))

# Находим минимальное число в объединенном списке
min_number = min(flat_list)

# Выводим результат
print("Наименьшее число:", min_number)

Задание 7. Напишите программу для генерации всех возможных паролей заданной длины из заданного набора символов (например, буквы и цифры). Используйте itertools.product для создания всех комбинаций паролей.

from itertools import product
import string

# Заданный набор символов
charset = string.ascii_lowercase + string.digits

# Длина пароля
password_length = 4

# Генерация и вывод всех паролей заданной длины
passwords = [''.join(p) for p in product(charset, repeat=password_length)]
for password in passwords:
    print(password)

Задание 8. Напишите программу для генерации всех возможных паролей заданной длины из заданного набора символов (например, буквы и цифры). Используйте itertools.product для создания всех комбинаций паролей.

from itertools import product
import string

# Заданный набор символов
charset = string.ascii_lowercase + string.digits

# Длина пароля
password_length = 4

# Генерация и вывод всех паролей заданной длины
passwords = [''.join(p) for p in product(charset, repeat=password_length)]
for password in passwords:
    print(password)

Задание 9. Создайте программу, которая перебирает все слова из словаря (например, из файла) и находит слова, которые являются палиндромами (читаются одинаково с начала и с конца). Используйте itertools.product для генерации всех возможных комбинаций букв в слове.

from itertools import product

# Загрузка словаря слов
with open('dictionary.txt', 'r') as file:
    word_list = file.read().splitlines()

# Функция для проверки, является ли слово палиндромом
def is_palindrome(word):
    return word == word[::-1]

# Поиск и вывод палиндромов
for word in word_list:
    if is_palindrome(word):
        print(word)

Задание 10. Напишите программу, которая разделяет список на подсписки заданной длины. Используйте itertools.islice для этой задачи.

from itertools import islice

# Заданный список
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Заданная длина подсписков
chunk_size = 3

# Разделение списка на подсписки заданной длины
sublists = [list(islice(my_list, i, i + chunk_size)) for i in range(0, len(my_list), chunk_size)]

# Вывод результатов
for sublist in sublists:
    print(sublist)

Создание собственных итераторов

1. Метод __iter__(): Этот метод должен возвращать сам объект (обычно self) и инициализировать или подготовить объект для итерации. Метод __iter__() должен быть определен для вашего класса, чтобы он стал итерируемым.
2. Метод __next__(): Этот метод должен возвращать следующий элемент в итерации. Если больше элементов нет, он должен вызвать исключение StopIteration. Каждый вызов метода __next__() должен возвращать следующий элемент или вызывать StopIteration, чтобы завершить итерацию.

class MyIterator:
    def __init__(self, max_num):
        self.max_num = max_num
        self.current_num = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_num < self.max_num:
            self.current_num += 1
            return self.current_num
        else:
            raise StopIteration

# Использование собственного итератора
my_iterator = MyIterator(5)
for num in my_iterator:
    print(num)

• Класс MyIterator реализует метод __iter__() так, чтобы он возвращал сам объект.
• Метод __next__() увеличивает текущее число на каждой итерации и возвращает его. Когда достигнуто максимальное значение, он вызывает StopIteration.

Пример собственного итератора

pip install openpyxl

import openpyxl

class ExcelIterator:
    def __init__(self, file_path):
        self.file_path = file_path
        self.workbook = openpyxl.load_workbook(file_path)
        self.current_sheet = None
        self.current_row = 1
        self.current_column = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_sheet is None:
            self.current_sheet = self.workbook.active
        if self.current_row > self.current_sheet.max_row:
            if self.current_sheet == self.workbook.active:
                self.current_sheet = None
                self.current_row = 1
                self.current_column = 1
            else:
                raise StopIteration

        cell = self.current_sheet.cell(row=self.current_row, column=self.current_column)
        data = cell.value

        # Переход к следующей ячейке
        self.current_column += 1
        if self.current_column > self.current_sheet.max_column:
            self.current_column = 1
            self.current_row += 1

        return data

# Пример использования итератора
excel_file = 'example.xlsx'
iterator = ExcelIterator(excel_file)

for data in iterator:
    print(data)

Задания на закрепление

Задание 11. Создайте собственный итератор для генерации ряда Фибоначчи. Ряд Фибоначчи начинается с двух начальных чисел (обычно 0 и 1), и каждое последующее число в ряде равно сумме двух предыдущих чисел.

class FibonacciIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0
        self.next = 1
        self.count = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.count >= self.limit:
            raise StopIteration
        else:
            result = self.current
            self.current, self.next = self.next, self.current + self.next
            self.count += 1
            return result

# Использование собственного итератора для генерации ряда Фибоначчи
limit = 10  # Задайте желаемое количество чисел в ряде
fibonacci_iterator = FibonacciIterator(limit)

for num in fibonacci_iterator:
    print(num)

Генераторы

1. Ленивая генерация: Генераторы создают значения по мере необходимости, что позволяет обрабатывать большие или бесконечные последовательности данных без необходимости хранить все значения в памяти одновременно.
2. Итерируемость: Генераторы являются итерируемыми объектами, что означает, что вы можете использовать их в циклах for и других конструкциях, требующих итерации.
3. Состояние сохраняется: Генераторы запоминают свое состояние между вызовами yield. Когда вызывается yield, текущее состояние сохраняется, и выполнение функции приостанавливается до следующей итерации.

def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()

for value in gen:
    print(value)

Чем функция-генератор отличается от обычной функции

1. Использование ключевого слова yield: Генераторы используют ключевое слово yield для создания значений, которые возвращаются при каждой итерации. Это позволяет генераторам сохранять свое состояние между вызовами итерации и лениво генерировать значения по мере необходимости. В обычных функциях значения возвращаются с помощью ключевого слова return, и функция завершается после возврата значения.
2. Состояние сохраняется: Генераторы сохраняют свое состояние между вызовами yield. Когда вызывается yield, текущее состояние функции сохраняется, и выполнение приостанавливается. При следующей итерации выполнение продолжается с точки, где оно было приостановлено. В обычных функциях состояние не сохраняется между вызовами, и функция начинает выполнение с самого начала при каждом вызове.
3. Итерируемость: Генераторы являются итерируемыми объектами, что означает, что их можно использовать в циклах for и других конструкциях, требующих итерации. Обычные функции не являются итерируемыми объектами, и их результаты обычно не могут быть перебраны напрямую.
4. Эффективность использования памяти: Генераторы позволяют лениво (по мере необходимости) генерировать значения, что делает их эффективными для работы с большими объемами данных. В отличие от обычных функций, которые могут вернуть большие списки или коллекции данных, генераторы генерируют значения по одному, не загружая всю память.

Использование памяти в случае обычной функции и генератора

• При вызове обычной функции вся локальная память (переменные, объекты и т.д.) выделяется и остается в памяти до тех пор, пока функция не завершит выполнение и не вернет результат (при помощи return).
• Если обычная функция создает большие объекты или выполняет сложные вычисления, это может потреблять много памяти, особенно при работе с большими объемами данных.
• После завершения выполнения обычной функции все локальные переменные уничтожаются, и память освобождается.

def ordinary_function():
    data = [1] * 1000000  # Создание списка из миллиона элементов
    return data

result = ordinary_function()  # Вызов функции
# Память будет занята списком data до возврата результата

• При вызове функции-генератора память выделяется только для сохранения состояния функции, а не для создания и хранения всех значений сразу.
• Генераторы используют ключевое слово yield, чтобы лениво (по мере необходимости) генерировать значения. Память занимается только для текущего состояния выполнения функции и не хранит значения, которые будут сгенерированы в будущем.
• После возврата значения через yield, состояние функции «замораживается», и память, выделенная для этого состояния, не освобождается полностью, но можно генерировать следующие значения, не занимая больше памяти.

def generator_function():
    for i in range(1000000):
        yield i

gen = generator_function()  # Создание генератора
# Память будет заниматься только текущим состоянием выполнения функции

Обратите внимание, что функция-генератор сохраняет состояние между итерациями, что может потреблять небольшое количество памяти. Однако это делает генераторы эффективными для работы с большими данными, так как память используется лениво и минимально.

Итерируемый объект (коллекция) или генератор?

1. Генерация значений:
   • Коллекции обычно генерируют значения заранее и сохраняют их в памяти. Это означает, что все элементы итерируемого объекта (например, списка) создаются и хранятся в памяти до их использования. Это может потреблять большой объем памяти, особенно при работе с большими данными.
   • Генераторы генерируют значения по мере необходимости (лениво). Они не сохраняют все значения в памяти, а генерируют их на лету при каждой итерации. Это позволяет эффективно обрабатывать большие объемы данных, так как память используется минимально.
2. Синтаксис:
   • Коллекции: Для создания собственной коллекции, обычно требуется определить класс с методами __iter__() и __next__(), что может потребовать больше кода.
   • Генераторы: Генераторы определяются с использованием функций, содержащих ключевое слово yield. Этот синтаксис гораздо более компактный и понятный, чем создание класса и методов для итератора.
3. Использование:
   • Коллекции подходят, когда вам нужно выполнить какие-то сложные действия при итерации, и вы хотите полный контроль над процессом.
   • Генераторы отлично подходят для простых случаев итерации по данным, особенно когда данные можно генерировать лениво, чтобы сэкономить память и упростить код.
4. Состояние:
   • Коллекции могут иметь состояние, они могут запоминать, где остановились, и продолжать с этой точки. Это может быть полезно в некоторых случаях.
   • Генераторы автоматически запоминают состояние между итерациями, поэтому вам не нужно заботиться о хранении состояния явно.
5. Производительность:
   • Итераторы: Итераторы могут быть менее эффективными с точки зрения производительности и использования памяти при работе с большими данными.
   • Генераторы: Генераторы обычно более эффективны с точки зрения производительности и использования памяти, так как они генерируют данные по мере необходимости.

Когда лучше использовать генератор, а когда коллекцию

1. Обработка данных из внешних источников: Если вы читаете данные из внешних источников, таких как базы данных, API, файлы, сетевые соединения и т. д., и данные поступают порциями или требуют специальной обработки, то создание собственной коллекции, отличная идея. коллекция позволяет управлять процессом чтения и обработки данных.

class DatabaseIterator:
    def __init__(self, query):
        self.query = query
        self.connection = create_database_connection()
        self.cursor = self.connection.cursor()

    def __iter__(self):
        return self

    def __next__(self):
        row = self.cursor.fetchone()
        if row is None:
            raise StopIteration
        return process_row(row)

# Использование собственного итератора для чтения данных из базы данных
query = "SELECT * FROM table_name"
db_iterator = DatabaseIterator(query)

for record in db_iterator:
    print(record)

1. Ленивая загрузка больших данных: Если вы имеете дело с большими объемами данных и хотите минимизировать использование памяти, генераторы и генераторные выражения идеально подходят. Генераторы создают значения по мере необходимости, что позволяет обрабатывать данные по частям.

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

# Использование генератора для генерации чисел Фибоначчи
limit = 1000000  # Генерировать миллион чисел
fibonacci_gen = fibonacci_generator(limit)

for num in fibonacci_gen:
    print(num)

2. Фильтрация данных: Генераторы удобны для фильтрации данных, когда вы хотите выбрать определенные элементы из исходной последовательности, и не хотите создавать новый список.

def even_numbers_generator(numbers):
    for num in numbers:
        if num % 2 == 0:
            yield num

# Использование генератора для фильтрации четных чисел
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_gen = even_numbers_generator(numbers)

for num in even_gen:
    print(num)

Генераторные выражения

Генераторное выражение в Python представляет собой компактный способ создания генераторов.

(expression for element in iterable)

• expression — выражение, которое определяет значение, которое будет сгенерировано для каждого элемента в iterable.
• element — переменная, которая принимает каждый элемент из iterable в процессе итерации.
• iterable — итерируемый объект, по которому производится итерация.

1. Генерация списка квадратов чисел от 1 до 10 с использованием генераторного выражения:

   squares = (x ** 2 for x in range(1, 11))
   

2. Генерация генератора для чтения строк из файла:

   lines_generator = (line.strip() for line in open('file.txt'))
   

3. Генерация генератора для фильтрации списка:

   numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   even_numbers = (x for x in numbers if x % 2 == 0)
   

Генераторные выражения или генераторы списков

1. Экономия памяти: Генераторные выражения создают генератор, который генерирует значения на лету по мере необходимости. Это позволяет сэкономить память, особенно при работе с большими данными, так как не все значения хранятся в памяти сразу.
2. Ленивая загрузка: Генераторные выражения подходят, когда данные могут быть обработаны по мере их поступления или по мере необходимости. Они позволяют начать обработку данных сразу, без ожидания полной генерации списка значений.
3. Компактность кода: Генераторные выражения предоставляют компактный синтаксис для создания генераторов без необходимости явно определять функцию-генератор.

1. Быстрота выполнения: Генераторы списков часто работают быстрее, чем эквивалентные генераторные выражения, особенно при создании небольших списков значений. Это связано с тем, что генераторы списков могут выполнять операции на более низком уровне и оптимизировать производительность.
2. Простота использования: Генераторы списков — это более простой и понятный синтаксис, особенно для начинающих. Они предоставляют более явное объявление того, что вы хотите создать список значений.
3. Сохранение результатов: Генераторы списков сохраняют все значения в памяти сразу, что может быть полезно, если вам нужно многократно обращаться к данным.

1. Не всегда подходят: Генераторные выражения не могут использоваться, если необходимо выполнить сложные операции или преобразования данных при создании генератора. В таких случаях потребуется определить функцию-генератор.
2. Ограниченные возможности: Генераторные выражения предназначены для простых операций, их использование ограничено по сравнению с функцией-генератором.

1. Ленивая фильтрация и обработка данных: Генераторные выражения отлично подходят для ленивой фильтрации или обработки данных на лету. Если вы хотите создать генератор, который возвращает результаты по мере их генерации, используйте генераторное выражение.

data = ["apple", "banana", "cherry", "date", "elderberry"]

# Генераторное выражение для фильтрации и обработки данных
filtered_lengths = (len(word) for word in data if len(word) > 5)

for length in filtered_lengths:
    print(length)

2. Преобразование данных: Генераторные выражения можно использовать для преобразования данных, не создавая нового списка. Это полезно, когда вы хотите получить новый генератор на основе существующего.

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

# Генераторное выражение для преобразования данных
squares_generator = (x ** 2 for x in numbers)

for square in squares_generator:
    print(square)

1. Создание списка значений: Генераторы списков полезны, когда вы хотите создать список значений на основе итерации или преобразования данных.

squares_list = [x ** 2 for x in range(1, 11)]
print(squares_list)

2. Создание нового списка с преобразованием данных: Генераторы списков удобны, когда вам нужно создать новый список с преобразованием или фильтрацией данных.

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

# Генератор списка для фильтрации данных
even_numbers_list = [x for x in numbers if x % 2 == 0]
print(even_numbers_list)

Практические задания

Задание 1. Создание собственного итератора для анализа текстового файла

1. Создайте текстовый файл с несколькими строками текста. Файл может содержать предложения, слова, числа или другие данные.
2. Напишите программу на Python, которая будет выполнять следующие действия:a. Создайте собственный итератор для чтения строк из текстового файла. Ваш итератор должен открывать файл, читать строки по одной и закрывать файл, когда все строки будут прочитаны.b. Реализуйте обработку данных, которую вы хотите выполнить с каждой строкой. Например, вы можете разбить строки на слова, вычислить среднюю длину строк, найти определенные ключевые слова и т. д.c. Выведите результаты обработки на экран или сохраните их в другой файл.

Задание 2. Создание собственного генератора для анализа данных в CSV-файле

1. Создайте CSV-файл, который содержит табличные данные. Файл может содержать информацию о продуктах, заказах, студентах или любые другие данные в формате CSV.
2. Напишите программу на Python, которая будет выполнять следующие действия:a. Создайте собственный генератор для чтения данных из CSV-файла. Генератор должен открывать файл, читать строки и возвращать каждую строку данных.b. Реализуйте обработку данных, которую вы хотите выполнить с каждой строкой. Например, вы можете выполнять анализ, вычисления, фильтрацию или другие операции над данными.c. Выведите результаты анализа на экран или сохраните их в другой файл.