Programmazione

Sesto incontro con Python, ancora non ho ricevuto feedback, quindi proseguiamo con il linguaggio.

Vediamo meglio come lavorare con gli iterabili, ovvero tuple, liste e dizionari.
In altri linguaggi sarebbero chiamati array, scalar, hashtables e simili nomi.
Si tratta in pratica di variabili che contengono sequenze di dati.
Ma in Python ogni cosa è un oggetto, come vedremo presto, per cui ha dei metodi, ovvero funzioni dell’oggetto, specifiche, per la manipolazione dell’oggetto stesso.
Abbiamo tre tipi di oggetti, le tuple e le liste che sono semplici liste di elementi assortiti e i dizionari che invece sono coppie chiave-valore.
Vediamole in dettaglio.

TUPLE
Una tupla è una sequenza di elementi assortiti. Si riconosce perché gli elementi sono racchiusi, alla creazione o inizializzazione della tupla, tra parentesi tonde.

>>> mia_tupla = (1,’ciccio’, 3.14, “Giovanni dalle bande nere”)

Come vedete possono essere eterogenee, ovvero contenere qualsiasi tipo di elemento. Un esempio di tupla piu’ sensato è il seguente:

>>> settimana = (“Lunedì”, “Martedì”, “Mercoledì”, “Giovedì”, “Venerdì”, “Sabato”, “Domenica”)

Possiamo quindi selezionare un giorno della settimana con

>>> settimana[indice]

dove indice è un valore compreso tra 0 e 6.

Ricordate sempre che gli indici iniziano con 0 e hanno come valore massimo il numero di elementi meno 1.

Per esempio per stampare tutti gli elementi potremmo scrivere
>>> settimana = (“Lunedì”, “Martedì”, “Mercoledì”, “Giovedì”, “Venerdì”, “Sabato”, “Domenica”)
>>> for a in range(0, len(settimana)):
>>> print settimana[a]

e otterremo come output
Lunedì
Martedì
Mercoledì
Giovedì
Venerdì
Sabato
Domenica

Bene, manca un particolare importante: le tuple sono delle costanti. Una volta assegnate non si possono modificare. Né aggiungere né sottrarre elementi.
Certo possiamo tranquillamente scrivere

>>> settimana = (‘Lun’, ‘Mar’, ‘Mer’, ‘Gio’, ‘Ven’, ‘Sab’, ‘Dom’)

ma in realtà avremo creato un altro oggetto con la stessa etichetta.

A cosa servono le tuple?

Le tuple sono più veloci delle liste. Se state definendo un gruppo costante di valori e l’unica cosa che intendete farci è iterare al suo interno, usate una tupla invece di una lista.
Potete rendere più sicuro il vostro codice “proteggendo dalla scrittura” i dati che non devono essere modificati.

Le tuple possono essere convertite in liste e viceversa. La funzione built-in tuple prende una lista e ritorna una tupla con gli stessi elementi, mentre la funzione list prende una tupla e ritorna una lista. In effetti, tuple congela una lista e list scongela una tupla.

Possiamo controllare se un elemento è presente in una tupla:
>>> ‘Sabato’ in settimana
True

mentre
>>> ‘Giovanni’ in settimana
False

Inoltre possiamo controllare quale sia l’indice dell’elemento
>>> settimana[‘sabato’] 5

E poi possiamo estrarre un certo numero di elementi con lo slicing
>>> settimana[2:4]
(‘Mercoled\xc3\xac’, ‘Gioved\xc3\xac’)

\xc3\xac è la rappresentazione UTF-8 della lettera accentata.
UTF-8 è una codifica che ci permette di descrivere qualsiasi carattere, inclusi quelli di lingue tipo cinese o arabo.

In pratica i due valori all’interno delle parentesi quadre, indicano l’inizio e la fine delle fette. Qui dobbiamo aprire una parentesi:

Se usiamo un indice averemo una situazione tipo:
‘a’,’b’,’c’,’d’,’e’
0 1 2 3 4

Invece con lo slicing
‘a’,’b’,’c’,’d’,’e’
0 1 2 3 4 5

