📦 Репозиторий занятия 56

## Определение

**Генератор** — это частный случай итератора.

## Но чем они отличаются?

### 1. По способу создания

**Итератор**:

1. **Мы пока знаем ТОЛЬКО итераторы последовательностей**  
***(например, итератор списка)***

2. Чуть позже, после знакомства с ООП, мы сможем создавать итераторы со сложной логикой.

* нужно реализовать вручную два метода:

  * `__iter__()` — возвращает сам итератор
  * `__next__()` — возвращает следующее значение или `StopIteration`
* это больше кода

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

```python
class Counter:
    def __init__(self, n):
        self.n = n
        self.i = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.i < self.n:
            self.i += 1
            return self.i
        raise StopIteration


c = Counter(3)

print(next(c))  # 1
print(next(c))  # 2
print(next(c))  # 3
print(next(c, 'Итератор исчерпан'))  # Итератор исчерпан

```

**Генератор**:

* создаётся автоматически:

  * либо с помощью `yield`
  * либо с помощью генераторного выражения
* не нужно писать класс и методы (т.е. не нужно описывать поведение итератора)
* программисту достаточно описать только логику появления следующего элемента.

Пример генератора:

```python
def counter(n):
    i = 0
…

## Генераторная функция

**Генераторная функция** — это функция, в которой используется ключевое слово `yield`.

```python
def countdown(n):
    while n > 0:
        yield n
        n -= 1
```

Эта функция не возвращает сразу весь набор данных (как `return`),  
а **генерирует по одному значению** при каждом обращении.

---

## Создание генератор из генераторной функции

Чтобы создать генератор, нужно просто **вызвать** (инициализировать) генераторную функцию:

```python
gen = countdown(5)
```

Теперь `gen` — это объект-генератор.
Он отдаёт значения по одному.

---

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

### 1. Через `next()`:

```python
print(next(gen))  # 5
print(next(gen))  # 4
print(next(gen))  # 3
```

### 2. Через цикл:

```python
for num in countdown(5):
    print(num)
```

Вывод:

```
5
4
3
2
1
```

from typing import Generator, Iterator, Callable

def countdown(n):
    while n > 0:
        yield n
        n -= 1

gen = countdown(5)

print('--- Где будет True, и где будет False? ---')

print(isinstance(countdown, Iterator))
print(isinstance(countdown, Generator))
print(isinstance(countdown, Callable))

print('------------------------------------------')

print(isinstance(gen, Iterator))
print(isinstance(gen, Generator))
print(isinstance(gen, Callable))

print('=========== Запуск генератора ============')

for n in gen:
    print(n)

# Генераторная функция
def infinite_numbers(start=0, step=1):
    n = start
    while True:
        yield n
        n += step


# Создание генератора
gen = infinite_numbers(0, 1)


# Запуск генератора
for x in gen:
    print(x)   # будет выводить 0,1

    # обязательное условие для бесконечного генератора
    if x >= 10:
        break

"""
.close() - метод, который:
    - прекращает работу генератора
    - и возвращает исключение StopIteration
    - в самом генераторе вызывает исключение GeneratorExit
"""

# Генераторная функция
def infinite_numbers(start=0, step=1):
    try:
        n = start
        while True:
            yield n
            n += step
    except GeneratorExit as e:
        print(f"{e.__class__.__name__}: {e}")


# Создание генератора
gen = infinite_numbers(0, 1)


# Закрытие генератора с помощью метода close()
while True:
    try:
        n = next(gen)
        print(n)
        if n >= 10:
            gen.close()
    except StopIteration:
        print("Завершение по StopIteration")
        break

 ## Конструкция `yield from`
 
### Простое (неполное) определение

`yield from` - это удобный способ получить генераторную функцию  
из любого итерируемого объекта.

И кстати, эта конструкция допустима ТОЛЬКО внутри тела генераторной функции.

```python
gen_express = (n for n in range(5))
nums_str = 'abcde'
nums_range = range(5)

