Indice
Definizione di stringa, lista e tupla (sequenze)
Costruzione di una sequenza
Dimensioni di una sequenza
Indicizzazione e accesso agli elementi di una sequenza
Concatenazione di sequenze
Ripetizione dei una sequenza
Scansione degli elementi di una sequenza
Aggiornamento di una lista
Assegnamento multiplo
List comprehension
La funzione
enumerate()Strutture di controllo (selezione e iterazione)
Stringhe, liste e tuple sono sequenze, cioé oggetti su cui si può iterare i cui elementi sono indicizzati tramire la loro posizione.
Stringa:
strNOTA BENE: il singolo carattere in Python una stringa di un solo carattere.
Lista:
listTupla:
tuple
In [195]:
'ciao'
Out[195]:
Inseririmento nella stringa di singoli apici:
In [196]:
'\'ciao\''
Out[196]:
Esempio di letterale con doppi apici:
In [197]:
"ciao"
Out[197]:
Inserimento nella stringa di doppi apici:
In [198]:
"\"ciao\""
Out[198]:
Con i singoli apici si possono inserire nella stringa i doppi apici (e viceversa). Ad esempio:
In [199]:
'"ciao"'
Out[199]:
In [200]:
"'ciao'"
Out[200]:
Inserimento nella stringa del carattere di backslash \:
In [201]:
'\\ciao\\'
Out[201]:
In [202]:
"\\ciao\\"
Out[202]:
Inserimento nella stringa del carattere di newline \n:
In [203]:
stringa = 'ciao\n'
print(stringa)
In [204]:
stringa = "ciao\n"
print(stringa)
Costruzione della stringa vuota:
In [205]:
''
Out[205]:
In [206]:
""
Out[206]:
Stringa vuota:
In [207]:
str()
Out[207]:
Costruzione con letterale stringa:
In [208]:
str("ciao\n")
Out[208]:
Costruzione con espressione aritmetica:
In [209]:
str(3+4)
Out[209]:
Costruzione con espressione di confronto:
In [210]:
str(34 > 0)
Out[210]:
NOTA BENE: il valore restituito dalla chiamata str(34 >0) è la stringa dei caratteri T, r, u ed e e non il valore True di tipo bool.
Costruzione con sequenza:
In [211]:
str((1,'2'))
Out[211]:
NOTA BENE: il valore restituito dalla chiamata str((1,'2')) è la stringa corrispondente al letterale '(1, '2')' e non la tupla composta dall'intero 1 e dalla stringa dell'unico simbolo di cifra 2.
Lista vuota:
In [212]:
[]
Out[212]:
Lista di un solo valore:
In [213]:
[4]
Out[213]:
Lista di tre valori dello stesso tipo:
In [214]:
[1, 2, 3]
Out[214]:
Lista di tre valori di tipo diverso:
In [215]:
[4, 5, '6']
Out[215]:
Lista di tre valori di tipo diverso di cui il terzo di tipo list (lista annidata):
In [216]:
[7, 8.9, [True,'ciao']]
Out[216]:
Lista vuota:
In [217]:
list()
Out[217]:
Costruzione con sequenze:
In [218]:
list('abcdef')
Out[218]:
In [219]:
list([1,2,3])
Out[219]:
In [220]:
list((1,2,3))
Out[220]:
Tupla vuota:
In [221]:
()
Out[221]:
Tupla di un solo valore:
In [222]:
(4,)
Out[222]:
NOTA BENE: la virgola è necessaria, in quanto il letterale (4) rappresenta l'intero 4.
In [223]:
(4)
Out[223]:
Tupla di tre valori dello stesso tipo:
In [224]:
(1, 2, 3)
Out[224]:
Tupla di tre valori di tipo diverso:
In [225]:
(4, 5, '6')
Out[225]:
Tupla di quattro valori di tipo diverso di cui il terzo di tipo list (lista annidata) e il quarto di tipo tuple (tupla annidata):
In [226]:
(7, 8.9, [True,'ciao'], (1,2,3))
Out[226]:
NOTA BENE: le parentesi tonde sono opzionali.
In [227]:
4,
Out[227]:
In [228]:
1, 2, 3
Out[228]:
In [229]:
4, 5, '6'
Out[229]:
In [230]:
7, 8.9, [True,'ciao'], (1,2,3)
Out[230]:
NOTA BENE: le parentesi tonde non possono essere omesse nel caso di tupla vuota.
Tupla vuota:
In [231]:
tuple()
Out[231]:
Costruzione con sequenze:
In [232]:
tuple('abcdef')
Out[232]:
In [233]:
tuple([1, 2, 3])
Out[233]:
In [234]:
tuple((1, 2, 3))
Out[234]:
La funzione len() restituisce la dimensione della sequenza passata come argomento.
In [235]:
len('abc')
Out[235]:
In [236]:
len([1, 2, 3, 4, 5])
Out[236]:
In [237]:
len((1, 2, 3, 4, 5))
Out[237]:
Le posizioni degli elementi di una sequenza my_sequence sono indicate tramite:
len(my_sequence)-1 (posizione dell'ultimo elemento)-len(my_sequence) (posizione del primo elemento)L'espressione:
my_sequence[some_index]
restituisce l'elemento della sequenza my_sequence in posizione some_index.
Esempi di accesso a un carattere di una stringa
Accesso tramite indice positivo:
In [238]:
stringa = 'Hello world!'
stringa[4]
Out[238]:
NOTA BENE: stringa[4] restituisce un oggetto di tipo str.
Accesso tramite indice negativo:
In [239]:
stringa[-2]
Out[239]:
Esempi di accesso a un elemento di una lista
Accesso tramite indice positivo:
In [240]:
lista = [1, 2, 3, [4, 5]]
lista[2]
Out[240]:
In [241]:
lista[3]
Out[241]:
Accesso al primo elemento della lista annidata in posizione di indice 3:
In [242]:
lista[3][0]
Out[242]:
Accesso tramite indice negativo:
In [243]:
lista[-len(lista)]
Out[243]:
Esempi di accesso a un elemento di una tupla
Accesso tramite indice positivo:
In [244]:
tupla = (1, 2, 3, 4)
tupla[2]
Out[244]:
Accesso tramite indice negativo:
In [245]:
tupla[-1]
Out[245]:
L'epressione:
my_sequence[start_index:end_index]
restituisce gli elementi della sequenza my_sequence da quello in posizione start_index fino a quello in posizione end_index-1.
In particolare:
my_sequence[start_index:] restituisce gli elementi da quello in posizione start_index fino all'ultimomy_sequence[:end_index] restituisce gli elementi dal primo fino a quello in posizione end_index-1my_sequence[:] restituisce tutti gli elementi dal primo fino all'ultimoNOTA BENE: l'oggetto restituito è sempre dello stesso tipo di my_sequence.
Esempi di accesso a caratteri consecutivi di una stringa (sottostringa):
In [246]:
stringa = 'Hello world!'
stringa[2:7]
Out[246]:
In [247]:
stringa = 'Hello world!'
stringa[-10:-5]
Out[247]:
In [248]:
stringa = 'Hello world!'
stringa[:]
Out[248]:
Esempi di accesso a elementi consecutivi di una lista (sottolista):
In [249]:
lista = [1, 2, 3, 4, 5, 6]
lista[2:4]
Out[249]:
In [250]:
lista = [1, 2, 3, 4, 5, 6]
lista[2:]
Out[250]:
In [251]:
lista = [1, 2, 3, 4, 5, 6]
lista[:4]
Out[251]:
Esempio di accesso a elementi consecutivi di una tupla (sottotupla):
In [252]:
tupla = (1, 2, 3, 4, 5, 6)
tupla[2:5]
Out[252]:
L'epressione:
my_sequence[start_index:end_index:step]
restituisce gli elementi della sequenza my_sequence da quello in posizione start_index fino a quello in posizione end_index-1 considerando il passo step (se step è uguale a 1, allora gli elementi saranno consecutivi).
NOTA BENE: l'oggetto restituito è sempre dello stesso tipo di my_sequence.
In [253]:
stringa = 'Hello world!'
stringa[2:7:2]
Out[253]:
Lo slicing con passo può essere utilizzato per invertire una stringa:
In [254]:
stringa = 'Hello world!'
stringa[-1:-len(stringa)-1:-1]
Out[254]:
In [255]:
stringa = 'Hello world!'
stringa[::-1]
Out[255]:
In [256]:
lista = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lista[2:7:3]
Out[256]:
Lo slicing con passo può essere utilizzato per invertire una lista (o una tupla):
In [257]:
lista = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lista[::-1]
Out[257]:
In [258]:
'ciao' + ' mondo!'
Out[258]:
In [259]:
[1, 2] + [3, 4, 5]
Out[259]:
In [260]:
('a', 'a') + (1, 1)
Out[260]:
In [261]:
'ciao' * 3
Out[261]:
In [262]:
[3, 4, 5] * 2
Out[262]:
In [263]:
('a', 'b') * 6
Out[263]:
L'espressione:
my_element in my_sequence
restituisce il valore True (di tipo bool) se l'elemento my_element è presente nella sequenza my_sequence.
NOTA BENE: nel caso di stringhe l'operatore in testa in generale la presenza di my_element come sottostringa; nel caso invece di liste e tuple testa la presenza di my_element come valore.
In [264]:
'H' in 'Hello world!'
Out[264]:
In [265]:
'world' in 'Hello world!'
Out[265]:
In [266]:
'ca' in [1, 2, 'acaa', 10.5]
Out[266]:
In [267]:
2 in ()
Out[267]:
Sintassi di scansione di una sequenza:
for element in my_sequence:
do_something
dove:
my_sequence è la sequenza i cui elementi sono da considerare uno dopo l'altro dal primo all'ultimoelement è la variabile che durante la scansione assume il valore dell'elemento di volta in volta consideratodo_something sono le istruzioni da eseguire per ogni elemento consideratoRegole:
do_something devono essere indentate 4 volte rispetto alla riga di intestazione
In [268]:
for c in 'world':
print(c)
In [269]:
for v in [3, 45.6, 'ciao']:
print(v)
In [270]:
for v in 3, 45.6, 'ciao':
print(v)
L'istruzione:
my_list[some_index] = new_value
sostituisce l'elemento della lista my_list in posizione some_index con il nuovo valore new_value.
In [271]:
lista = [1, 2, 3, 4, 5, 6, 7]
lista[3] = 0
lista
Out[271]:
L'istruzione:
my_list[start_index:end_index] = new_list
sostituisce la sottolista di my_list ottenuta tramite slicing con la lista new_list.
Sostituzione di tre elementi consecutivi:
In [272]:
lista = [1, 2, 3, 4, 5, 6, 7]
lista[3:6] = ['*', '*', '*']
lista
Out[272]:
Cancellazione di tre elementi consecutivi:
In [273]:
lista = [1, 2, 3, 4, 5, 6, 7]
lista[3:6] = []
lista
Out[273]:
Inserimento di tre elementi consecutivi:
In [274]:
lista = [1, 2, 3, 4, 5, 6, 7]
lista[1:1] = ['*', '*', '*']
lista
Out[274]:
Aggiunta in coda di tre elementi consecutivi:
In [275]:
lista = [1, 2, 3, 4, 5, 6, 7]
lista[len(lista):] = ['*', '*', '*']
lista
Out[275]:
Aggiunta in testa di tre elementi consecutivi:
In [276]:
lista = [1, 2, 3, 4, 5, 6, 7]
lista[0:0] = ['*', '*', '*']
lista
Out[276]:
NOTA BENE: il mutamento di una lista non è da confondere con il suo riassegnamento.
Mutamento: il riferimento all'oggetto non viene alterato.
In [305]:
lista = [1, 2, 3, 4, 5, 6, 7]
lista[1:3] = [8]
lista[0] = 'ciao'
lista
Out[305]:
Riassegnamento: viene creato un nuovo riferimento.
In [306]:
lista = [0, 0.0, False]
lista
Out[306]:
NOTA BENE: attenzione a quando si usa lo slicing con il passo per aggiornare una lista. Nell'esempio seguente l'operazione di slicing "estrae" gli elementi in posizione di indice positivo pari a partire dal primo. Siccome per la lista costruita gli elementi estratti sono quattro, nell'aggiornamento deve essere assegnata una lista di esattamente quattro elementi.
Estrazione degli elementi in posizione di indice pari:
In [279]:
lista = [1, 2, 3, 4, 5, 6, 7]
lista[0:len(lista):2]
Out[279]:
Aggiornamento degli elementi in posizione di indice pari:
In [280]:
lista[0:len(lista):2] = [0, 0, 0, 0]
lista
Out[280]:
L'istruzione:
del my_list[some_index]
rimuove dalla lista my_list l'elemento in posizione di indice some_index.
In [281]:
lista = [1, 2, 3, 4]
del lista[2]
lista
Out[281]:
L'istruzione:
del my_list[start_index:end_index:step]
rimuove dalla lista my_list gli elementi prodotti dall'operazione di slicing (il passo step è opzionale).
In [282]:
lista = [1, 2, 3, 4]
del lista[2]
lista
Out[282]:
In [283]:
lista = [1, 2, 3, 4, 5, 6, 7, 8]
del lista[2:5]
lista
Out[283]:
In [284]:
lista = [1, 2, 3, 4, 5, 6, 7, 8]
del lista[::2]
lista
Out[284]:
L'istruzione (in cui le parentesi tonde sono opzionali):
(my_var1, my_var2, ..., my_varN) = my_sequence
assegna alle N variabili specificate nella tupla a sinistra i valori (presi nello stesso ordine) della sequenza my_sequence specificata a destra.
NOTA BENE: la sequenza my_sequence deve avere dimensione pari a N.
In [285]:
v1, v2, v3, v4 = '1234'
In [286]:
v1
Out[286]:
In [287]:
v2
Out[287]:
In [288]:
v3
Out[288]:
In [289]:
v4
Out[289]:
In [290]:
v1, v2, v3, v4 = [1, 2, 3, 4]
In [291]:
v1
Out[291]:
In [292]:
v2
Out[292]:
In [293]:
v3
Out[293]:
In [294]:
v4
Out[294]:
In [311]:
v1, v2, v3, v4 = 1, 2, 3, 4
In [312]:
v1
Out[312]:
In [313]:
v2
Out[313]:
In [314]:
v3
Out[314]:
In [315]:
v4
Out[315]:
Assegnamento di una tupla di variabili:
In [316]:
v1, v2 = v2, v1
In [317]:
v1
Out[317]:
In [318]:
v2
Out[318]:
Esempio di assegnamento multiplo utilizzato per scandire una lista di tuple di due interi:
In [297]:
for (v1, v2) in [(1, 2), (3, 4), (5, 6)]:
print(str(v1)+' '+str(v2))
La list comprehension permette di creare liste in maniera molto concisa.
L'istruzione:
[some_expression for e1 in my_sequence1 for e2 in my_sequence2 ... for eN in my_sequenceN if condition]
equivale a scrivere:
for e1 in my_sequence1:
for e2 in my_sequence2:
...
for eN in my_sequenceN:
if condition
some_expression
con la differenza che i valori restituiti da some_expression vengono restituiti in un oggetto di tipo list.
In [298]:
[i+1 for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] if i % 2 == 0]
Out[298]:
In [299]:
[c + '1' for c in 'ciao']
Out[299]:
In [300]:
[c1 + str(i) + str(c2) for c1 in 'ciao' for i in [1, 2, 3, 4] for c2 in ('a', 'b', 'c')]
Out[300]:
La funzione enumerate():
enumerate(my_sequence, start)
restituisce gli elementi di my_sequence, ciasuno con il suo indice di posizione, in tuple di dimensione due. L'indice di posizione prima di essere restituito viene incrementato di start (che se omesso vale 0 di default).
L'oggetto restituito è di tipo enumerate e può essere interrogato all'occorrenza per restuire le tuple.
In [301]:
enum = enumerate('ciao', 1)
enum
Out[301]:
Basta ad esempio effettuare una scansione dell'oggetto per ottenere le sue tuple.
La seguente istruzione produce la lista (oggetto di tipo list) delle tuple dell'oggetto enum:
In [302]:
[t for t in enum]
Out[302]:
La seguente istruzione produce la lista (oggetto di tipo list) delle tuple con indice pari dell'oggetto enum:
In [2]:
enum = enumerate('ciao', 1)
[(i , e) for (i, e) in enum if i % 2 == 0]
Out[2]:
NOTA BENE: si è dovuto ricreare l'oggetto per poter produrre nuovamente le sue tuple. Una nuova scansione produrrebbe in questo caso una lista vuota
In [3]:
[(i , e) for (i, e) in enum if i % 2 == 0]
Out[3]:
Selezione if
if condition:
do_something
Se condition è un valore vero allora le istruzioni do_something vengono eseguite.
Selezione alternativa if-else
if condition:
do_something-if
else:
do_something-else
Se condition è un valore vero allora le istruzioni do_something-if vengono eseguite, altrimenti vengono eseguite le istruzioni do_something-else.
Selezione in serie if-elif-else
if condition1:
do_something1
elif condition2:
do_something2
elif condition3:
do_something3
...
else:
do_something-else
vengono eseguite le istruzioni do_something della prima condizione che risulta essere vera. Altrimenti vengono eseguite le istruzioni do_something-else.
NOTA BENE: i costrutti di selezione possono essere annidati l'uno nell'altro.
Ciclo while
while condition:
do-something