Per cui posto che abbiamo la tupla
>>> miatupla = (‘a’,’b’,’c’,’d’,’e’)
>>> miatupla[2:4]
(‘c’, ‘d’)

Questa cosa funziona anche con le stringhe come avremo occasione di vedere in seguito.

LISTE
Le liste sono simili alle tuple, ma sono modificabili e si inizializzano con le parentesi quadre.

>>> mia_lista = [1,2,3,4,5,6,7]
>>> mia_lista
[1, 2, 3, 4, 5, 6, 7]

Ma possiamo aggiungere elementi alla lista
>>> mia_lista.append(8)
>>> mia_lista
[1, 2, 3, 4, 5, 6, 7,8]

>>> mia_lista.insert(2,10)
>>> mia_lista
[1, 2, 10, 3, 4, 5, 6, 7, 8]

>>> mia_lista.extend([11,12])
>>> mia_lista
[1, 2, 10, 3, 4, 5, 6, 7, 8, 11, 12]

Possiamo fare ricerche
>>> mia_lista.index(10)
2

E possiamo anche fare cose tipo:
>>> mia_lista[mia_lista.index(10)]
10

che ci conferma che index ha tornato il valore corretto.

Possiamo anche togliere elementi

>>> mia_lista.remove(10)
>>> mia_lista
[1, 2, 3, 4, 5, 6, 7, 8, 11, 12]

oppure
>>> mia_lista.pop()
12
>>> mia_lista
[1, 2, 3, 4, 5, 6, 7, 8, 11]

Ma non abbiamo finito, perché possiamo anche fare cose tipo
>>> mia_lista = mia_lista + [‘a’,’b’]
>>> mia_lista
[1, 2, 3, 4, 5, 6, 7, 8, 11, ‘a’, ‘b’]

>>> mia_lista += [‘c’]
[1, 2, 3, 4, 5, 6, 7, 8, 11, ‘a’, ‘b’, ‘c’]

>>> altra_lista = [1,2,3] * 3
>>> altra_lista
[1, 2, 3, 1, 2, 3, 1, 2, 3]

Inoltre una lista può avere come elementi altre liste, tuple e dizionari
>>> nuova_lista = [1,2,3,’a’,[‘AAA’, ‘BBB’], (1,2,3)]
>>> nuova_lista
[1, 2, 3, ‘a’, [‘AAA’, ‘BBB’], (1, 2, 3)]
>>> nuova_lista[2:5]
[3, ‘a’, [‘AAA’, ‘BBB’]]

DIZIONARI
Un dizionario e’ una specie di lista dove l’indice non è il numero (progressivo) assegnato dalla lista stessa, in base all’ordine di apparizione e che è mutabile ma bensì un valore che decidiamo noi (un numero, una stringa etc.) e quindi immutabile.

Per contro una lista torna sempre nello stesso ordine (quello in cui sono ordinati gli elementi in base all’indice) mentre un dizionario può tornare ogni volta gli elementi in maniera differente. Se eseguiamo un
>>> mio_dizio = {1: ‘AAA’, ‘2’: ‘BBB’, ‘3’: ‘CCC’, 4: ‘DDD’}

e poi invochiamo diverse volte
>>> mio_dizio

non è garantito che tutte le volte torni lo stesso ordine, sopratutto se nel mezzo ho fatto operazioni (aggiunto, rimosso o modificato elementi).
Esiste una versione speciale l’OrderedDict che torna sempre nello stesso ordine, come una lista, ma si tratta di un caso differente, di cui parleremo in futuro.

Vediamo ora quali siano i metodi propri di un dizionario.
>>> mio_dizio = {“server”:”mpilgrim”, “database”:”master”}
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘database’: ‘master’}
>>> mio_dizio[“server”]
‘mpilgrim’
>>> mio_dizio[“database”]
‘master’
>>> mio_dizio[“mpilgrim”]
Traceback (innermost last):
File “<interactive input>”, line 1, in ?
KeyError: mpilgrim

Abbiamo definito un dizionario assegnandogli delle coppie chiave:valore, abbiamo fatto stampare il contenuto, abbiamo fatto stampare i valori delle due chiavi, ma quando abbiamo cercato di passare come chiave un contenuto abbiamo ricevuto un errore.

