Python Academy · Aula

yield from e delegação

Componha geradores

yield from e delegação é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 4 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 problema resolvido por yield from

Quando um gerador quer produzir todos os valores de outro iterável, você pode escrever um laço manual. yield from faz a mesma coisa em uma única linha.

def manual():
    for x in [1, 2, 3]:
        yield x

print(list(manual()))

Apresentando yield from

yield from iterable delega a execução a esse iterável, produzindo cada um de seus valores em sequência. É mais curto e claro do que um laço de encaminhamento.

def delegate():
    yield from [1, 2, 3]

print(list(delegate()))

Combinando várias fontes

Você pode encadear várias instruções yield from para concatenar sequências de forma tardia.

def chained():
    yield from 'ab'
    yield from [1, 2]
    yield from range(2)

print(list(chained()))

Delegando a outro gerador

O iterável delegado pode ser um gerador, permitindo compor geradores em outros maiores.

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

def report(n):
    print('evens:')
    yield from evens(n)

print(list(report(6)))

Achतando listas aninhadas

Um uso clássico de yield from é o achatamento recursivo: um gerador que delega a execução a si mesmo para tratar sublistas.

def flatten(items):
    for item in items:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

print(list(flatten([1, [2, [3, 4]], 5])))

yield from versus um laço

As duas versões abaixo produzem a mesma saída. yield from é preferível por ser mais legível e também encaminhar recursos avançados, como o envio de valores e os resultados de retorno.

def with_loop(src):
    for x in src:
        yield x

def with_yield_from(src):
    yield from src

print(list(with_loop(range(3))))
print(list(with_yield_from(range(3))))

Capturando o retorno de um subgerador

Quando um gerador delegado faz return de um valor, yield from é avaliado como esse valor. Isso permite que subgeradores informem um resultado.

def counter(n):
    count = 0
    for i in range(n):
        yield i
        count += 1
    return count

def driver():
    total = yield from counter(3)
    print('subgen yielded', total, 'items')

list(driver())

Criando um pipeline

A delegação facilita dividir um pipeline em etapas nomeadas e compô-las.

def source():
    yield from range(5)

def only_odd(src):
    for x in src:
        if x % 2 == 1:
            yield x

def pipeline():
    yield from only_odd(source())

print(list(pipeline()))

Delegando a qualquer iterável

yield from funciona com qualquer iterável, não apenas com geradores: listas, tuplas, conjuntos, cadeias de caracteres, chaves de dicionários e muito mais.

def mixed():
    yield from {1, 2, 3}
    yield from ('a', 'b')

result = list(mixed())
print(sorted(str(x) for x in result))

Mesclando geradores em ordem

Você pode criar um gerador que percorre várias fontes sequencialmente, o que é útil para unir fluxos.

def concat(*iterables):
    for it in iterables:
        yield from it

print(list(concat([1, 2], [3], [4, 5])))

A legibilidade em primeiro lugar

Para dados profundamente aninhados ou semelhantes a árvores, yield from mantém os geradores recursivos curtos e revela claramente sua intenção.

def walk(tree):
    yield tree['name']
    for child in tree.get('children', []):
        yield from walk(child)

tree = {'name': 'root', 'children': [
    {'name': 'a'},
    {'name': 'b', 'children': [{'name': 'c'}]}
]}
print(list(walk(tree)))

Verificação rápida

Teste sua compreensão de yield from.

Recapitulação

Você aprendeu sobre yield from e delegação:

Ele encaminha todos os valores de um iterável interno.
Compõe geradores e permite o achatamento recursivo.
Captura o valor retornado pelo subgerador.
É mais claro do que um laço manual de encaminhamento.

Próximo curso: concorrência com encadeamentos e multiprocessamento.

Perguntas Frequentes

A aula “yield from e delegação” é grátis?

Sim — o texto completo de “yield from e delegação” é 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 “yield from e delegação”?

Componha geradores 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 4 de 4.

Quanto tempo leva a aula “yield from e delegação”?

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