Python Academy · Aula

Funções geradoras

Produza valores sob demanda com yield

Funções geradoras é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

O que é um gerador

Uma função geradora se parece com uma função normal, mas usa yield em vez de (ou junto com) return. Chamá-la não executa o corpo; ela retorna um objeto gerador, que é um iterador.

def gen():
    yield 1
    yield 2
    yield 3

g = gen()
print(type(g).__name__)
print(list(g))

yield pausa a execução

Cada vez que você chama next(), a função é executada até encontrar um yield, retorna esse valor e congela seu estado. A chamada seguinte continua logo após o yield.

def steps():
    print('start')
    yield 'a'
    print('resumed')
    yield 'b'

g = steps()
print(next(g))
print(next(g))

Percorrendo um gerador

Como um gerador é um iterador, um laço for o conduz automaticamente e para quando a função termina (o que gera StopIteration internamente).

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

for x in countdown(4):
    print(x)

Avaliação tardia

Geradores são preguiçosos: os valores só são produzidos quando solicitados. Isso permite modelar sequências muito grandes ou infinitas sem usar muita memória.

def naturals():
    n = 1
    while True:
        yield n
        n += 1

g = naturals()
print(next(g), next(g), next(g))

Estado entre os yields

As variáveis locais mantêm seus valores entre os pontos de yield. Um gerador naturalmente se lembra de onde parou, sem a necessidade de controlar manualmente um índice.

def fib():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

g = fib()
print([next(g) for _ in range(7)])

Geradores versus criação de uma lista

Uma função normal cria e retorna a lista inteira de uma vez. Um gerador produz itens sob demanda. Use um gerador quando a sequência for grande ou quando você puder interromper o processamento antes do fim.

def squares_list(n):
    result = []
    for i in range(n):
        result.append(i * i)
    return result

def squares_gen(n):
    for i in range(n):
        yield i * i

print(squares_list(5))
print(list(squares_gen(5)))

Interrompendo antes do fim

Como a produção é tardia, você pode sair de um laço, e o gerador simplesmente nunca calculará o restante.

def naturals():
    n = 1
    while True:
        print('producing', n)
        yield n
        n += 1

for x in naturals():
    if x > 3:
        break
    print('got', x)

return dentro de um gerador

Um return isolado em um gerador simplesmente o encerra (gerando StopIteration). Qualquer valor retornado torna-se o atributo value da exceção, que a maioria dos laços ignora.

def up_to(stop):
    i = 0
    while True:
        if i >= stop:
            return
        yield i
        i += 1

print(list(up_to(4)))

Geradores são de uso único

Como todos os iteradores, um gerador é consumido uma vez. Depois de esgotado, ele não produz mais nada. Chame a função novamente para obter um gerador novo.

def gen():
    yield 1
    yield 2

g = gen()
print(list(g))
print(list(g))
print(list(gen()))

Filtragem com geradores

Geradores permitem criar pipelines de dados claros. Aqui, produzimos apenas os números pares, um de cada vez.

def evens(numbers):
    for n in numbers:
        if n % 2 == 0:
            yield n

print(list(evens(range(10))))

Encadeando geradores

Um gerador pode consumir outro gerador, criando um pipeline de várias etapas em que cada etapa é tardia.

def numbers(n):
    for i in range(n):
        yield i

def doubled(src):
    for x in src:
        yield x * 2

print(list(doubled(numbers(5))))

Verificação rápida

Teste sua compreensão das funções geradoras.

Recapitulação

Você aprendeu sobre funções geradoras:

yield pausa e retoma a execução, preservando o estado local.
Chamar a função retorna um objeto gerador tardio.
Elas economizam memória e são excelentes para pipelines e fluxos infinitos.
São de uso único, como qualquer iterador.

Em seguida: as expressões geradoras, ainda mais compactas.

Perguntas Frequentes

A aula “Funções geradoras” é grátis?

Sim — o texto completo de “Funções geradoras” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Funções geradoras”?

Produza valores sob demanda com yield Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Funções geradoras”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Python Academy