Vediamo ora come modificare un dizionario
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘database’: ‘master’}
>>> mio_dizio[“database”] = “pubs”
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘database’: ‘pubs’}
>>> mio_dizio[“uid”] = “sa”
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘pubs’}

In pratica abbiamo aggiunto una nuova chiave (uid) assegnandogli un valore con la semplice istruzione [‘uid’] = ‘sa’, e modificato il valore della chiave ‘database’ con un sistema analogo.
Se si indica una chiave esistente se ne modifica il valore, in caso contrario si aggiunge una coppia chiave:valore.

Notate che il nuovo elemento (chiave ‘uid’, valore ‘sa’) sembra trovarsi nel mezzo. Infatti è una semplice coincidenza che gli elementi appaiano ordinati nel primo esempio; è comunque una coincidenza anche il fatto che ora appaiano disordinati.

Un dizionario può, esattamente come le liste e le tuple, contenere elementi eterogenei.
Ecco un esempio
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘pubs’}
>>> mio_dizio[“retrycount”] = 3
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, ‘retrycount’: 3}
>>> mio_dizio[42] = “douglas”
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}

Per rimuovere un elemento da un dizionario si fa così
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> del mio_dizio[42]
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, ‘retrycount’: 3}
>>> mio_dizio.clear()
>>> mio_dizio
{}

del rimuove l’elemento con la chiave indicata, il metodo clear() invece rimuove tutte le coppie chiave:valore del dizionario, lasciando un dizionario vuoto.

In Python le stringhe usate come chiavi o nomi di variabili sono case sensitive, ovvero c’è differenza tra maiuscole e minuscole, come possiamo vedere qui di seguito
mio_dizio = {}
>>> mio_dizio[“key”] = “value”
>>> mio_dizio[“key”] = “other value”
>>> mio_dizio
{‘key’: ‘other value’}
>>> mio_dizio[“Key”] = “third value”
>>> mio_dizio
{‘Key’: ‘third value’, ‘key’: ‘other value’}

‘Key’ e ‘key’ sono due chiavi diverse tra loro.

Per avere un valore di una chiave inserita si possono usare due strade
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> mio_dizio[‘database’]
‘master’
>>> mio_dizio.get(‘database’)
‘master’

Il secondo e’ un metodo più chiaro, il primo è più immediato.

Se voglio l’elenco dei valori contenuti nel dizionario
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> mio_dizio.values()
[3, ‘douglas’, ‘master’, ‘sa’, ‘mpilgrim’]

che mi torna sotto forma di lista. In maniera simile posso avere l’elenco delle chiavi
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> mio_dizio.keys()
[‘retrycount’, 42, ‘database’, ‘uid’, ‘server’]

Ma posso anche farmi tornare una lista di tuple che contengono le coppie chiave:valore
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> mio_dizio.items()
[(‘retrycount’, 3), (42, ‘douglas’), (‘database’, ‘master’), (‘uid’, ‘sa’), (‘server’, ‘mpilgrim’)]

Per sapere se un dizionario contenga o meno una data chiave si puo’ usare il metodo has_key()
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> mio_dizio.has_key(‘server’)
True
>>> mio_dizio.has_key(‘nonserver’)
False

Oppure possiamo scrivere
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> ‘server’ in mio_dizio
True
>>> ‘nonserver’ in mio_dizio
False

Per farci tornare separatamente le coppie possiamo utilizzare un ciclo for come segue
>>> for key,value in mio_dizio.items():
>>> print key, value
retrycount 3
42 douglas
database master
uid sa
server mpilgrim

Bene per oggi chiudiamo qui.
Nella prossima lezione potremo dare una occhiata ad uno dei piu’ potenti strumenti che Python ci mette a disposizione: le List Comprehensions, che ci permettono di racchiudere in una sola stringa, di elevata leggibilità, istruzioni complesse per la gestione di stringhe, liste e dizionari.

Arrivederci alla prossima.

Altre letture utili:
Programmare con Python. Guida completa
Python
Programmare in Python

