Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial

Liste in Python

Usare le liste per gestire collezioni ordinate di oggetti (generalmente omogenei), memorizzarne una sequenza ed accedere ad essi mediante un indice.
Usare le liste per gestire collezioni ordinate di oggetti (generalmente omogenei), memorizzarne una sequenza ed accedere ad essi mediante un indice.
Link copiato negli appunti

Python fornisce anche un tipo built-in chiamato lista, che viene solitamente usato per rappresentare una sequenza mutabile di oggetti, in genere omogenei.

Definire le liste

Le liste vengono definite elencando tra parentesi quadre ([]) una serie di oggetti separati da virgole (,). È possibile creare una lista vuota usando le parentesi quadre senza nessun elemento all'interno.

>>> nums = [0, 1, 2, 3] # nuova lista di 4 elementi
>>> nums
[0, 1, 2, 3]
>>> type(nums) # verifichiamo che il tipo sia "list"
<class 'list'>
>>> empty = [] # nuova lista vuota
>>> empty
[]
>>> one = ['Python'] # nuova lista con un elemento
>>> one
['Python']

Usare le liste

Così come le tuple e le stringhe, anche le liste sono un tipo di sequenza, e supportano quindi le operazioni comuni a tutte le sequenze, come indexing, slicing, contenimento, concatenazione, e ripetizione:

>>> letters = ['a', 'b', 'c', 'd', 'e']
>>> letters[0] # le liste supportano indexing
'a'
>>> letters[-1]
'e'
>>> letters[1:4] # slicing
['b', 'c', 'd']
>>> 'a' in letters # gli operatori di contenimento "in" e "not in"
True
>>> letters + ['f', 'g', 'h'] # concatenazione (ritorna una nuova lista)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> [1, 2, 3] * 3 # ripetizione (ritorna una nuova lista)
[1, 2, 3, 1, 2, 3, 1, 2, 3]

Le liste supportano anche funzioni e metodi comuni alle altre sequenze: len() per contare gli elementi, min() e max() per trovare l'elemento più piccolo/grande (a patto che i tipi degli elementi siano comparabili), .index() per trovare l'indice di un elemento, e .count() per contare quante volte un elemento è presente nella lista:

>>> letters = ['a', 'b', 'c', 'b', 'a']
>>> len(letters) # numero di elementi
5
>>> min(letters) # elemento più piccolo (alfabeticamente nel caso di stringhe)
'a'
>>> max(letters) # elemento più grande
'c'
>>> letters.index('c') # indice dell'elemento 'c'
2
>>> letters.count('c') # numero di occorrenze di 'c'
1
>>> letters.count('b') # numero di occorrenze di 'b'
2

A differenza di tuple e stringhe che sono immutabili, le liste possono essere mutate. È quindi possibile assegnare un nuovo valore agli elementi, rimuovere elementi usando la keyword del, o cambiare gli elementi usando uno dei metodi aggiuntivi delle liste:

  • lista.append(elem): aggiunge elem alla fine della lista;
  • lista.extend(seq): estende la lista aggiungendo alla fine gli elementi di seq;
  • lista.insert(indice, elem): aggiunge elem alla lista in posizione indice;
  • lista.pop(): rimuove e restituisce l'ultimo elemento della lista;
  • lista.remove(elem): trova e rimuove elem dalla lista;
  • lista.sort(): ordina gli elementi della lista dal più piccolo al più grande;
  • lista.reverse(): inverte l'ordine degli elementi della lista;
  • lista.copy(): crea e restituisce una copia della lista;
  • lista.clear(): rimuove tutti gli elementi della lista;

Vediamo alcuni esempi:

>>> letters = ['a', 'b', 'c']
>>> letters.append('d') # aggiunge 'd' alla fine
>>> letters
['a', 'b', 'c', 'd']
>>> letters.extend(['e', 'f']) # aggiunge 'e' e 'f' alla fine
>>> letters
['a', 'b', 'c', 'd', 'e', 'f']
>>> letters.append(['e', 'f']) # aggiunge la lista come elemento alla fine
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', ['e', 'f']]
>>> letters.pop() # rimuove e ritorna l'ultimo elemento (la lista)
['e', 'f']
>>> letters.pop() # rimuove e ritorna l'ultimo elemento ('f')
'f'
>>> letters.pop(0) # rimuove e ritorna l'elemento in posizione 0 ('a')
'a'
>>> letters.remove('d') # rimuove l'elemento 'd'
>>> letters
['b', 'c', 'e']
>>> letters.reverse() # inverte l'ordine "sul posto" e non ritorna niente
>>> letters # gli elementi sono ora in ordine inverso
['e', 'c', 'b']
>>> letters[1] = 'x' # sostituisce l'elemento in posizione 1 ('c') con 'x'
>>> letters
['e', 'x', 'b']
>>> del letters[1] # rimuove l'elemento in posizione 1 ('x')
>>> letters
['e', 'b']
>>> letters.clear() # rimuove tutti gli elementi rimasti
>>> letters
[]

Alcuni di questi metodi accettano anche argomenti aggiuntivi che potrete vedere usando help(list.metodo) o consultando la documentazione ufficiale sulle liste.

Differenze tra tuple e liste

Anche se a prima vista le liste possono sembrare delle "tuple mutabili", in realtà vengono usate in situazioni diverse. Riassumiamo le differenze tra tuple e liste:

tuple liste
Mutabilità immutabili mutabili
Lunghezza fissa variabile
Accesso agli elementi avviene tramite indexing iterazione
Di solito contengono oggetti eterogenei omogenei
Simile in C al tipo di dati struct array

Dato che le tuple sono immutabili, la loro lunghezza è fissa, e in genere ogni elemento della tupla ha un ruolo preciso. Questi elementi, che possono essere di tipi diversi, in genere vengono letti tramite indexing (tupla[indice]).

Le liste, invece, sono mutabili, quindi la loro lunghezza è variabile (elementi possono essere aggiunti o rimossi). Questo significa che gli elementi singoli non hanno un ruolo preciso e vengono in genere letti mediante iterazione (ad esempio usando un for), e perciò devono anche essere dello stesso tipo.

Un altro modo per capire la differenza, è pensare a una tabella di un database, come ad esempio:

Nome Cognome Età
John Smith 20
Jane Johnson 30
Jack Williams 28
Mary Jones 25
Mark Brown 23

Ogni riga della tabella può essere rappresentata con una tupla (es. ('John', 'Smith', 20)) di 3 elementi (lunghezza fissa) eterogenei (stringhe e interi) a cui possiamo accedere tramite indexing (es. t[1] per il cognome). Ogni colonna può essere rappresentata con una lista (es. ['John', 'Jane', 'Jack', ...]]) di lunghezza variabile (persone possono essere aggiunte o tolte) e elementi omogenei (la colonna del nome ha solo stringhe, quella dell'età solo numeri) che vengono accessi tramite iterazione (es. stampare la lista di cognomi usando un loop).

È inoltre possibile combinare i due tipi e rappresentare l'intera tabella come una lista di tuple:

[('John', 'Smith', 20),
('Jane', 'Johnson', 30),
('Jack', 'Williams', 28),
...]

Nella prossima lezione vedremo un altro tipo di dato built-in: i dizionari.

Ti consigliamo anche