def gen_f():
    for char in 'ABCDE':
        yield char


def outer_gen(iterable1, iterable2, iterable3, coll_1):
    yield from iterable1
    yield from iterable2
    yield from iterable3
    yield from coll_1()
    
    
# 0, 1, 2, 3, 4, a, b, c, d, e, 0, 1, 2, 3, 4, A, B, C, D, E, 


gen = outer_gen(gen_express, nums_str, nums_range, gen_f)

for x in gen:
    print(x, end=", ")
```

Как видим, для `yield from` годится вся, включая генераторную функцию.  
НО обратите внимание: последнюю надо добавить со скобками, чтоб получить генератор.


### Полное определение

Конструкция `yield from` позволяет:
1. последовательно получать все элементы вложенного генератора/итерируемого.
2. автоматически передавать внутрь вложенного генератора:

   * отправленные через `.send()` значения,
   * исключения,
   * завершение итерации.

3. возвращать значение из `return` внутреннего генератора (если оно есть).

### Запущенный генератор может не только выдавать значения, но и принимать их!

1. **Что делает**:
   Метод `send(value)` позволяет не просто получать следующее значение из генератора (как `next()`),  
   а **отправить генератору значение**, которое будет возвращено в месте `yield`.

2. **Как работает**:

   ```python
   def gen():
       x = yield "Первое значение"
       yield f"Получили: {x}"

   g = gen()
   print(next(g))        # Запускаем генератор, вывод: "Первое значение"
   print(g.send(42))     # Отправляем 42, вывод: "Получили: 42"
   ```

   Здесь:

   * Первый `next()` запускает генератор до первого `yield`.
   * `send(42)` передает значение 42 в `x = yield ...`.

3. **Важно**:

   * Первый раз нельзя вызывать `send` с ненулевым значением — генератор ещё не стартовал. 
   * Для запуска нужно `next(g)` или `g.send(None)`.

4. **Полезность**:

   * Позволяет **двустороннее взаимодействие**: генератор выдает значение и одновременно принимает данные.
   * Часто используется для **корутин**, потоков данных или сложной логики генерации.

"""
В генератор можно не только передавать значения,
но даже можно "забрасывать" исключения!
"""

def my_generator():
    try:
        yield 1
        yield 2
    except ValueError as e:
        # Здесь может быть код, который запустится после получения исключения
        print(f"{e.__class__.__name__}: {e}")


gen = my_generator()
print(next(gen))  # Выводит 1
if next(gen) < 3:
    try:
        gen.throw(ValueError("Specially thrown exception"))
    except StopIteration as e:
        # с методом .throw генератор завершается нестандартно!
        print(f"{e.__class__.__name__}: {e}")

**Задача**:  
Реализовать функцию, которая 
* принимает список словарей и значение ключа
* и возвращает первый элемент, удовлетворяющий условию

``` python
data = [
    {"id": 1, "name": "Leo Tolstoy"},
    {"id": 2, "name": "Fyodor Dostoevsky"},
    {"id": 3, "name": "Jane Austen"},
    {"id": 4, "name": "Mark Twain"},
    {"id": 5, "name": "George Orwell"}
  ]
```


---

## Сравним 3 подхода

Ищем **один** элемент по `id`.

---

### Вариант 1. Обычный `for` + `return`

```python
def find_by_id(items, item_id):
    for item in items:
        if item["id"] == item_id:
            return item
    return None
```

#### ✔ Плюсы

* максимально понятно
* легко дебажить
* лучший вариант для новичков

#### ❌ Минусы

* много «шумного» кода
* намерение (*«найти первый элемент»*) менее очевидно

---

### Вариант 2. `list comprehension`

```python
def find_by_id(items, item_id):
    matches = [item for item in items if item["id"] == item_id]
    return matches[0] if matches else None
```

#### ❌ Минусы (критично)

* проходит **весь список**, даже если элемент найден в начале
* создаёт **лишний список**
* больше памяти
…