Eccoci qui per il quinto incontro. Oggi scopriremo come si eseguono operazioni ripetitive in Python.
Abbiamo due possibilità di eseguire operazioni ripetitive.
Per un preciso numero di volte oppure fino a che non si verifica una data condizione.

Prima possibilità: il FOR
L’istruzione FOR ci permette di eseguire un certo numero di iterazioni come segue
>>> for a in range(1, 10):
>>> print a
e otterremo come output
1
2
3
4
5
6
7
8
9

La funzione predefinita range prende due parametri, il valore iniziale e quello finale (in realtà si deve aumentare di uno il valore finale, capiremo tra breve perché) ed esegue un numero di iterazioni pari alla differenza tra i due (10-1 = 9) assegnando alla variabile “a” il valore conteggiato.

Ovviamente possiamo fare di meglio, ad esempio stampare solo i numeri dispari, con il seguente codice
>>> for a in range(1, 10, 2):
>>> print a

che stamperà
1
3
5
7
9

Il secondo parametro indica lo step, ovvero di quanto si deve incrementare il contatore.

Ora facciamo un giochino.
Chi è uso a risolvere le parole crociate conosce quelle definizioni tipo “Arteria senza pari”, dove si devono scrivere solo le lettere dispari della parola.
Vediamo come Python ci viene in aiuto:

>>> parola = “arteria”
>>> for a in range(0,len(parola),2):
>>> print parola[a]

a
t
r
a
la funzione len() ci torna la lunghezza della stringa che gli passiamo.
Quindi range con parametri 0, len(parola) e 2 ci permette di avere gli indici (posizioni delle lettere) dispari.
L’istruzione print parola[a] stampa la lettera che ha indice a.

Come dire se avessimo scritto
>>> print parola[3] avremmo ottenuto come output
r
che è la lettera nella quarta posizione (tenete conto che gli indici in Python iniziano sempre da 0).

In seguito vedremo come possiamo ritagliare solo una parte (substring o sottostringa) da una stringa, ma per ora ci basta l’indice.

Abbiamo visto quindi come fare un ciclo con un numero di iterazioni predefinito. Che sia con un valore fisso o con la lunghezza di una stringa, sempre un preciso numero di iterazioni avranno luogo.

Abbiamo pero’ la possibilita’ di eseguire un numero di iterazioni indefinite che terminano al verificarsi di una determinata condizione. Un poco come se iniziassimo un loop infinito (ciclo senza un valore limite maggiore) e ne uscissimo se una istruzione if <condizione>: si verifica.
Che poi si potrebbe fare con le istruzioni:
>>> from random import randint
>>> for x in iter(int, 1):
>>> print x
>>> if randint(1,9) == 3:
>>> break

stamperà 0 per un numero indefinito di volte.

Rieseguite le istruzioni più volte, al limite racchiudendole in una funzione con codice come il seguente:
>>> from random import randint
>>> def funzione():
>>> for x in iter(int, 1):
>>> print x
>>> if randint(1,9) == 3:
>>> break
>>> funzione()

Chiamando più volte funzione() non dovrete digitare tutte le volte il gruppo di istruzioni.

L’istruzione from random import randint importa dal package random la funzione randint.
randint con due parametri (i due estremi) genera un numero intero casuale tra i due estremi.
Quando il numero generato è uguale a 3 l’istruzione break interrompe il ciclo.
Però fare le cose cosi’ non è molto comodo. Facciamo pertanto conoscenza con l’istruzione while.

Seconda possibilità: il WHILE

>>> from random import randint
>>> while randint(1,9) != 3:
>>> print “ciao”

stamperà ciao un numero variabile di volte, in base a quando verrà generato il numero 3 da randint.
Ovviamente se allargassimo da 9 a 90 o a 900 il limite le probabilita’ che il ciclo termini diminuiranno in maniera proporzionale.

Abbiamo visto quindi come con while fino a che non si verifica la condizione abbiamo un ciclo.
Qui la condizione la impostiamo dall’istruzione.
Un ciclo infinito con while possiamo averlo con
>>> while 1 == 1:
>>> print “ciao”

Arrivederci alla prossima settimana.

Altre letture utili:
Programmare con Python. Guida completa
Python
Programmare in Python