Appunti Python

'ALICE'

# il valore di name non è cambiato

>>> name

'Alice'

>>> name = name.upper()

# il valore di name è ora stato cambiato

>>> name

'ALICE'

I metodi split() e join()

Il metodo join() è utile quando ci troviamo con una lista di stringhe e vogliamo

unirle tra di loro per formare una nuova stringa risultante, come nel caso di una

lista di parole. Questo metodo viene chiamato su una stringa che usiamo "a mo'

di collante" tra le varie stringhe che vogliamo unire. Nel nostro caso questa

stringa "collante" potrebbe essere una virgola seguita da uno spazio, oppure un

carattere newline.

>>> to_do = ["portare il cane a passeggio", "finire di studiare", "fare

la spesa", "lavare i panni"]

>>> ", ".join(to_do)

'portare il cane a passeggio, finire di studiare, fare la spesa, lavare i

panni'

>>> da_fare = "oggi devo: " + ", ".join(to_do)

>>> da_fare

'oggi devo: portare il cane a passeggio, finire di studiare, fare la

spesa, lavare i panni'

##################################################################

>>> da_fare = "\n".join(to_do)

>>> print(da_fare)

portare il cane a passeggio

finire di studiare

fare la spesa

lavare i panni

Col metodo split() possiamo al contrario dividere una stringa in una lista di

stringhe, e dovremo passare come parametro il carattere che intendiamo usare

come separatore.

>>> citazione = "Nel mezzo del cammin di nostra vita..."

>>> citazione.split(" ")

['Nel', 'mezzo', 'del', 'cammin', 'di', 'nostra', 'vita...']

Il metodo format()

Per formattare le stringhe possiamo utilizzare anche il metodo format():

stringa.format(valore1, valore2, ...)

Dove stringa è la stringa da formattare e valore1, valore2, ecc. sono i valori da

inserire nella stringa. Il metodo format() sostituisce ogni posizione {} nella

stringa con il valore corrispondente passato come parametro. Ad esempio:

>>> colore1 = "blu"

>>> colore2 = "verde"

>>> s = "I miei colori preferiti sono {} e {}.".format(colore1, colore2)

>>> print(s)

# output

I miei colori preferiti sono blu e verde.

Similarità tra liste e stringhe

I tipi di dato di Python list e string sono per certi aspetti simili tra di loro, e per

questo motivo ci sono alcune tipologie di azioni che possiamo fare su entrambi.

Potete in questi esempi pensare quindi alle stringhe come a delle liste di

caratteri.

La funzione len()

La funzione integrata di Python len() ci permette di ottenere la lunghezza di una

lista o una stringa, e quindi rispettivamente il numero di elementi o di caratteri

presenti in queste:

>>> my_str = "spam, eggs, bacon, spam"

>>> my_list = ["spam", "spam", "spam"]

>>> len(my_str)

23

>>> len(my_list)

3

In my_str , conta tutti i caratteri tranne gli apici.

In my_list, conta gli elementi (non virgole, apici)

Operatori in e not in

Possiamo usare gli operatori in e not in per verificare se un elemento o un

carattere sia presente in una lista o stringa:

>>> my_list = ["spam", "spam", "spam"]

>>> new_str = "happiness"

>>> "bacon" in my_list

False

>>> "spam" in my_list

True

>>> "eggs" not in my_list

True

>>> "k" not in new_str

True

>>> "h" in new_str

True

String Slicing

In maniera analoga a quanto visto con le liste, possiamo accedere ai caratteri di

una stringa tramite indice, in modo da ottenere una porzione della stessa. In

questo esempio abbiamo una variabile chiamata alfa che contiene un insieme

di caratteri alfabetici + tre punti di sospensione.

Volendo possiamo isolare la porzione puramente alfabetica o i tre punti usando

lo slicing e usare questi valori per creare delle nuove variabili:

>>> alfa = "abcdefghijklm..."

>>> dots = alfa[-3:]

>>> dots

'...'

>>> alfa = alfa[:-3]

>>> alfa

'abcdefghijklm'

Stringhe e cicli for

Come per le liste, possiamo usare i cicli for assieme alle nostre stringhe:

random_alnum = "dj1oi3u4nuqnoru01u3m3mdasd"

counter = 0

match = "d"

for char in random_alnum:

if char == match:

counter += 1

output = f"Ho trovato {counter} caratteri '{match}' "

>>> output

"Ho trovato 3 caratteri 'd' "

Tuple – Set

In questa lezione parleremo di due nuovi tipi di dato: tuple e set.

Le tuple in Python

Come il tipo di dato lista visto nelle lezioni precedenti, anche il tipo tuple di

Python rappresenta un insieme di elementi, definiti stavolta utilizzando una

coppia di parentesi tonde, oppure senza alcuna parentesi ma separati da

virgola.

>>> tupla = (2, 4, 9, 15, 23)

>>> type(tupla)

# output

<class 'tuple'>

###################

>>> tupla

# output

(2, 4, 9, 15, 23)

###################

>>> tupla_due = 7, 8, 9

>>> tupla_due

# output

(7, 8, 9)

Come per le liste, possiamo accedere agli elementi delle tuple utilizzando

l'indice.

>>> tupla = (2, 4, 9, 15, 23)

>>> tupla[0]

# output

2

Le Tuple sono IMMUTABILI

La grande differenza tra i tipi di dato tuple e list è che le tuple sono immutabili.

Per questo motivo il dato tuple non dispone di un metodo append() e non

possiamo usare l'istruzione del per rimuovere elementi. Questo risulta molto

comodo in certe situazioni: tenetelo a mente!

>>> tupla.append(999)

# output

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AttributeError: 'tuple' object has no attribute 'append'

#####################################

>>> del tupla[0]

# output

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'tuple' object doesn't support item deletion

Il tipo set di Python

I set sono un altro tipo di dato di Python che permette di creare collezioni di

elementi. I set vengono definiti con una coppia di parentesi graffe, e i valori

sono separati da virgola

>>> my_set = {"asd", "qwerty", "cmd"}

>>> type(my_set)

# output

<class 'set'>

La caratteristica fondamentale dei set è che non possono contenere duplicati al

loro interno.

>>> new_set = {"asd", "asd", "qwerty", "cmd"}

>>> new_set

# output

{'qwerty', 'cmd', 'asd'}

Il metodo add() dei set

A differenza delle tuple possiamo però aggiungere nuovi elementi col metodo

.add ; Provare ad aggiungere elementi già presenti non funzionerà!

>>> new_set = {"asd", "asd", "qwerty", "cmd"}

>>> new_set.add("cmd")

>>> new_set

# output

{'qwerty', 'cmd', 'asd'}

##############################

>>> new_set.add("nova")

>>> new_set

# output

{'qwerty', 'cmd', 'asd', 'nova'}

I set sono quindi MUTABILI.

Funzioni per iterabili

Python fornisce diverse funzioni per manipolare gli elementi degli iterabili,

vediamo alcune delle più utilizzate:

La funzione max()

La funzione max() viene utilizzata per trovare il valore massimo di un oggetto

iterabile.

max(iterable, key=None, default=None)

Dove iterable è la sequenza di cui si vuole trovare il valore massimo. Ad

esempio possiamo usare max() per ottenere il numero maggiore in un set di

numeri:

numeri = {3, 8, 1, 6, 9, 4}

valore_massimo = max(numeri)

print(valore_massimo)

# output

9

L'argomento default specifica il valore da restituire se l'insieme di input è vuoto,

mentre l’argomento key specifica un criterio di ordinamento personalizzato, ad

esempio se gli passiamo len possiamo ottenere la parola più lunga in una tupla

di parole:

parole = ('casa', 'auto', 'giardino', 'mestolo')

parola_più_lunga = max(parole, key=len)

print(parola_più_lunga)

# output

giardino

La funzione sum()

La funzione sum() restituisce la somma degli elementi di un oggetto iterabile:

sum(iterable, start=0)

Dove iterable è l'oggetto iterabile che si desidera sommare e start è il valore di

partenza opzionale della somma che per impostazione predefinita è uguale a

zero; quindi, se non viene specificato viene sommato il valore di tutti gli

elementi. Ad esempio, sommiamo con sum() tutti gli elementi da una lista di

numeri:

numeri = [33, 78, 5, 42, 23]

totale = sum(numeri)

print(totale)

# output

181

Vediamo cosa succede se impostiamo a 100 il valore di partenza:

totale = sum(numeri, 100)

print(totale)

# output

281

La funzione enumerate()

La funzione enumerate() consente di iterare su una sequenza (liste, tuple,

stringhe, ecc.) e restituire una tupla contenente il valore dell'elemento corrente

e il suo indice:

enumerate(sequence, start=0)

Dove sequence è la sequenza da iterare e start è l'indice di partenza per la

numerazione (il valore predefinito è 0). Ad esempio, se vogliamo stampare il

nome di ogni frutto di una lista insieme al suo indice, possiamo utilizzare la

funzione enumerate() in questo modo:

frutta = ["mela", "banana", "kiwi", "arancia"]

for indice, frutto in enumerate(frutta):

print(indice, frutto)

# output

0 mela

1 banana

2 kiwi

3 arancia

In questo caso enumerate() restituisce una sequenza di tuple contenenti

l'indice e il valore corrente della lista frutta. Queste tuple vengono assegnate

alle variabili indice e frutto e vengono utilizzate all'interno del ciclo for per

stampare il nome del frutto insieme al suo indice.

Se non c’è bisogno di utilizzare l'indice si può utilizzare l'underscore _ al posto

della variabile indice:

frutta = ["mela", "banana", "kiwi", "arancia"]

for _, frutto in enumerate(frutta):

print(frutto)

# output

mela

banana