Summary  
This chapter covers generator functions that use `yield` to pause and resume execution for memory-efficient, on-the-fly value production and support iteration via `next()` or `for` loops.

General domain of usage  
data stream processing

Una **funzione generatrice** è un tipo speciale di funzione che utilizza la parola chiave `yield` invece di `return` per generare una sequenza di valori. Quando una funzione generatrice viene chiamata, restituisce un oggetto iteratore, che può essere iterato per recuperare i valori uno alla volta.

Definizione

Il principale vantaggio delle funzioni generatrici è la loro **efficienza nella gestione della memoria**. Invece di generare l'intera sequenza in anticipo e memorizzarla in memoria, i generatori producono i valori **al volo** quando sono necessari.

## Come funziona `yield`

A differenza di `return`, che termina completamente la funzione, `yield` **mette in pausa** la funzione e ne salva lo stato. Alla chiamata successiva di `next()`, il generatore riprende esattamente dal punto in cui era stato interrotto:


def count_up(start, stop):
    while start <= stop:
        yield start  # Pause and return the current value
        start += 1   # Resume from here on the next call

counter = count_up(1, 3)

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

È anche possibile iterare su un generatore utilizzando un ciclo `for` – chiama automaticamente `next()` fino a quando il generatore non è esaurito:

def count_up(start, stop):
    while start <= stop:
        yield start
        start += 1

for value in count_up(1, 5):
    print(value)  # 1, 2, 3, 4, 5

Quando un generatore è esaurito (nessun valore da restituire), chiamare `next()` su di esso genererà un errore `StopIteration`. Un ciclo `for` gestisce automaticamente questa situazione.

Nota

import unittest
import re

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 TestEvenNumbers(unittest.TestCase):

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

    def test_even_numbers_correct_values(self):
        import user_code
        try:
            result = list(user_code.even_numbers(1, 10))
            expected = [2, 4, 6, 8, 10]
            condition = result == expected
            failure_message = f"Expected `{expected}`, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, f"The `even_numbers` generator yields `[2, 4, 6, 8, 10]` for range 1 to 10.", failure_message)

    def test_even_numbers_no_odd_values(self):
        import user_code
        try:
            result = list(user_code.even_numbers(1, 10))
            condition = all(n % 2 == 0 for n in result)
            failure_message = f"Expected only even numbers, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, "The `even_numbers` generator yields only even numbers.", failure_message)

    def test_even_numbers_different_range(self):
        import user_code
        try:
            result = list(user_code.even_numbers(5, 20))
            expected = [6, 8, 10, 12, 14, 16, 18, 20]
            condition = result == expected
            failure_message = f"Expected `{expected}` for range 5 to 20, but got `{result}`."
        except AttributeError:
            condition = False
            failure_message = "The function `even_numbers` is not defined."
        _dynamic_test(self, condition, f"The `even_numbers` generator correctly handles the range 5 to 20.", failure_message)

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

test_main.py

Acquisire una solida comprensione di come le funzioni modellano la programmazione in Python. Padroneggiare la definizione e la chiamata delle funzioni, la gestione degli argomenti, il trattamento dei valori di ritorno e la creazione di codice flessibile ed efficiente utilizzando ricorsione ed espressioni lambda.

Esplora cosa sono le funzioni e perché sono essenziali in Python. Scopri come creare funzioni, definire argomenti, gestire i valori di ritorno e utilizzare efficacemente le funzioni integrate.

Scopri come funzionano gli argomenti posizionali e opzionali in Python. Sviluppo di funzioni adattabili che gestiscono diversi input e migliorano la flessibilità del codice.

Comprendere come lavorare con argomenti arbitrari e keyword per gestire dimensioni di input variabili. Apprendere come queste tecniche rendano le funzioni più dinamiche e organizzate.

Scopri come i valori di ritorno rappresentano l'output di una funzione. Impara a restituire valori singoli o multipli, utilizzare None ed esplorare i generatori per un controllo più avanzato del flusso dei dati.

Sblocca concetti avanzati sulle funzioni con la ricorsione e le funzioni lambda. Scopri come la ricorsione risolve problemi ripetitivi e come le espressioni lambda creano funzioni concise in una sola riga.

Funzioni Generatrici

Come funziona `yield`

Soluzione

Funzioni Generatrici

Come funziona yield

Soluzione

Come funziona `yield`