Cos'è un errore logico?

Tre voti, 80, 90 e 100, hanno una media di 90. Questo programma viene eseguito senza una sola lamentela e stampa qualcos'altro:

scores = [80, 90, 100]
average = scores[0] + scores[1] + scores[2] / 3
print("Average:", average)

Average: 203.33333333333334

Python ha fatto esattamente ciò che dice la riga. La divisione avviene prima dell'addizione, quindi solo l'ultimo voto è stato diviso per 3, e il risultato è 80 + 90 + 33,33. Chi l'ha scritto intendeva (scores[0] + scores[1] + scores[2]) / 3. Aggiungi le parentesi e il programma stampa Average: 90.0.

Perché non compare alcun messaggio di errore

Un computer controlla se il codice è valido, non se è corretto. Il parser controlla la grammatica, e così scopre un errore di sintassi. Il runtime controlla ogni operazione, e così scopre un errore di runtime come la divisione per zero. Sommare tre numeri e dividerne uno per 3 è grammatica valida e un'operazione lecita, quindi entrambi i controlli vengono superati.

Solo chi ha scritto il programma sa che doveva calcolare una media. Quell'intenzione non esiste da nessuna parte nel codice, quindi nessuno strumento può confrontarci il risultato. Un errore logico è la distanza tra ciò che hai detto al computer di fare e ciò che volevi che facesse.

Cause comuni degli errori logici

La maggior parte degli errori logici viene da un breve elenco di schemi.

• Errori di uno (off-by-one). Un ciclo gira una volta di troppo o di meno. range(1, 5) produce 1, 2, 3 e 4, perché la fine è esclusa. Vedi iterazione.
• Precedenza degli operatori. a + b / 2 divide solo b, come nella media qui sopra.
• Il confronto sbagliato. < dove serviva <=, oppure and dove serviva or. Le condizioni sono espressioni booleane, e un operatore sbagliato capovolge il risultato per alcuni input.
• Condizioni nell'ordine sbagliato. In una catena di if ed elif vince la prima condizione vera, quindi un test generico messo per primo nasconde quelli più specifici sotto di esso.
• La variabile sbagliata. Aggiornare total dentro un ciclo ma stampare subtotal.
• Supposizioni sui numeri. 0.1 + 0.2 == 0.3 è False in Python, Java e JavaScript, perché i numeri in virgola mobile sono approssimazioni. 7 // 2 fa 3, non 3,5.

Ecco l'errore sull'ordine delle condizioni. Un punteggio di 95 dovrebbe essere una A:

def grade(score):
    if score >= 60:
        return "D"
    elif score >= 90:
        return "A"
    else:
        return "F"

print(grade(95))
print(grade(72))
print(grade(40))

D
D
F

95 è maggiore o uguale a 60, quindi vince il primo ramo e l'elif non viene mai raggiunto. Metti per prima la soglia più alta e ogni risultato diventa giusto.

Tipi di errori in programmazione

Gli errori di programmazione di solito si dividono in tre tipi in base a quando compaiono e a cosa li segnala.

Alcuni libri di testo elencano più tipi, e la maggior parte rientra in questi tre. Un errore di tipo che il compilatore Java rifiuta, come incompatible types: String cannot be converted to int, viene trovato in fase di compilazione come un errore di sintassi, e alcuni libri lo chiamano errore semantico. Un errore del linker avviene nell'ultima fase della costruzione di un programma C o C++, quando una funzione è stata dichiarata ma il suo codice non si trova da nessuna parte. Gli errori aritmetici, di risorse e di file, come dividere per zero, esaurire la memoria o aprire un file che non c'è, sono tutti errori di runtime. Alcuni corsi usano "errore semantico" anche come altro nome dell'errore logico, quindi controlla quale significato usa il tuo libro di testo.

Come trovare un errore logico

1. Testa con una risposta che conosci già. Calcola a mano il risultato corretto per un input piccolo, poi confronta. Tre voti sono più facili da controllare di tremila.
2. Stampa i valori intermedi. Stampare score e il ramo scelto, o il contatore del ciclo a ogni passaggio, mostra il passo esatto in cui la realtà si allontana dal tuo piano.
3. Procedi passo passo con un debugger. Impostare un breakpoint ed eseguire una riga alla volta fa la stessa cosa senza modificare il codice.
4. Testa i casi limite. Prova 0, 1, il valore più grande, una lista vuota e la soglia esatta (60 e 90 nell'esempio dei voti).
5. Spiega il codice ad alta voce. Descrivere ogni riga a qualcun altro, o a una paperella di gomma, ti costringe a dire cosa fa davvero la riga invece di cosa pensi che faccia.

Un assert trasforma una risposta nota in un controllo automatico. Non fa niente quando la condizione è vera e ferma il programma quando è falsa:

def grade(score):
    if score >= 60:
        return "D"
    elif score >= 90:
        return "A"
    else:
        return "F"

assert grade(40) == "F"
assert grade(95) == "A", "95 should be an A"
print("all tests passed")

Traceback (most recent call last):
  File "main.py", line 10, in <module>
    assert grade(95) == "A", "95 should be an A"
           ^^^^^^^^^^^^^^^^
AssertionError: 95 should be an A

Un test che fallisce trasforma un errore logico silenzioso in uno rumoroso con un numero di riga. È tutta qui l'idea dei test unitari.

Errori logici in altri linguaggi

Gli schemi sono gli stessi ovunque, ma ogni linguaggio ha le sue trappole. In JavaScript, "5" + 3 è la stringa "53", mentre "5" - 3 è il numero 2, quindi un valore letto da un modulo come testo può sommarsi in modo sbagliato senza alcun errore. In C, if (x = 5) assegna 5 a x ed è sempre vero. Clang lo segnala con un avviso per impostazione predefinita (using the result of an assignment as a condition without parentheses), ma il codice compila e gira comunque, quindi prendi gli avvisi del compilatore sul serio quanto gli errori.

Cosa leggere dopo

Confronta questa pagina con le pagine sull'errore di sintassi e sull'errore di runtime per vedere come viene segnalato ogni tipo. I cicli sono il posto dove vivono gli errori di uno, quindi la pagina sull'iterazione e la guida Python ai cicli for sono buone letture successive. Per esercitarti a trovare risultati sbagliati con esercizi reali, prova il corso Python.