# Liste, Tuple, Set e Dizionari Python offre diversi tipi di strutture dati per gestire e organizzare insiemi di valori. Le quattro principali strutture dati integrate sono: - **Liste** (list) - **Tuple** (tuple) - **Set** (set) - **Dizionari** (dict) Ogni struttura ha caratteristiche specifiche che la rendono utile per vari casi d'uso. --- ## Liste Le **liste** in Python sono **sequenze ordinate** di elementi, mutabili e dinamiche. Gli elementi possono essere di qualsiasi tipo e possono essere modificati, aggiunti o rimossi. ### Creazione di una lista ```python # Creazione di una lista vuota lista_vuota = [] # Creazione di una lista con elementi frutta = ["mela", "banana", "arancia"] numeri = [1, 2, 3, 4, 5] mista = [1, "ciao", True] ``` ### Accesso agli elementi della lista Gli elementi della lista sono indicizzati a partire da 0. ```python frutta = ["mela", "banana", "arancia"] print(frutta[0]) # Output: mela (primo elemento) print(frutta[-1]) # Output: arancia (ultimo elemento) ``` ### Modifica di una lista Le liste sono mutabili, quindi possiamo cambiare, aggiungere o rimuovere elementi. ```python frutta = ["mela", "banana", "arancia"] # Modifica di un elemento frutta[1] = "pera" print(frutta) # Output: ['mela', 'pera', 'arancia'] # Aggiunta di un elemento frutta.append("kiwi") print(frutta) # Output: ['mela', 'pera', 'arancia', 'kiwi'] # Rimozione di un elemento frutta.remove("mela") print(frutta) # Output: ['pera', 'arancia', 'kiwi'] ``` ### Operazioni comuni sulle liste ```python frutta = ["mela", "banana", "arancia"] # Lunghezza della lista lunghezza = len(frutta) print(lunghezza) # Output: 3 # Verifica della presenza di un elemento esiste = "banana" in frutta print(esiste) # Output: False # Concatenazione di liste lista1 = [1, 2, 3] lista2 = [4, 5, 6] lista_concatenata = lista1 + lista2 print(lista_concatenata) # Output: [1, 2, 3, 4, 5, 6] ``` --- ## Tuple Le **tuple** sono simili alle liste, ma sono **immutabili**, il che significa che una volta create, non possono essere modificate. Le tuple sono utili quando si vogliono memorizzare valori che non devono cambiare. ### Creazione di una tupla ```python # Creazione di una tupla mesi = ("Gennaio", "Febbraio", "Marzo") numeri = (1, 2, 3, 4) ``` ### Accesso agli elementi di una tupla Come nelle liste, puoi accedere agli elementi di una tupla utilizzando gli indici. ```python mesi = ("Gennaio", "Febbraio", "Marzo") print(mesi[0]) # Output: Gennaio print(mesi[-1]) # Output: Marzo ``` ### Caratteristiche delle tuple - Le tuple **non possono essere modificate** dopo la loro creazione. - Le tuple possono essere **concatenate** o **moltiplicate** come le liste. ```python # Concatenazione di tuple t1 = (1, 2, 3) t2 = (4, 5, 6) tupla_concatenata = t1 + t2 print(tupla_concatenata) # Output: (1, 2, 3, 4, 5, 6) ``` ### Uso di tuple con una singola variabile Quando si lavora con funzioni che restituiscono più valori, spesso si utilizzano tuple. ```python def coordinate(): return (10, 20) x, y = coordinate() print(x, y) # Output: 10 20 ``` --- ## Set I **set** sono collezioni non ordinate di elementi **unici**. Non permettono duplicati e sono mutabili (tranne per il tipo `frozenset`, che è immutabile). ### Creazione di un set ```python # Creazione di un set numeri = {1, 2, 3, 4} ``` ### Aggiungere e rimuovere elementi ```python numeri = {1, 2, 3} # Aggiungere un elemento numeri.add(4) print(numeri) # Output: {1, 2, 3, 4} # Rimuovere un elemento numeri.remove(2) print(numeri) # Output: {1, 3, 4} ``` ### Operazioni sui set I set supportano varie operazioni matematiche come **unione**, **intersezione** e **differenza**. ```python set1 = {1, 2, 3} set2 = {3, 4, 5} # Unione (elementi presenti in entrambi i set) unione = set1 | set2 print(unione) # Output: {1, 2, 3, 4, 5} # Intersezione (elementi comuni ai due set) intersezione = set1 & set2 print(intersezione) # Output: {3} # Differenza (elementi in set1 ma non in set2) differenza = set1 - set2 print(differenza) # Output: {1, 2} ``` ### Verifica della presenza di un elemento ```python numeri = {1, 2, 3} esiste = 2 in numeri print(esiste) # Output: True ``` --- ## Dizionari I **dizionari** (o **dict**) sono collezioni di coppie chiave-valore, in cui ogni chiave è associata a un valore. I dizionari sono mutabili, e le chiavi devono essere **uniche**. ### Creazione di un dizionario ```python # Dizionario con chiavi e valori studente = { "nome": "Mario", "età": 23, "corsi": ["Matematica", "Informatica"] } ``` ### Accesso ai valori tramite le chiavi ```python print(studente["nome"]) # Output: Mario print(studente["corsi"]) # Output: ['Matematica', 'Informatica'] ``` ### Modifica e aggiunta di elementi ```python # Modifica di un valore studente["età"] = 24 print(studente) # Output: {'nome': 'Mario', 'età': 24, 'corsi': ['Matematica', 'Informatica']} # Aggiunta di una nuova coppia chiave-valore studente["email"] = "mario.rossi@email.com" print(studente) # Output: {'nome': 'Mario', 'età': 24, 'corsi': ['Matematica', 'Informatica'], 'email': 'mario.rossi@email.com'} ``` ### Operazioni comuni sui dizionari ```python # Ottenere tutte le chiavi del dizionario chiavi = studente.keys() print(chiavi) # Output: dict_keys(['nome', 'età', 'corsi', 'email']) # Ottenere tutti i valori del dizionario valori = studente.values() print(valori) # Output: dict_values(['Mario', 24, ['Matematica', 'Informatica'], 'mario.rossi@email.com']) # Verifica dell'esistenza di una chiave esiste = "nome" in studente print(esiste) # Output: True ``` ### Rimozione di elementi ```python # Rimuovere una coppia chiave-valore del studente["email"] print(studente) # Output: {'nome': 'Mario', 'età': 24, 'corsi': ['Matematica', 'Informatica']} ``` ## Slicing Lo **slicing** in Python è una potente tecnica che permette di ottenere una porzione (o "fetta") di una sequenza, come una lista, una stringa o una tupla, senza modificarne il contenuto originale. Lo slicing consente di specificare l'indice di inizio, l'indice di fine e un passo per selezionare gli elementi. La sintassi di base dello slicing è: ```python sequenza[inizio:fine:passo] ``` - **inizio**: indice da cui partire (inclusivo). - **fine**: indice a cui fermarsi (esclusivo). - **passo**: salto tra gli elementi selezionati (opzionale). Se non specificato, il valore predefinito è 1. ### Slicing su Liste Le liste supportano pienamente lo slicing. Ecco come puoi ottenere un sottoinsieme di elementi da una lista: ```python frutta = ["mela", "banana", "arancia", "kiwi", "limone"] # Slicing di base: ottenere i primi tre elementi prime_tre = frutta[:3] print(prime_tre) # Output: ['mela', 'banana', 'arancia'] # Ottenere gli elementi dal secondo al quarto (indice 1 a 3) dal_secondo_al_quarto = frutta[1:4] print(dal_secondo_al_quarto) # Output: ['banana', 'arancia', 'kiwi'] # Ottenere tutti gli elementi tranne gli ultimi due senza_ultimi_due = frutta[:-2] print(senza_ultimi_due) # Output: ['mela', 'banana', 'arancia'] # Ottenere gli ultimi tre elementi ultimi_tre = frutta[-3:] print(ultimi_tre) # Output: ['arancia', 'kiwi', 'limone'] ``` ### Slicing con Passo Il terzo parametro, **passo**, indica il salto tra gli elementi selezionati. Può essere utilizzato per ottenere elementi a intervalli regolari o invertire l'ordine di una sequenza. ```python numeri = [1, 2, 3, 4, 5, 6, 7, 8, 9] # Ottenere tutti gli elementi con un passo di 2 ogni_due = numeri[::2] print(ogni_due) # Output: [1, 3, 5, 7, 9] # Ottenere gli elementi dal secondo al settimo con un passo di 2 dal_secondo_con_passo = numeri[1:7:2] print(dal_secondo_con_passo) # Output: [2, 4, 6] # Invertire la lista usando un passo negativo invertito = numeri[::-1] print(invertito) # Output: [9, 8, 7, 6, 5, 4, 3, 2, 1] ``` ### Slicing su Stringhe Anche le stringhe supportano lo slicing. È utile quando vuoi ottenere una parte di una stringa, come un prefisso o un suffisso. ```python testo = "Python è fantastico" # Ottenere i primi sei caratteri primi_sei = testo[:6] print(primi_sei) # Output: 'Python' # Ottenere gli ultimi nove caratteri ultimi_nove = testo[-9:] print(ultimi_nove) # Output: 'fantastico' # Ogni secondo carattere ogni_secondo = testo[::2] print(ogni_secondo) # Output: 'Pto èfnatsc' ``` ### Slicing su Tuple Le tuple, essendo simili alle liste, supportano anche lo slicing. Tuttavia, essendo immutabili, non possono essere modificate. ```python giorni = ("Lunedì", "Martedì", "Mercoledì", "Giovedì", "Venerdì", "Sabato", "Domenica") # Ottenere i giorni lavorativi lavorativi = giorni[:5] print(lavorativi) # Output: ('Lunedì', 'Martedì', 'Mercoledì', 'Giovedì', 'Venerdì') # Ottenere il weekend weekend = giorni[-2:] print(weekend) # Output: ('Sabato', 'Domenica') # Invertire l'ordine della tupla invertito = giorni[::-1] print(invertito) # Output: ('Domenica', 'Sabato', 'Venerdì', 'Giovedì', 'Mercoledì', 'Martedì', 'Lunedì') ``` --- ### Slicing con valori predefiniti Quando ometti uno dei parametri in uno slicing, Python utilizza i valori predefiniti: - Se non specifichi **l'indice di inizio**, Python parte dall'inizio della sequenza. - Se non specifichi **l'indice di fine**, Python va fino alla fine della sequenza. - Se non specifichi **il passo**, Python utilizza un passo di 1. ```python numeri = [10, 20, 30, 40, 50, 60] # Slicing dall'inizio fino all'indice 3 (esclusivo) print(numeri[:3]) # Output: [10, 20, 30] # Slicing dall'indice 2 fino alla fine print(numeri[2:]) # Output: [30, 40, 50, 60] # Slicing con passo di 1 (predefinito) print(numeri[::1]) # Output: [10, 20, 30, 40, 50, 60] ``` --- ### Uso di slicing con assegnazione (solo per liste) In Python, lo slicing può essere utilizzato per assegnare nuovi valori a un sottoinsieme di una lista. ```python numeri = [1, 2, 3, 4, 5] numeri[1:4] = [10, 11, 12] print(numeri) # Output: [1, 10, 11, 12, 5] ``` ### Rimozione di elementi con slicing Puoi anche rimuovere elementi da una lista assegnando una lista vuota allo slice: ```python numeri = [1, 2, 3, 4, 5] numeri[1:3] = [] print(numeri) # Output: [1, 4, 5] ```