P.25 Stringhe

Fino ad ora abbiamo utilizzato le stringhe in modo abbastanza semplice e istintivo ma questo tipo di “oggetti” in Python offrono varie possibilità di elaborazione. Una stringa è un messaggio, un testo o semplicemente una sequenza di caratteri delimitati da una coppia di virgolette.

Leggi tutto “P.25 Stringhe”

P.23 Dizionari

Python prevede l’utilizzo di dizionari, cioè delle strutture dati in cui inseriamo delle coppie chiave-valore. Un dizionario funziona proprio come l’omonimo oggetto: cerco una parola e ne trovo il significato. Anche la rubrica del telefono è un esempio di “dizionario”: all’interno ci sono dei nominativi in ordine alfabetico con associato un numero di telefono.

Leggi tutto “P.23 Dizionari”

P.21 Tuple

A prima vista una tupla è come una lista, ma differenza di questa è immutabile, cioè il suo contenuto non può essere modificato. Gli elementi di una tupla sono disposti in ordine e possiamo richiamarli con un indice, proprio come per le liste. Possiamo avere anche elementi ripetuti, appunto perché sono distinti dalla loro posizione. Possiamo usare delle tuple per memorizzare dati differenti (es. il nome di un prodotto,la sua quantità e il prezzo), preferendo le liste per dati omogenei (tutti dello stesso tipo e significato).

Le tuple essendo a sola lettura sono ottimizzate e hanno tempi di accesso più brevi.

Questa è una lista:

lista = [1, 2, 3]

e questa è una tupla:

mytupla = ("apple", "banana", "cherry")

L’unica differenza sono le parentesi: quadre per la liste e tonde per la tupla. Non ci sono vincoli a quello che possiamo inserire in una tupla e quindi possiamo anche avere anche tipi “misti”:

mytupla = ("Ciao", 100, 3.14)
print(mytupla)

Possiamo stampare direttamente una lista passandola a print(), oppure scorrendo gli elementi uno a uno con un ciclo:

for x in mytupla:
    print(x)

Possiamo accedere agli elementi con un indice che parte da 0:

print(mytupla[1])

Il numero di elementi è dato da:

len(tupla)

Possiamo contare quante volte un elemento compare in una lista utilizzando count():

lettere = ("A", "B", "C", "B", "D")
print(lettere.count("B"))

Le tuple ci permettono di utilizzare il meccanismo di “impacchettamento/spacchettamento” (packing/unpacking) che ci permette di creare una tupla elencando delle variabili o dei valori seguiti da delle virgole:

dati = "cane", 100, 3.14
print(dati)

Lo spacchettamento prende il contenuto di una tupla e lo assegna a più variabili. Il numero delle variabili deve essere pari al numero di elementi contenuti nella tupla:

a, b, c = dati

print(a)      # cane
print(b)      # 100
print(c)      # 3.14

Non è possibile modificare, cancellare, aggiungere elementi ad una tupla ma possiamo cercarli con index(). Per ottenere la posizione della lettera C all’interno della tupla lettere scriveremo:

lettere = ("A", "B", "C", "B", "D")
posizione = lettere.index("C")
print(posizione)

Pre verificare la presenza di un elemento in una tupla utilizziamo in:

lettere = ("A", "B", "C", "B", "D")
if “A” in lettere:
    print(“A e’ presente”)

Gli operatori di Python permettono di svolgere operazioni esotiche con le tuple. Possiamo unire due tuple, sommandole e questo non dovrebbe stupirci:

t = (1,2,3)
p = (4,5)
print(t + p)

Ottenendo:

(1, 2, 3, 4, 5)

Possiamo però moltiplicare una tupla, per esempio per 2, raddoppiando i suoi elementi!

t = (1,2,3)
print(t * 2)

producendo:

(1,2,3,1,2,3)

Cose da provare

Come puoi stampare gli elementi di una tupla con un while?

P.20 Break e Continue nel ciclo While

L’istruzione break interrompe totalmente l’esecuzione di un ciclo. L’abbiamo utilizzata con i cicli for, ma funziona anche con while. Riprendiamo il listato 1.30, modifichiamolo così che arrivi fino a 9 e inseriamo nel corpo del ciclo l’istruzione break, richiamata quando il conteggio arriva a 5:

count = 0
while (count < 10):
    print(count, end=" ")
    count += 1
    if (count == 5):
        break
print("END")

Listato 1.33 – Utilizzo di break con un ciclo while.

Eseguendo il codice otterremo:

0 1 2 3 4 END

L’istruzione continue invece fa saltare un’iterazione, ma quando si utilizza all’interno di un ciclo while, bisogna fare molta attenzione a dove la inseriamo perché se la richiamassimo prima dell’istruzione di incremento della variabile count, rischieremmo di non uscire mai dal ciclo.

count = 0
while (count < 10):
    print(count, end=” “)
    count += 1
    if count == 5:
        print(“salto”)
        continue
print(“END”)  

Listato 1.34 – Utilizzo di break con un ciclo while.

Ecco il risultato prodotto dall’esecuzione del listato 1.34:

0 1 2 3 4 salto
5 6 7 8 9 END

Qui di seguito riporto una differente versione del listato 1.34: qui l’istruzione di incremento è posta dopo la chiamata alla continue. Il ciclo procede incrementando il valore di count fino a che questo non è pari a 5. A questo punto “scatterà” l’if, richiamando la continue e rimandando l’esecuzione all’inizio del ciclo. Purtroppo non raggiungeremo mai l’istruzione di incremento, count resterà ferma a 5 e rimarremo imprigionati nel ciclo.

