Python Academy · Lezione

yield from e delega

Comporre generatori

yield from e delega è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.

Il problema risolto da yield from

Quando un generatore vuole produrre ogni valore di un altro iterabile, può scrivere un ciclo manuale. yield from fa la stessa cosa in una sola riga.

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

print(list(manual()))

Introduzione a yield from

yield from iterable delega a quell'iterabile, producendo a turno ciascuno dei suoi valori. È più breve e chiaro di un ciclo di inoltro.

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

print(list(delegate()))

Combinare più sorgenti

Può concatenare diverse istruzioni yield from per concatenare sequenze in modo lazy.

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

print(list(chained()))

Delegare a un altro generatore

L'iterabile delegato può essere a sua volta un generatore, permettendo di comporre generatori più grandi.

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)))

Appiattire liste annidate

Un uso classico di yield from è l'appiattimento ricorsivo: un generatore che delega a sé stesso per gestire le sottoliste.

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 e un ciclo

Le due versioni seguenti producono lo stesso output. yield from è preferibile per la leggibilità e perché inoltra anche funzionalità avanzate, come l'invio di valori e i risultati restituiti.

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))))

Acquisire il valore restituito da un sottogeneratore

Quando un generatore delegato restituisce un valore con return, yield from restituisce quel valore come risultato dell'espressione. In questo modo i sottogeneratori possono comunicare un risultato.

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())

Costruire una pipeline

La delega facilita la suddivisione di una pipeline in fasi con nomi, che possono poi essere composte.

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()))

Delegare a qualsiasi iterabile

yield from funziona con qualsiasi iterabile, non solo con i generatori: liste, tuple, set, stringhe, chiavi di dizionario e altro ancora.

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

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

Unire i generatori in ordine

Può creare un generatore che attraversa diverse sorgenti in sequenza, una soluzione utile per unire flussi.

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

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

La leggibilità prima di tutto

Per dati profondamente annidati o strutturati ad albero, yield from mantiene brevi i generatori ricorsivi e rende evidente la loro intenzione.

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 rapida

Verifichi la Sua comprensione di yield from.

Riepilogo

Ha imparato a usare yield from e la delega:

Inoltra ogni valore di un iterabile interno.
Permette di comporre generatori e realizzare l'appiattimento ricorsivo.
Acquisisce il valore restituito dal sottogeneratore.
È più chiaro di un ciclo di inoltro manuale.

Prossimo corso: la concorrenza con threading e multiprocessing.

Domande Frequenti

La lezione «yield from e delega» è gratuita?

Sì — il testo completo di «yield from e delega» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.

Cosa imparerò in «yield from e delega»?

Comporre generatori Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «yield from e delega»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Python Academy