Summary  
This chapter covers how to implement infinite generators using `yield` inside a `while True` loop to produce unbounded sequences of values on demand and control their retrieval with `next()` or iteration constructs.  

General domain of usage  
Data streaming

Lembre-se de que `yield` pausa um gerador e o retoma na próxima chamada de `next()`. Até agora, os geradores apresentados tinham um ponto de parada definido. No entanto, os geradores tornam-se especialmente poderosos quando combinados com um **laço infinito** – produzindo valores indefinidamente sem nunca armazená-los na memória.

## Geradores Infinitos com `while True`

O uso de um laço `while True` dentro de um gerador cria uma **sequência infinita** – algo impossível de armazenar como uma lista. O gerador só produz o próximo valor quando `next()` é chamado:


def counter():
    count = 1
    while True:       # Runs forever
        yield count   # Return current value and pause
        count += 1    # Resume from here on the next call

gen = counter()

print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3

Não importa quantas vezes você chame `next()`, o gerador sempre terá um novo valor pronto – ele nunca se adianta nem armazena valores na memória.

## Controle de um Gerador Infinito

Como o gerador executa indefinidamente, é necessário controlar quantos valores você deseja obter. A maneira mais comum é utilizando um laço `for` com `range()`:


def counter():
    count = 1
    while True:
        yield count
        count += 1

gen = counter()

for _ in range(5):
    print(next(gen))  # 1, 2, 3, 4, 5

Nunca itere sobre um gerador infinito com um loop `for` simples sem uma condição de parada – isso fará com que ele execute para sempre e trave seu programa.

Nota

import unittest
import types

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestIdGenerator(unittest.TestCase):

    def test_id_generator_is_generator(self):
        import user_code
        try:
            result = user_code.id_generator()
            condition = isinstance(result, types.GeneratorType)
            failure_message = "Expected `id_generator()` to return a generator object."
        except AttributeError:
            condition = False
            failure_message = "The function `id_generator` is not defined."
        _dynamic_test(self, condition, "The `id_generator()` returns a generator object.", failure_message)

    def test_first_five_ids(self):
        import user_code
        try:
            gen = user_code.id_generator()
            result = [next(gen) for _ in range(5)]
            expected = ["ID_1", "ID_2", "ID_3", "ID_4", "ID_5"]
            condition = result == expected
            failure_message = f"Expected `{expected}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `id_generator` is not defined."
        _dynamic_test(self, condition, f"The `id_generator` correctly generates `['ID_1', 'ID_2', 'ID_3', 'ID_4', 'ID_5']`.", failure_message)

    def test_id_format(self):
        import user_code
        try:
            gen = user_code.id_generator()
            result = [next(gen) for _ in range(5)]
            condition = all(id.startswith("ID_") for id in result)
            failure_message = f"Expected all IDs to follow the format `ID_N`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `id_generator` is not defined."
        _dynamic_test(self, condition, "All generated IDs follow the format `ID_N`.", failure_message)

    def test_ids_are_sequential(self):
        import user_code
        try:
            gen = user_code.id_generator()
            result = [next(gen) for _ in range(5)]
            numbers = [int(id.split("_")[1]) for id in result]
            condition = numbers == list(range(1, 6))
            failure_message = f"Expected sequential IDs starting from 1, but got `{result}`."
        except (AttributeError, ValueError):
            condition = False
            failure_message = "Could not verify sequential IDs — make sure the format is `ID_N`."
        _dynamic_test(self, condition, "The generated IDs are sequential starting from `ID_1`.", failure_message)

if __name__ == '__main__':
    unittest.main()

test_main.py

Adquira uma compreensão sólida de como as funções estruturam a programação em Python. Domine a definição e chamada de funções, o trabalho com argumentos, o tratamento de valores de retorno e a criação de código flexível e eficiente utilizando recursão e expressões lambda.

Explore o que são funções e por que são essenciais em Python. Aprenda a criar funções, definir argumentos, manipular valores de retorno e utilizar funções embutidas de forma eficaz.

Aprenda como funcionam os argumentos posicionais e opcionais em Python. Desenvolva funções adaptáveis que lidam com diferentes entradas e aumentam a flexibilidade do seu código.

Compreensão do uso de argumentos arbitrários e argumentos nomeados para lidar com tamanhos variáveis de entrada. Estudo de como essas técnicas tornam as funções mais dinâmicas e organizadas.

Descubra como os valores de retorno representam a saída de uma função. Aprenda a retornar valores únicos ou múltiplos, utilizar None e explorar geradores para um controle de fluxo de dados mais avançado.

Desbloqueie conceitos avançados de funções com recursão e funções lambda. Aprenda como a recursão resolve problemas repetitivos e como as expressões lambda criam funções concisas em uma única linha.

Geradores Infinitos

Geradores Infinitos com while True

Controle de um Gerador Infinito

Solução

Geradores Infinitos com `while True`