count = 0
while (count < 10):
    print(count, end=" ")    
    if count == 5:
        print("salto")
        continue
    count += 1
print("END")  

Listato 1.35 – Utilizzo non corretto di continue all’interno di un ciclo while.

Cose da provare

  • Scrivete un programma con while e continue che stampi i numeri pari fino a 50.
  • Scrivete un programma che conta da 1 a 100 e si interrompe con break al numero 50.
  • Modificate il programma precedente chiedendo a che numero si deve interrompere.

P.19 Il ciclo While

A volte abbiamo bisogno di ripetere delle operazioni senza sapere quando sarà necessario terminare. Immaginate di voler costruire un sistema automatico per riscaldare una pentola d’acqua con una resistenza elettrica. Un sensore misurerà la temperatura per poter spegnere l’elemento riscaldante quando abbiamo raggiunto la temperatura di 100°C. Il codice di controllo:

  • attiva l’elemento riscaldante;
  • misura la temperatura del liquido;
  • se la temperatura è pari a 100°C interrompe la sequenza di riscaldamento.

È chiaro che il tempo necessario per riscaldare l’acqua dipenderà dalla sua quantità e quindi non sappiamo a priori quante iterazioni saranno necessarie. In questi casi è preferibile utilizzare l’istruzione while, che ripete delle istruzioni fino a che la condizione che controlla è vera (funziona un po’ come se fosse un if).

Per realizzare un conteggio da 0 a 4 possiamo scrivere:

count = 0
while (count < 5):
	print(count, end=” ”)
	count += 1 

Listato 1.30 – Programma per contare da 0 a 4 utilizzando un ciclo while.

Utilizziamo una variabile count, inizialmente a 0. Eseguiremo il corpo del ciclo while fino a che count è minore di 5. Ad ogni iterazione stamperemo il valore di count con una print(). L’ultima istruzione del ciclo while è quella che incrementa il valore di count di una unità. In forma compatta scriveremo:

count += 1

che equivale a:

count = count + 1

Eseguendo il codice otterremo la sequenza:

0 1 2 3 4 

Il ciclo while è indicato nel caso volessimo creare un programma che stampa numeri casuali fino a che non estraiamo il 7. Per ottenere dei numeri casuali utilizzeremo l’istruzione randind(0, 9) che genera numeri a caso tra 0 e 9. La condizione del ciclo while sarà:

while not(n == 7):

La variabile n, che contiene i numeri casuali va creata prima del ciclo while e conterrà inizialmente il valore 0. Alla prima esecuzione del ciclo incontriamo il test:

not (n == 7)

Quindi con n pari a 0, (n == 7) sarà False. Per entrare nel corpo del ciclo abbiamo bisogno di “ribaltare” il suo valore booleano. Anteponiamo la negazione not. Ora la scrittura not (n == 7) avrà il valore True fino a che n non varrà 7, interrompendo le ripetizioni.

import random
n = 0;
while not(n == 7):
    n = random.randint(0,10)
    print(n, end=”, ”)
print("Ho trovato il 7!")

Listato 1.31 – Programma per generare generare numeri fino a che non si ottiene il 7.

Eseguendo il codice otterremo una sequenza simile alla seguente:

10, 6, 3, 1, 9, 7, Ho trovato il 7!

I numeri del Lotto

Proviamo a scrivere un programma che ci fornisca i numeri per giocare al Lotto fino a che ne abbiamo necessità. Dopo ogni estrazione, ci verrà chiesto se desideriamo proseguire e potremo rispondere con “s” o “n”.

Utilizzeremo la libreria random per generare numeri casuali. Creiamo una variabile risposta, inizialmente impostata al valore “s”:

risposta = 's'

Il ciclo while verifica se risposta è pari a “s”:

while risposta == 's':

All’interno del ciclo estraiamo un numero casuale e lo stampiamo, quindi chiediamo al giocatore se vuole proseguire. La risposta fornita a input() è inserita nella variabile risposta che sarà valutata alla prossima iterazione.

import random
risposta = 's'
while risposta == 's':
    print(random.randint(1,90))
    risposta = input('estraggo un nuovo numero (s/n)? ')

print('fine')    

Listato 1.32 – Programma per generare i numeri del Lotto.

Ecco una possibile esecuzione:

66
estraggo un nuovo numero (s/n)? s
71
estraggo un nuovo numero (s/n)? s
83
estraggo un nuovo numero (s/n)? n
fine

Cose da provare

  • Provate a creare una versione del programma che genera una lista di 10 numeri casuali, utilizzando un ciclo while anziché il for.
  • Modificate il precedente programma in modo che possiate prima scegliere quanti numeri aggiungere alla lista.

P.18 Creare una lista di numeri scelti a caso

Fino ad ora abbiamo sempre lavorato con delle liste di numeri fornite dall’utilizzatore o inserite direttamente nel codice. Potrebbe fare comodo generare dei valori casuali con cui popolare le liste utilizzate nei nostri esperimenti. Purtroppo Python non ha un’istruzione che fornisca direttamente un numero a caso e dobbiamo richiamare un codice esterno.

Leggi tutto “P.18 Creare una lista di numeri scelti a caso”