Quanto si e' detto a proposito dell'indicizzazione degli elementi di una lista e' riassunto nella seguente figura che fa riferimento alla lista che contiene i caratteri della parola 'hello'
Una lista e' un insieme ordinato di elementi che in generale sono eterogenei. Il termine 'ordinato' sta a dire che c'e' un primo oggetto, un secondo oggetto etc. etc. e non riflette necessariamente l'ordinamento degli elementi nella lista secondo un criterio.
una lista si crea 'letteralmente' con le parentesi quadre e gli elementi separati da virgole:
lista_interi = [1,5,-2] # questa e' una lista di interi
lista_interi
lista_varie = [1,"ciao",True] #questa e' una lista che contiene elementi di diverso tipo
lista_varie
Le liste possono contenere davvero qualsiasi tipo di oggetto:
import math
l=[math , math.sin ,type(25.)]
#una lista che contiene un modulo (l[0]), una funzione (l[1]) ed un tipo di dati (l[2])
l
#per creare una lista vuota
l1 = []
l2 = list()
print(l1,l2)
Oltre a poter creare una lista vuota (vedi sopra) ...
#per creare una lista e riempirla
l1 = [1 , 'ciao' , 10.6]
l2 = list(l1) #creo una copia della lista passata come argomento
print(l1,l2)
pi ù in generale, la funzione list restituisce una lista a partire da altri tipi di sequenze:
l=list('stringa')
print(l)
I range sono oggetti diversi dalle liste che sono usati direttamente quando vogliamo 'iterare' su sequenze di interi (solo un accenno l'iterazione ed il ciclo for li approfondiremo in seguito).
for i in range(10):
print(i)
I range sono veri e propri tipi di dati ma in realta' per un uso di base noi li utilizzeremo alla stregua di funzioni ...
type(range(10))
In particolare sono usati molto spesso insieme alla funzione list per generare liste di interi con la sintassi:
dove le parentesi quadre indicano gli argomenti opzionali ed i relativi valori predefiniti
n=10
list(range(n))
ni=3
nf=10
list(range(ni,nf))
ni=3
nf=12
ns=3
list(range(ni,nf,ns))
a=range(100000)
Ci sono diverse funzioni che operano su liste, ad esempio la funzione (len) determina il numero di elementi di una lista. Queste funzioni richiedono che si indichi come argomento la lista di cui si vogliono contare gli elementi.
len(l)
print(l)
La funzione sorted ordina gli elementi di una lista (in senso decrescente se si imposta a True il parametro bool reversed).
sorted([2,5,9,1,34])
sorted([2,5,9,1,34],reverse=True)
Le funzioni che operano su liste il piu' delle volte restituiscono una copia elaborata della lista di partenza:
l=[6,5,8,3,2,1]
m=sorted(l)
print(l)
print(m)
è possibile specificare un criterio di ordinamento diverso da quello standard (operatore < applicato agli elementi della lista) specificando una funzione in modo che l'ordinamento avvenga in base al valore restituito dalla funzione per cisacuno degli elementi della lista
data una lista di stringhe
l=['aa','Assfsfsffssw','asdasf','SDDFhoiumn,mi','DGGuuyDSD','dSSDSD']
sorted(l)
ordino la lista per lunghezza
sorted(l,key=len)
ho usato come key la funzione predefinita len
oppure la ordino in base al contenuto del secondo carattere:
def mykey(s):
#restituisco il secondo carattere
return s[1]
sorted(l,key=mykey)
se voglio trascurare le maiuscole e le minuscole:
def mykey(s):
#restituisco il secondo carattere
return s[1].lower()
l.pop()
sorted(l,key=mykey)
vediamo un esempio: voglio ordinare una lista contenente degli angoli in gradi
#lista degli angoli tra 0 e 180
l = list(range(0,190,10))
print(l)
ordinandoli secondo il valore del valore assoluto del coseno
definisco una funzione che definisce il criterio da usare per ordinare la lista
def myorderingfunc(i):
# restituisce il valore assoluto del coseno
# per un angolo i specificato in gradi
return abs(cos(2*pi*i/180))
ordino la lista con sorted:
#lista ordinata per valore del coseno
print(sorted(l,key=myorderingfunc))
altre funzioni Built-in analoghe ...
l=[1,23,5,8,9.099,4]
lr=reversed(l)
print(l)
print(lr)
ooops
print(list(lr))
somma gli elementi della lista:
l = list(range(1,10))
sum(l)
con un valore iniziale diverso da 0 :
__builtin__.sum(l,5)
Ci sono anche funzioni intrinsecamente associate ad una specifica lista.
Si parla di funzioni membro dell'oggetto lista e costituiscono un primo elemento di programmazione ad oggetti.
Queste funzioni si invocano con il punto tra il nome della lista (prima) ed il nome della funzione (dopo).
A differenza delle funzioni che agiscono sulle liste, le funzioni membro in genere effettuano le eventuali modifiche in-place.
Vediamo ad esempio la funzione membro sort
l=[6,5,8,3,2,1]
print('prima: ',l)
l.sort()
print('dopo',l)
Ad esempio la funzione count conta il numero di occorrenze nella lista dell'elemento indicati tra parentesi
l
l.count(1)
la funzione append aggiunge l'elemento indicato tra parentesi in fondo alla lista:
l.append(1)
l.append(1)
l.append(1)
print(l)
l.count(1)
Oltre a sort c' è anche una reverse:
#per ordinare la lista oltre alla funzione builtin sorted
#possiamo usare il metodo sort o il metodo reverse della classe lista
l=[1,5,2,1,4,6,4,5]
l.sort()
print(l)
l.reverse()
print(l)
#determinazione dell'indice di un elemento
l.index(2)
#se ci sono pi ù elementi con lo stesso valore
#index restituisce l'indice del primo che trova
l.index(5)
Gli elementi contenuti nella lista sono indicizzabili e l'indice parte da zero
Accedo al primo elemento con l'indice 0
l = [1,5,-2]
l[0]
Se cerco di accedere ad un elemento inesistente Python mi segnala un IndexError:
l[5]
Accedo all'ultimo elemento della lista con l'indice -1
print(l)
l[-1]
Accedo al penultimo elemento della lista con l'indice -2
l[-2]
Quanto si e' detto a proposito dell'indicizzazione degli elementi di una lista e' riassunto nella seguente figura che fa riferimento alla lista che contiene i caratteri della parola 'hello'
l=list('Hello')
l[-5]
Consideriamo una lista che contiene i numeri interi da 10 a 200 presi a passi di 10.
per creare una lista simile (ed evitare di digitare tutti gli interi della lista) si utilizza la funzione range
l=list(range(10,200,10))
#NB:range(start, stop, step) dove stop NON viene incluso nella lista!!!!
print(l)
posso estrarre una sotto-lista, ad esempio che va dal primo elemento (indice 0) al secondo (1)
#[i-start : i-stop]
#con l'elemento con indice i-stop non incluso
l[0:2]
#dal primo (0) al sesto (5) (compreso)
l[0:6]
#dal 7mo (6) fino alla fine
l[6:]
#dal 7mo (6) al penultimo
l[6:-1]
#Gli ultimi sei elementi
#se non specifico il secondo elemento si intende 'FINO ALLA FINE'
l[-6:]
#Tutti gli elementi tranne gli ultimi sei
#se non specifico il primo elemento dello slice si intende 'DALL'INIZIO'
l[:-6]
#occhio a non invertire l'ordine degli indici
#altrimenti si ottiene una lista vuota
l[6:1]
#negli slice posso specificare anche un 'passo':
#dal primo al decimo elemento a passi di due
l[0:10:2]
NB: con la notazione l[:] ottengo una COPIA della lista originaria
l2 = l[:]
print(l2 == l)
print(l2 is l)
Le liste sono oggetti mutable (modificabili) i cui elementi possono cioe' essere modificati 'in-place' (senza cioe' che cambi l'id dell'oggetto):
print('l=',l)
print('id(l)=',id(l))
#modifico il primo elemento
l[0]=1000000
print('l=',l)
print('id(l) =',id(l))
Ho modificato la lista ma l'id e' rimasto lo stesso.
vediamo cosa succedeva con un oggetto di tipo NON-mutable (un intero ad esempio):
a=10000000000000222334
print('id(a)=',id(a))
a=1000222334
print('id(a)=',id(a))
a=10000000000000222334 ## lo stesso valore di 4 righe sopra
print('id(a)=',id(a))
Il fatto che le liste possano contenere oggetti di diverso tipo rende oneroso l'accesso ai loro elementi (complessita' o(n) per l'accesso all'n-esimo elemento)
l=list(range(10))
print(l)
#inserimento di un elemento in fondo alla lista con append
l.append('aa')
print(l)
#estensione di una lista con extend
l.extend(['bb','cc'])
print(l)
#inserimento di un elemento in un generico punto della lista
l.insert(3,'nuovo')
print(l)
#inserimento con slice
l[4:4]=['y','y','y','y']
print(l)
#sostituzione con slice
l[4:8]=['z','z2','z','z2']
print(l)
#rimozione con remove
print(l)
#la prima occorenza di un elemento passato per valore
l.remove('nuovo')
print(l)
l.remove('z')
print(l)
#se l'elemento non c'e' ...
l.remove('nuovo')
#rimozione con pop dell'ultimo elemnto della lista (pop() senza argomenti)
print(l)
print("Ho rimosso l'elemento:",l.pop())
print(l)
print("Ho rimosso l'elemento:",l.pop())
print(l)
#rimozione con pop dell'elemento con indice i
print(l)
print("Ho rimosso l'elemento:",l.pop(2))
print(l)
NB: pop restituisce l'elemento rimosso dalla lista
#rimozione con slice
print(l)
l[2:6]=[] # cancello dal terzo al sesto elemento
print(l)
Posso anche usare la funzione builtin del che acccetta anche slice:
l=list(range(10))
print(l)
#cancello un elemento
del(l[8])
print(l)
#cancello pi ù elementi anche non contigui
del(l[1:6:2])
print(l)
Introduciamo un altro elemento di sintassi che qui applicheremo specificatamente alle liste.
Se in un linguaggio come il C++ vogliamo eseguire ciclicamente un operazione sugli elementi di un vettore, normalmente si usa un ciclo for basato sugli indici del vettore stesso
In Python posso 'iterare' sugli indici (come in c):
#creo la lista di partenza
v = list(range(10,100,10))
print(v)
#creo la lista vuota che conterra' il risultato dell'iterazione
vsq = []
#ciclo sugli indici (a la C++):
for i in range(len(v)):
#inserisco il quadrato nella lista dei risultati
vsq.append(v[i]**2)
print(vsq)
Ma posso iterare direttamente sugli elementi di v:
vsq=[]
#ciclo direttamente sugli elementi di v
for val in v:
vsq.append(val**2)
print(vsq)
Per iterare sugli elementi della lista abbiamo utilizzato il ciclo for che in python ha la seguente sintassi:
Nell'utilizzo interattivo di Python la prima pressione di invio dopo un istruzione all'interno di un ciclo permette di inserire una nuova istruzione all'interno del ciclo stesso.
Se premo una seconda volta invio si esce dal ciclo e si eseguono le istruzioni.
La sequenza sulla quale itero puo' essere un lista ma anche altre tipi di sequenze che vedremo in seguito (stringhe, touple ...)
for s in 'stringa':
print(3*s)
Gli oggetti sui quali posso iterare con un ciclo for sono detti appunto iterabili
La funzione enumerate restituisce sia l'indice sia l'elemento della sequenza sulla quale si sta iterando:
ln=['Mario','Luigi','Anna','Paolo']
for indice,nome in enumerate(ln):
print(indice,nome)
list(enumerate(ln))
#vediamo cosa restituisce la funzione enumerate:
list(enumerate(ln))
Per iterare nello stesso ciclo su due o pi ù sequenze contemporaneamente, queste possono essere accoppiate con la funzione zip.
domande = ['Cibo', 'Colore', 'Sport']
prime_scelte = ['bistecca', 'rosso', 'bocce']
seconde_scelte = ['lasagne', 'verde', 'parapendio']
for d, ps, ss in zip(domande, prime_scelte, seconde_scelte):
print(d+" preferito:"+ps+" e poi "+ss)
list(zip(domande, prime_scelte, seconde_scelte))
Se le sequenze hanno lunghezze diverse l'iterazione si ferma all'ultimo elemento della sequenza pi ù corta.
La List comprehensions e' un modo conciso per creare nuove liste.
Uso tipico:
Sostanzialmente si tratta di integrare un (o piu') ciclo for all'interno di una definizione di lista.
Come spesso accade un esempio vale pi ù di molte parole ....
#riprendiamo il caso dei quadrati visto per il ciclo for
vsq=[] #inizializzo
for val in range(10,100,10): #itero
vsq.append(val**2) #aggiungo
print(vsq)
vsq = [v**2 for v in range(10,100,10)] #tutto in una botta!
print(vsq)
Sintassi:
Un tipico utilizzo della list comprehension e' quello di applicare una o pi ù funzioni a tutti gli elementi di una lista:
l = [-1,-20,40,-90 , 80, -50]
print(l)
#valore assoluto
l1 = [abs(x) for x in l]
print(l1)
#ordinamento + valore assoluto
l2 = [abs(x) for x in sorted(l)]
print(l2)
La list comprehension puo' essere nidificata (una list comprehension al posto della espressione)
#quale e' il contenuto di l2 ?
l2 = [ [i*j for i in range(1,5)] for j in range(10,60,10)]
l2
spezziamo in due cicli for distinti:
#creo una lista vuota
l2=[]
for j in range(10,60,10):
#creo una sotto lista vuota e la aggiungo in fondo a l2
l2.append([])
for i in range(1,5):
#appendo i*j in fondo all'ultima lista aggiunta alla lista l2
l2[-1].append(i*j)
print(l2)
......1 riga di codice contro 5 .......
#aggiungiamo una proposizione if ed estraiamo solo i valori tra 1000 e 5000
vsq = [v**2 for v in range(10,100,10) if (v**2 > 1000.0) and (v**2 < 5000.0) ]
print(vsq)
b=False
vsq = [v**2 for v in range(10,100,10) if b]
print(vsq)
Per usare una proposizione if con clausola else in una list comprehension, e' necessario usare l'operatore ternario che e' un costrutto if che si riconduce ad una singola espressione:
esempio di utilizzo operatore ternario:
cond = 1
print('Vero') if cond else print('Falso')
uso di operatore ternario in una list comprehension
[(v**2 if v<5 else v**3) for v in range(1,10) ]