Introduzione
In Python, le istruzioni if, elif (contrazione di «else and if») ed else servono a controllare il flusso di esecuzione e a prendere decisioni all'interno di un programma.
A differenza di molti altri linguaggi di programmazione, nelle versioni di Python dalla 3.9 in giù non esiste un'istruzione formale di tipo case-switch: al suo posto si usano più istruzioni elif per ottenere uno scopo simile.
Python 3.10 introduce una variante dell'istruzione case-switch chiamata structural pattern matching, che verrà trattata separatamente in un altro concetto.
Le istruzioni condizionali usano espressioni che devono dare come risultato True o False, restituendo direttamente un tipo bool oppure valutandosi come «truthy» o «falsy».
x = 10
y = 5
# The comparison '>' returns the bool 'True',
# so the statement is printed.
if x > y:
print("x is greater than y")
...
>>> x is greater than y
Quando è abbinato a if, un blocco di codice else opzionale viene eseguito quando la condizione if originale dà False:
x = 5
y = 10
# The comparison '>' here returns the bool 'False',
# so the 'else' block is executed instead of the 'if' block.
if x > y:
print("x is greater than y")
else:
print("y is greater than x")
...
>>> y is greater than x
elif permette di avere più valutazioni o più rami.
x = 5
y = 10
z = 20
# The 'elif' statement allows for the checking of more conditions.
if x > y:
print("x is greater than y and z")
elif y > z:
print("y is greater than x and z")
else:
print("z is greater than x and y")
...
>>> z is greater than x and y
Le operazioni booleane e i confronti si possono combinare con i condizionali per eseguire verifiche più complesse:
>>> def classic_fizzbuzz(number):
if number % 3 == 0 and number % 5 == 0:
say = 'FizzBuzz!'
elif number % 5 == 0:
say = 'Buzz!'
elif number % 3 == 0:
say = 'Fizz!'
else:
say = str(number)
return say
>>> classic_fizzbuzz(15)
'FizzBuzz!'
>>> classic_fizzbuzz(13)
'13'
Istruzioni
In questo esercizio, svilupperemo un semplice sistema di controllo per un reattore nucleare.
Perché un reattore produca energia, deve trovarsi in uno stato di criticità.
Se il reattore si trova in uno stato al di sotto della criticità, può danneggiarsi.
Se lo stato del reattore supera la criticità, può sovraccaricarsi e causare una fusione del nocciolo.
Vogliamo ridurre le probabilità di una fusione del nocciolo e gestire correttamente lo stato del reattore.
I tre compiti seguenti riguardano tutti la scrittura di codice per mantenere lo stato ideale del reattore.
1. Verificare la criticità
La prima cosa che un sistema di controllo deve fare è verificare se il reattore è bilanciato in criticità.
Si dice che un reattore è bilanciato in criticità se soddisfa le seguenti condizioni:
- La temperatura è inferiore a 800 K.
- Il numero di neutroni emessi al secondo è maggiore di 500.
- Il prodotto tra la temperatura e i neutroni emessi al secondo è inferiore a 500000.
Implementa la funzione is_criticality_balanced() che prende come parametri temperature, misurata in kelvin, e neutrons_emitted, e restituisce True se le condizioni di criticità sono soddisfatte, False altrimenti.
>>> is_criticality_balanced(750, 600)
True
2. Determinare l'intervallo di potenza erogata
Una volta che il reattore ha iniziato a produrre energia, bisogna determinarne l'efficienza.
L'efficienza può essere raggruppata in 4 fasce:
-
green -> efficienza pari o superiore all'80%,
-
orange -> efficienza inferiore all'80% ma almeno pari al 60%,
-
red -> efficienza inferiore al 60%, ma comunque pari o superiore al 30%,
-
black -> efficienza inferiore al 30%.
Il valore percentuale può essere calcolato come (generated_power/theoretical_max_power)*100, dove generated_power = voltage * current.
Nota che il valore percentuale di solito non è un numero intero, quindi assicurati di usare correttamente i confronti < e <=.
Implementa la funzione reactor_efficiency(<voltage>, <current>, <theoretical_max_power>), con tre parametri: voltage,
current e theoretical_max_power.
Questa funzione dovrebbe restituire la fascia di efficienza del reattore: 'green', 'orange', 'red' oppure 'black'.
>>> reactor_efficiency(200,50,15000)
'orange'
3. Meccanismo fail-safe
L'ultimo compito consiste nel creare un meccanismo fail-safe per evitare sovraccarichi e fusioni del nocciolo.
Questo meccanismo determinerà se il reattore è al di sotto, in corrispondenza o al di sopra della soglia di criticità ideale.
La criticità può quindi essere aumentata, diminuita o arrestata inserendo (o rimuovendo) le barre di controllo nel reattore.
Implementa la funzione chiamata fail_safe(), che prende 3 parametri: temperature, misurata in kelvin,
neutrons_produced_per_second e threshold, e restituisce un codice di stato per il reattore.
-
Se temperature * neutrons_produced_per_second < 90% di threshold, restituisci un codice di stato 'LOW',
che indica che le barre di controllo devono essere rimosse per produrre energia.
-
Se il valore temperature * neutrons_produced_per_second rientra nel 10% di threshold (quindi è inferiore alla soglia di 0-10%, è uguale alla soglia, oppure è superiore alla soglia di 0-10%), il reattore è in criticità e va restituito il codice di stato 'NORMAL', che indica che il reattore è in condizioni ottimali e che le barre di controllo sono in posizione ideale.
-
Se temperature * neutrons_produced_per_second non rientra negli intervalli sopra indicati, il reattore sta
andando incontro a una fusione del nocciolo e si deve restituire un codice di stato 'DANGER' per spegnere immediatamente il reattore.
>>> fail_safe(temperature=1000, neutrons_produced_per_second=30, threshold=5000)
'DANGER'
Esercizio di apprendimento
