<jupyter_start><jupyter_text>Condizionali - if else [Scarica zip esercizi](../_static/generated/control-flow.zip)[Naviga file online](https://github.com/DavidLeoni/softpython-it/tree/master/control-flow)Possiamo usare il comando condizionale `if` ogni volta che il computer deve prendere una decisione in base al valore di qualche condizione. Se la condizione viene valutata come vera (cioè come il booleano `True`) allora verrà eseguito un blocco di codice, altrimenti ne verrà eseguito un altro. **Riferimenti**: * [SoftPython - Basi - booleani](https://it.softpython.org/basics/basics-sol.htmlBooleani) Che fare- scompatta lo zip in una cartella, dovresti ottenere qualcosa del genere: ```control-flow    flow1-if.ipynb    flow1-if-sol.ipynb    flow2-for.ipynb    flow2-for-sol.ipynb    flow3-while.ipynb    flow3-while-sol.ipynb        jupman.py    ```**ATTENZIONE**: Per essere visualizzato correttamente, il file del notebook DEVE essere nella cartella szippata.- apri il Jupyter Notebook da quella cartella. Due cose dovrebbero aprirsi, prima una console e poi un browser. Il browser dovrebbe mostrare una lista di file: naviga la lista e apri il notebook `flow1-if.ipynb`- Prosegui leggendo il file degli esercizi, ogni tanto al suo interno troverai delle scritte **ESERCIZIO**, che ti chiederanno di scrivere dei comandi Python nelle celle successive. Gli esercizi sono graduati per difficoltà, da una stellina ✪ a quattro ✪✪✪✪Scorciatoie da tastiera:* Per eseguire il codice Python dentro una cella di Jupyter, premi `Control+Invio`* Per eseguire il codice Python dentro una cella di Jupyter E selezionare la cella seguente, premi `Shift+Invio`* Per eseguire il codice Python dentro una cella di Jupyter E creare una nuova cella subito dopo, premi `Alt+Invio`* Se per caso il Notebook sembra inchiodato, prova a selezionare `Kernel -> Restart`  Il comando base `if else`Vediamo un programmino che prende decisioni diverse in base al valore di una variabile `caramelle`:<jupyter_code>caramelle = 20

if caramelle > 10 :  
    print('Abbiamo trovato...')
    print('Tante caramelle!')    
else:
    print("Purtroppo ci sono.. ")
    print('Poche caramelle!')
    
print()
print('Cerchiamo altri dolci!')<jupyter_output>Abbiamo trovato...
Tante caramelle!

Cerchiamo altri dolci!<jupyter_text>La condizione qui è `caramelle > 10`<jupyter_code>caramelle > 10<jupyter_output><empty_output><jupyter_text>**ATTENZIONE: Subito dopo la condizione vanno messi due punti** `:````pythonif caramelle > 10:``` Dato che nell'esempio sopra `caramelle` vale `20`, la condizione è valutata a `True` e viene quindi eseguito il blocco di codice subito dopo la riga con l'`if`.Proviamo invece a mettere un numero piccolo, come `caramelle = 5`:<jupyter_code>caramelle = 5

if caramelle > 10 :    
    print('Abbiamo trovato...')
    print('Tante caramelle!')    
else:
    print("Purtroppo ci sono.. ")
    print('Poche caramelle!')
    
print()
print('Cerchiamo altri dolci!')<jupyter_output>Purtroppo ci sono.. 
Poche caramelle!

Cerchiamo altri dolci!<jupyter_text>In questo caso è stato eseguito il blocco di codice dopo la riga con `else:`     **ATTENZIONE all'indentazione nei blocchi !**Come tutti i blocchi di codice in Python, sono preceduti da spazi. Di solito si usano 4 spazi (in qualche progetto Python puoi trovarne solo 2, ma è sconsigliato dalle linee guida di Python)  `else` è opzionaleNon è obbligatorio indicare l'`else`. Se lo omettiamo e la condizione risulta `False`, il controllo passa direttamente ai comandi allo stesso livello di indentazione dell'`if` (senza errori):<jupyter_code>caramelle = 5

if caramelle > 10 :  
    print('Abbiamo trovato...')
    print('Tante caramelle!')    

print()
print('Cerchiamo altri dolci!')<jupyter_output>Cerchiamo altri dolci!<jupyter_text>**DOMANDA**: Guarda i seguenti frammenti di codice, e per ciascuno cerca di indovinare quale risultato produce (o se da errore):1.  ```python    x = 3    if x > 2  and if x < 4:        print('ABBA')    ```1.  ```python    x = 3    if x > 2 and x < 4        print('ABBA')    ```1.  ```python    x = 3    if x > 2 and x < 4:        print('ABBA')    ```1.  ```python    x = 2    if x > 1:        print(x+1, x):    ```1.  ```python    x = 3    if x > 5 or x:        print('ACDC')    ```1.  ```python    x = 7    if x == 7:    print('GLAM')    ```1.  ```python    x = 7    if x < 1:        print('BIM')    else:        print('BUM')    print('BAM')    ```1.  ```python    x = 30    if x > 8:        print('DOH')    if x > 10:        print('DUFF')    if x > 20:        print('BURP')    ``` 1.  ```python    if not True:        print('sottosopra')    else:        print('soprasotto')    ```1.  ```python    if False:    else:        print('ZORB')    ```1.  ```python    if False:        pass    else:        print('ZORB')    ```1.  ```python    if 0:        print('Brandy')    else:        print('Rum')    ```1.  ```python    if False:        print('illustrissimo')    else:        print('esimio')    else:        print('dottore')    ```1.  ```python        if 2 != 2:        'ATTENTO'    else:        'STOLTO'    ```1.  ```python    if 2 != 2:        print('ATTENTO')    else:        print('STOLTO')    ```    1.  ```python    x = [1,2,3]    if 4 in x:        x.append(4)    else:        x.remove(3)    print(x)    ```    1.  ```python    if 'False':           print('OCCHIO ALLA STRINGA')    else:        print('CRUDELE')    ```  Esercizio - senza benzaSi vuole fare un viaggio in auto e servono almeno `30` litri. Scrivi del codice che:* se la variabile `benzina` è inferiore a `30`,  stampa `'Senza benza, faccio il pieno'` e  incrementa `benzina` di `20` litri* Altrimenti, stampa `Ho abbastanza carburante!`* In ogni caso, alla fine stampa `'Si parte con '` seguito dall dalla quantità di benzina finale.<jupyter_code>benzina = 5
#benzina = 30

# scrivi qui

if benzina < 30:
    print('Senza benza, faccio il pieno')
    benzina += 20
else:
    print('Ho abbastanza carburante')
    
print('Si parte con', benzina, 'litri')<jupyter_output>Senza benza, faccio il pieno
Si parte con 25 litri<jupyter_text>Il comando *if - elif - else*Esaminando il programmino delle caramelle di prima ti sarai forse chiesto cosa stampare quando non ci sono proprio caramelle. Per farlo, potremmo usare più _condizioni in cascata_ con il comando `elif` (abbreviazione di _else if_):<jupyter_code>caramelle = 0  # METTIAMO ZERO

if caramelle > 10:
    print('Abbiamo trovato...')
    print('Tante caramelle!')
elif caramelle > 0:
    print("Purtroppo ci sono.. ")
    print('Poche caramelle!')    
else:
    print("Che sfortuna! ")
    print('Non ci sono caramelle!')    

print()
print('Cerchiamo altri dolci!')<jupyter_output>Che sfortuna! 
Non ci sono caramelle!

Cerchiamo altri dolci!<jupyter_text>**ESERCIZIO**: Prova a cambiare i valori di `caramelle` nella cella qua sopra e guarda cosa succede Il programmino si comporta esattamente come i precedenti e quando nessuna condizione è soddisfatta viene eseguito l'ultimo blocco di codice dopo l'`else:`Possiamo aggiungere quanti `elif` vogliamo, quindi potremmo essere ancora più specifici e mettere un `elif x == 0:` e nell'`else` gestire tutti gli altri casi, anche quelli imprevisti o assurdi come per esempio un numero di caramelle negativo. Perchè mai dovremmo farlo? Gli imprevisti possono sempre succedere, ne avrai trovati in giro di programmi _buggati_ ... (vedremo meglio come gestire queste situazioni nel tutorial [Gestione errori e testing](https://it.softpython.org/errors-and-testing/errors-and-testing-sol.html))<jupyter_code>caramelle = -2   # PROVIAMO UN NUMERO NEGATIVO

if caramelle > 10:
    print('Abbiamo trovato...')
    print('Tante caramelle!')
elif caramelle > 0:
    print("Purtroppo ci sono.. ")
    print('Poche caramelle!')    
elif caramelle == 0:
    print("Che sfortuna! ")
    print('Non ci sono caramelle!') 
else:
    print('Qualcosa è andato MOLTO storto! Abbiamo trovato', caramelle, 'caramelle')
    
print()
print('Cerchiamo altri dolci!')<jupyter_output>Qualcosa è andato MOLTO storto! Abbiamo trovato -2 caramelle

Cerchiamo altri dolci!<jupyter_text>**ESERCIZIO**: Prova a cambiare i valori di `caramelle` nella cella qua sopra e guarda cosa succede  DomandeGuarda i seguenti frammenti di codice, e per ciascuno cerca di indovinare quale risultato produce (o se da errore):1.  ```python    y = 2    if y < 3:        print('bingo')    elif y <= 2:        print('bango')    ```1.  ```python    z = 'q'    if not 'quando'.startswith(z):        print('BAR')    elif not 'spqr'[2] == z:        print('WAR')    else:        print('ZAR')    ```1.  ```python    x = 1    if x < 5:        print('BARCHE')        elif x < 3:            print('ZATTERE')            else:                 print('SCIALUPPE')    ```1.  ```python    x = 5    if x < 3:        print('ORO')    else if x >= 3:        print('ARGENTO')    ```1.  ```python    if 0:        print(0)    elif 1:        print(1)    ```  Domande - Sono equivalenti? Guarda i seguenti frammenti di codice: in ciascuno, vi sono due parti, A e B. In ciascun frammento, cerca di indovinare se la parte A stamperà esattamente quello che stampa il codice nella parte B, per ogni valore delle variabili da cui dipendono.* **PRIMA** pensa alla risposta* **POI** prova ad eseguire con ciascuno dei valori delle  variabili suggerite  Sono equivalenti? - fragoleProva a cambiare il valore di `fragole` togliendo i commenti<jupyter_code>fragole = 5
#fragole = 2
#fragole = 10

print('fragole =', fragole)
print('A:')
if fragole > 5:
    print("Le fragole sono > 5")
elif fragole > 5: 
    print("Ho detto che le fragole sono > 5!")
else:
    print("Le fragole sono <= 5")
    
print('B:')
if fragole > 5:
    print("Le fragole sono > 5")
if fragole > 5:
    print("Ho detto che le fragole sono > 5!")
if fragole <= 5:
    print("Le fragole sono <= 5")<jupyter_output>fragole = 5
A:
Le fragole sono <= 5
B:
Le fragole sono <= 5<jupyter_text>Sono equivalenti? - max```pythonx, y = 3, 5x, y = 5, 3x, y = 3, 3print('x =', x)print('y =', y)print('A:')if x > y:    print(x)else:    print(y)    print('B:')    print(max(x,y))```  Sono equivalenti?  - min```pythonx, y = 3, 5x, y = 5, 3x, y = 3, 3print('x =',x)print('y =', y)print('A:')if x < y:    print(y)else:    print(x)    print('B:')    print(min(x,y))```  Sono equivalenti?  - grande piccolo```pythonx = 2x = 4x = 3print('x =',x)print('A:')if x > 3:    print('grande')else:    print('piccolo')    print('B:')if x < 3:    print('piccolo')else:    print('grande') ```  Sono equivalenti?  - Cippirillo```pythonx = 3x = 10x = 11x = 15print('x =', x)print('A:')if x % 5 == 0:       print('cippirillo')if x % 3 == 0:       print('cippirillo')    print('B:')if x % 3 == 0 or x % 5 == 0:    print('cippirillo')```  Esercizio - fattoriaData una stringa `s`, scrivi del codice che stampa `'BAU!'` se la stringa inizia con `cane` , stampa `'CHICCHIRICHI!'` se le stringa inizia con `'gallo'`, e stampa `'???'` in tutti gli altri casi<jupyter_code>s = 'cane dalmata'
#s = 'gallo cedrone'
#s = 'sghirimpo'

print(s)

# scrivi qui

if s.startswith('cane'):
    print('BAU')
elif s.startswith('gallo'):
    print('CHICCHIRICHI!')
else:
    print('???')<jupyter_output>cane dalmata
BAU<jupyter_text>Esercizio - accentiScrivi del codice che stampa se una `parola` termina o meno con una lettera accentata. * Per determinare se una lettera è accentata, usa le stringhe di accenti `acuti` e `gravi`* il tuo codice deve funzionare con qualunque `parola`<jupyter_code>acuti = "áéíóú"
gravi = "àèìòù"

parola = 'urrà'         # termina con una accentata
#parola = 'martello'    # non termina con una accentata
#parola = 'ahó'         # termina con una accentata
#parola = 'però'        # termina con una accentata
#parola = 'capitaneria' # non termina con una accentata
#parola = 'viceré'      # termina con una accentata
#parola = 'cioè'        # termina con una accentata
#parola = 'chéto'       # non termina con una accentata
#parola = 'Chi dice che la verità è una sòla?'  # non termina con una accentata

# scrivi qui

if parola[-1] in acuti or parola[-1] in gravi:
    print(parola,'termina con una accentata!')
else:
    print(parola, 'non termina con una accentata')<jupyter_output>urrà termina con una accentata!<jupyter_text>Esercizio - arcaniDato un arcano `x` espresso come una stringa e delle liste di arcani `maggiori` e `minori`, stampare a quale categoria appartiene `x`. Se `x` non appartiene a nessuna categoria, stampare `è un mistero`.<jupyter_code>x = 'La Ruota'     # maggiore
#x = "L'Appeso"       # maggiore
#x = 'Asso di Spade'  # minore
#x = 'Due di Denari'  # minore
#x = 'Il Coding'      # mistero

maggiori = ['La Ruota','Il Carro', "L'Appeso"]
minori = ['Asso di Spade', 'Due di Denari', 'Regina di Coppe']

# scrivi qui
if x in maggiori:
    print(x, 'è un Arcano maggiore')
elif x in minori:
    print(x, 'è un Arcano minore')
else:
    print(x, 'è un mistero')<jupyter_output>La Ruota è un Arcano maggiore<jupyter_text>`if` annidatiI comandi `if` sono _blocchi_ perciò possono essere annidati come qualunque altro blocco.Facciamo un esempio. Se hai un punto con coordinate `x` e `y` e vuoi sapere in quale quadrante risiede:![quadrant iu34234](img/quadrant.png)Potresti scrivere qualcosa del genere:<jupyter_code>x,y = 5,9     
#x,y = -5,9   
#x,y = -5,-9  
#x,y = 5,-9

print('x =',x,'y =', y)

if x >= 0:
    if y >= 0:
        print('primo quadrante')
    else:
        print('quarto quadrante')
else:
    if y >= 0:
        print('secondo quadrante')
    else:
        print('terzo quadrante')<jupyter_output>x = 5 y = 9
primo quadrante<jupyter_text>**ESERCIZIO**: prova le varie coppie di punti suggeriti togliendo i commenti e convinciti che il codice funziona come atteso. **NOTA**: A volte gli `if` annidati possono essere evitati scrivendo sequenze di `elif` con espressioni booleane che verificano due condizioni alla volta:<jupyter_code>x,y = 5,9     
#x,y = -5,9   
#x,y = -5,-9  
#x,y = 5,-9

print('x =',x,'y =', y)

if x >= 0 and y >= 0:
    print('primo quadrante')
elif x >= 0 and y < 0:
    print('quarto quadrante')
elif x < 0 and y >= 0:
    print('secondo quadrante')
elif x < 0 and y < 0:
    print('terzo quadrante')<jupyter_output>x = 5 y = 9
primo quadrante<jupyter_text>Esercizio - ascisse e ordinate 1Il codice che abbiamo visto non è molto preciso, perchè non considera il caso di punti che giacciono sugli assi. In questi casi invece del numero del quadrante dovrebbe stampare:* 'origine' quando `x` e `y` sono uguali a `0`* 'ascissa' quando `y` è `0`* 'ordinata' quando `x` è `0`Scrivi qui sotto una versione modificata **del codice con if annidati**  che consideri anche questi casi, poi testalo togliendo i commenti alle varie coppie di coordinate suggerite.<jupyter_code>x,y = 0,0     # origine
#x,y = 0,5    # ordinata
#x,y = 5,0    # ascissa
#x,y = 5,9    # primo
#x,y = -5,9   # secondo
#x,y = -5,-9  # terzo
#x,y = 5,-9   # quarto


print('x =',x,'y =', y)

# scrivi qui

if x == 0 and y == 0:
    print('origine')
elif x == 0:
    print('ordinata')
elif x > 0:
    if y == 0:
        print('ascissa')
    elif y > 0:
        print('primo quadrante')
    else:
        print('quarto quadrante')
else:
    if y == 0:
        print('ascissa')
    elif y > 0:
        print('secondo quadrante')
    else:
        print('terzo quadrante')<jupyter_output>x = 0 y = 0
origine<jupyter_text>Esercizio - ascisse e ordinate 2Volendo essere ancora più specifici, invece che stampare genericamente 'ascissa' o 'ordinata', potremmo stampare:* 'ascissa tra il primo e quarto quadrante'* 'ascissa tra il secondo e terzo quadrante'* 'ordinata tra il primo e il secondo quadrante'* 'ordinata tra il terzo e il quarto quadrante'Copia qui sotto  il codice dell'esercizio precedente modificandolo per considerare anche questi casi.<jupyter_code>x,y = 0,0     # origine
#x,y = 0,5    # ordinata tra il primo e il secondo quadrante
#x,y = 0,-5   # ordinata tra il terzo e il quarto quadrante
#x,y = 5,0    # ascissa tra il primo e il quarto quadrante
#x,y = -5,0   # ascissa tra il secondo e il terzo quadrante
#x,y = 5,9    # primo
#x,y = -5,9   # secondo
#x,y = -5,-9  # terzo
#x,y = 5,-9   # quarto

print('x =',x,'y =', y)

# scrivi qui

if x == 0 and y == 0:
    print('origine')
elif x == 0:
    if y > 0:
        print('ordinata tra il primo e il secondo quadrante')
    else:
        print('ordinata tra il terzo e il quarto quadrante')
elif x > 0:
    if y == 0:        
        print('ascissa tra il primo e il quarto quadrante')        
    elif y > 0:
        print('primo quadrante')
    else:
        print('quarto quadrante')
else:
    if y == 0:        
        print('ascissa tra il secondo e il terzo quadrante')        
    elif y > 0:
        print('secondo quadrante')
    else:
        print('terzo quadrante')<jupyter_output>x = 0 y = 0
origine<jupyter_text>Esercizio - autobusDevi correre a prendere l'autobus, e hai poco tempo. Per fare il viaggio:* ti serve lo zaino, altrimenti resti a casa* ti servono anche dei soldi per il biglietto, oppure la tessera trasporti (o tutte due). Altrimenti resti a casa.Scrivi del codice che date tre variabili booleane `zaino`, `soldi` e `tessera`, stampa quello che vedi nei commenti a seconda dei vari casi. Una volta scritto il codice, togli i commenti alle assegnazioni per provare i risultati* **SUGGERIMENTO**: per tener traccia degli oggetti posseduti, ti conviene creare una lista di stringhe dove mettere gli oggetti trovati<jupyter_code>zaino, soldi, tessera = True, False, True
# Non ho i soldi !
# Ho trovato: zaino,tessera
# Posso partire !

#zaino, soldi, tessera = False, False, True
# Non ho lo zaino, non posso partire !

#zaino, soldi, tessera = True, True, False
# Non ho la tessera !
# Ho trovato: zaino,soldi
# Posso partire !

#zaino, soldi, tessera = True, True, True
# Ho trovato: zaino,soldi,tessera
# Posso partire !

zaino, soldi, tessera = True, False, False
#Non ho i soldi !
#Non ho la tessera !
#Non ho la tessera nè i soldi, non posso partire !


# scrivi qui

trovato = []
if zaino:
    trovato.append('zaino')
    if soldi: 
        trovato.append('soldi')
    else:        
        print('Non ho i soldi !')
    if tessera:
        trovato.append('tessera')
    else:
        print('Non ho la tessera !')
    if soldi or tessera:
        print('Ho trovato:', ','.join(trovato))
        print('Posso partire !')
    else:
        print('Non ho la tessera nè i soldi, non posso partire !')
else:
    print('Non ho lo zaino, non posso partire !')<jupyter_output>Non ho i soldi !
Non ho la tessera !
Non ho la tessera nè i soldi, non posso partire !<jupyter_text>Esercizio - cronometroUn cronometro segna le ore, minuti e secondi trascorsi dalla mezzanotte di un certo giorno in una stringa `cronometro`, in cui i numeri delle ore, minuti e secondi sono separati da due punti `:`. Scrivi del codice che in base al numero di ore trascorse, stampa la fase del giorno:- dalle ore 6 incluse alle ore 12 escluse  : stampa `mattino`- dalle ore 12 incluse alle ore 18 escluse  : stampa `pomeriggio`- dalle ore 18 incluse alle ore 21 escluse  : stampa `sera`- dalle ore 21 incluse alle ore 6 escluse  : stampa `notte`* **USA** `elif` con espressioni booleane multiple* Il tuo codice **DEVE** funzionare anche se il cronometro supera le 23:59:59, vedi esempi* **SUGGERIMENTO**: per avere ore che vadano solo dalle 0 alle 23, usa l'operatore modulo `%`<jupyter_code>cronometro = '10:23:43'   # mattina
#cronometro = '12:00:00'   # pomeriggio
#cronometro = '15:56:02'   # pomeriggio
#cronometro = '19:23:27'   # sera
#cronometro = '21:45:15'   # notte
#cronometro = '02:45:15'   # notte
#cronometro = '27:45:30'   # notte
#cronometro = '32:28:30'   # mattina

# scrivi qui

ora = int(cronometro.split(':')[0]) % 24

if ora >= 6 and ora < 12:
    print('mattina')
elif ora >=12 and ora < 18:
    print('pomeriggio')
elif ora >=18 and ora < 21:
    print('sera')
else:
    print('notte')<jupyter_output>mattina<jupyter_text>Domande - Sono equivalenti? Guarda i seguenti frammenti di codice: in ciascuno, vi sono due parti, A e B. In ciascun frammento, cerca di indovinare se la parte A stamperà esattamente quello che stampa il codice nella parte B, per ogni valore di `x`.* **PRIMA** pensa alla risposta* **POI** prova ad eseguire con ciascuno dei valori di `x` suggeriti.   Sono equivalenti?  - dentro fuori 1```pythonx = 3x = 4x = 5print('x =',x)print('A:')if x > 3:    if x < 5:        print('dentro')    else:        print('fuori')else:    print('fuori')                print('B:')if x > 3 and x < 5:    print('dentro')else:    print('fuori')```  Sono equivalenti?  - stelle pianeti```pythonx = 2x = 3x = 4print('x =', x)print('A:')if not x > 3:    print('stelle')else:    print('pianeti')    print('B:')if x > 3:    print('pianeti')else:    print('stelle')```  Sono equivalenti?  - verde rosso```pythonx = 10x = 5x = 0print('x =',x)print('A:')if x >= 5:     print('verde')    if x >= 10:        print('rosso')            print('B:')if x >= 10:    if x >= 5:        print('verde')    print('rosso')```      Sono equivalenti? - cerchi quadrati```pythonx = 4x = 3x = 2x = 1x = 0print('x =', x)print('A:')if x > 3:    print('cerchi')else:    if x > 1:        print('quadrati')    else:        print('triangoli')print('B:')        if x <= 1:    print('triangoli')elif x <= 3:    print('quadrati')else:    print('cerchi')```  Sono equivalenti?  - dentro fuori 2```pythonx = 7x = 0x = 15print('x =', x)print('A:')if x > 5:    if x < 10:        print('dentro')    else:        print('fuori')else:    print('fuori')print('B:')        if not x > 5 and not x < 10:    print('fuori')else:    print('dentro')```  Sono equivalenti? - Ciabanga```pythonx = 4x = 5x = 6x = 9x = 10x = 11print('x =', x)print('A:')if x < 6:    print('Ciabanga!')else:    if x >= 10:                print('Ciabanga!')           print('B:')if x <= 5 or not x < 10:    print('Ciabanga!')```  Esercizio - Il massimoScrivi del codice che stampa il massimo fra tre numeri `x`, `y` e `z`* usa **if annidati*** **NON** usare la funzione `max`* **NON** creare variabili che si chiamano `max` (violerebbe il [V Comandamento](https://it.softpython.org/commandments.htmlV-COMANDAMENTO): non ridifinerai mai funzioni di sistema)<jupyter_code>x,y,z = 1,2,3
#x,y,z = 1,3,2
#x,y,z = 2,1,3
#x,y,z = 2,3,1
#x,y,z = 3,1,2
#x,y,z = 3,2,1

# scrivi qui

if x > y:    
    if x > z:
        print(x)
    else:
        print(z)
elif y > z:
    print(y)
else:
    print(z)<jupyter_output>3<jupyter_text>Operatore ternarioIn qualche caso è conveniente inizializzare una variabile con valori diversi a seconda di una condizione**Esempio**:Lo sconto che si applica ad un'acquisto dipende dalla quantità acquistata. Crea una variabile `sconto` mettendo il suo valore a 0 se la variabile `spesa` è minore di 100€, oppure `10%` se è maggiore.<jupyter_code>spesa = 200
sconto = 0

if spesa > 100:
    sconto = 0.1
else:
    sconto = 0 # non necessario

print("spesa:", spesa, "  sconto:", sconto)<jupyter_output>spesa: 200   sconto: 0.1<jupyter_text>Il codice precedente può essere scritto più concisamente così:<jupyter_code>spesa = 200
sconto = 0.1 if spesa > 100 else 0
print("spesa:", spesa, "  sconto:", sconto)<jupyter_output>spesa: 200   sconto: 0.1<jupyter_text>La sintassi dell'operatore ternario è: ```pythonVARIABILE = VALORE if CONDIZIONE else ALTRO_VALORE``` col significato che `VARIABILE` è inizializzata a `VALORE` se la `CONDIZIONE` è `True`, altrimenti viene inizializzata ad `ALTRO_VALORE`  Domande if ternariGuarda i seguenti frammenti di codice, e per ciascuno cerca di indovinare quale risultato produce (o se da errore):1.  ```python    y = 3    x = 8 if y < 2 else 9    print(x)    ```1.  ```python    y = 1    z = 2 if y < 3    ```1.  ```python    y = 10    z = 2 if y  5 9    ```      Esercizio - scarpeScrivere del codice che data la variabile numerica `scarpe`, se `scarpe` è minore di 10 viene incrementata di `1`, altrimenti viene decrementata di `1`* Usa **SOLO** l'**if ternario*** Il tuo codice deve funzionare per _qualsiasi_ valore di `scarpe`Esempio 1 - dato:```pythonscarpe = 2```Dopo il tuo codice, deve risultare:```python>>> print(scarpe)3```Esempio 2 - dato:```pythonscarpe = 16```Dopo il tuo codice, deve risultare:```python>>> print(scarpe)15```<jupyter_code>scarpe = 2
#scarpe = 16

# scrivi qui

scarpe = scarpe + 1 if scarpe < 10 else scarpe - 1
print('scarpe =', scarpe)<jupyter_output>scarpe = 3<jupyter_text>Esercizio - treninoScrivi del codice che date 3 stringhe `sa`, `sb` e `sc` assegna alla variabile `x` la stringa `'CIUFCIUF'` se è possibile comporre `sa`, `sb` e `sc` per ottenere la scritta `'trenino'`, altrimenti mette la stringa `':-('`* **USA** un if ternario* il tuo codice deve funzionare per **qualsiasi** terna di stringhe* **NOTA**: ci interessa sapere SE è possibile comporre le scritte come `'trenino'`, NON in che ordine vanno composte* **SUGGERIMENTO**: ti è consentito creare una lista di appoggioEsempio 1 - date:```pythonsa,sb,sc = "ni","no","tre"```dopo il tuo codice, deve risultare:```>>> print(x)CIUFCIUF```Esempio 2 - date:```pythonsa,sb,sc = "quattro","ni","no"```dopo il tuo codice, deve risultare:```>>> print(x):-(```<jupyter_code>sa,sb,sc = "ni","no","tre"       # CIUFCIUF
#sa,sb,sc = "ni","tre","no"      # CIUFCIUF
#sa,sb,sc = "quattro","ni","no"  # :-(
#sa,sb,sc = "na","tre","no"      # :-(


# scrivi qui
tutte = [sa,sb,sc]
x = 'CIUFCIUF' if "tre" in tutte and "ni" in tutte and "no" in tutte else ':-('

#print(x)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12796709753231492, 'fraction_numerical': 0.01981981981981982, 'mean_word_length': 3.5509803921568626, 'pattern_counts': {'":': 0, '<': 105, '<?xml version=': 0, '>': 146, 'https://': 4, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '22', 'dir': 'jupyter-structured-clean-dedup', 'id': '213732', 'license': 'CC-BY-4.0', 'n_tokens_mistral': 10033, 'n_tokens_neox': 9651, 'n_words': 3098, 'path': 'control-flow/flow1-if-sol.ipynb', 'repo_name': 'DavidLeoni/softpython-', 'size': '25530'}