Summary  
This chapter covers using while loops for indefinite iteration by repeatedly executing a code block while a boolean condition remains True, and updating a counter or state variable within the loop to eventually make the condition False and stop the loop.

General domain of usage  
Processing a customer queue at a grocery store checkout

I cicli `while` sono lo strumento principale per gestire l'**iterazione indefinita**, utile in scenari in cui **il numero di iterazioni non è noto in anticipo**, come il monitoraggio dei livelli di inventario **fino a** quando non raggiungono una soglia specifica.

Guarda come Alex dimostra l'utilizzo dei cicli `while` per gestire situazioni dinamiche:

Un ciclo `while` in Python **esegue continuamente un blocco di codice** finché una condizione specificata rimane `True`.

### Sintassi
Per iniziare un ciclo `while`, si definisce una **variabile contatore** e si utilizza la parola chiave `while` seguita da una **condizione booleana**. La condizione è seguita da due punti `:`, che **indicano l'inizio del blocco di codice del ciclo**.

Una sintassi semplice è la seguente:


counter = 1
while counter <= 3:
    print(counter)
    counter += 1

Il ciclo verrà eseguito ripetutamente **finché la condizione non diventa** `False`. Tipicamente, la variabile contatore viene aggiornata **all'interno del ciclo** per far sì che la condizione diventi `False` e interrompere il ciclo.

Considera, ad esempio, questo ciclo `while`:


# Handling a queue at a grocery store checkout
queue_length = 5  # Initial number of people in the queue
while queue_length > 0:  # Start the `while` loop as long as the queue isn't empty
    print(f"Current queue size: {queue_length}")
    
    # Simulate serving a customer
    print("Serving the next customer...")
    
    # Decrease the queue length by 1 as a customer leaves
    # The `-=` operator is a shortcut for `queue_length = queue_length - 1`
    queue_length -= 1

In questo esempio, `queue_length` funge da **variabile contatore**, partendo da `5`. A ogni iterazione del ciclo, il valore di `queue_length` diminuisce di `1` fino a raggiungere `0`. A quel punto, il ciclo termina perché la condizione `0 > 0` risulta `False`.

È fondamentale **aggiornare la variabile contatore all'interno del ciclo** per arrivare a **soddisfare la condizione di uscita dal ciclo**. In caso contrario, il ciclo verrà eseguito **all'infinito**, impedendo l'esecuzione di qualsiasi altro codice.

Nota

import unittest
import importlib
import io
from contextlib import redirect_stdout

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)

def normalize_text(text):
    import re
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

class TestTask(unittest.TestCase):
    def test_stock_reaches_or_exceeds_goal(self):
        import user_code
        importlib.reload(user_code)
        stock = getattr(user_code, 'stock', None)
        restock_goal = getattr(user_code, 'restock_goal', None)
        _dynamic_test(
            self,
            isinstance(stock, int) and isinstance(restock_goal, int) and stock >= restock_goal,
            "Final stock is at least restock_goal",
            f"Expected stock >= restock_goal ({restock_goal}), got {stock}",
        )

    def test_stock_value_correct(self):
        import user_code
        importlib.reload(user_code)
        stock = getattr(user_code, 'stock', None)
        _dynamic_test(
            self,
            stock == 20,
            "Stock is correctly updated to 20",
            f"Expected stock to be 20, got {stock}",
        )

    def test_output_messages(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            normalize_text("Restocking complete!") in output,
            "Output contains 'Restocking complete!' message",
            f"Expected message 'Restocking complete!' not found in output: {output}",
        )
        _dynamic_test(
            self,
            normalize_text("20") in output,
            "Output contains the final stock value (20)",
            f"Expected final stock value '20' not found in output: {output}",
        )


test_main.py

Python è un linguaggio di programmazione di alto livello, interpretato e di uso generale. A differenza di linguaggi come HTML, CSS e JavaScript, principalmente utilizzati nello sviluppo web, Python si distingue per la sua versatilità in molteplici ambiti, tra cui lo sviluppo software, la data science e lo sviluppo back-end. Questo corso ti guiderà attraverso i concetti fondamentali di Python, fornendoti le competenze necessarie per creare le tue funzioni al termine del programma.

In questa sezione, verranno esplorati i fondamenti di Python, familiarizzazione con l'ambiente di lavoro, esecuzione di semplici operazioni matematiche e visualizzazione dei risultati.

In questa sezione scoprirai come salvare elementi come numeri e testo nella memoria del computer e recuperarli tramite un nome. Inoltre, riceverai un'introduzione alla manipolazione del testo in Python.

In questa sezione, esplorerai il tipo di dato booleano e apprenderai come viene utilizzato per sviluppare programmi che reagiscono a determinate condizioni.

In questa sezione continuerai ad approfondire i tipi di dati e scoprirai
come organizzare vari attributi in una singola variabile utilizzando liste, tuple e dizionari.

In questa sezione, apprenderai come creare cicli in Python — una competenza essenziale per iterare su liste, tuple e dizionari.

Per concludere questo corso introduttivo, esplorerai alcune funzioni integrate
e poi inizierai a sviluppare le tue.

Cicli While

Sintassi

Soluzione