# Tuple in Python: come creare liste immutabili

Le tuple in Python sono collezioni di dati diversi o uguali, contrassegnati da un indice e non modificabili. Sono create come le classiche liste nei [linguaggi di programmazione web](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/linguaggi-programmazione-web/).

## Cosa sono le tuple in Python?

A prima vista, le tuple assomigliano alle ben note [liste in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/liste-in-python/). In entrambi i casi si tratta di elenchi che possono contenere e memorizzare molti tipi di contenuti diversi, presentati quindi in modo chiaro. C’è però una differenza: il contenuto di una tupla in Python è immutabile. Ciò significa che **una volta che le tuple sono state riempite di contenuto, questo rimane invariato e non può essere cancellato**. Ciò è particolarmente utile se il contenuto è costituito da costanti che devono assolutamente essere mantenute nella loro forma e composizione attuale. Utilizzando le tuple in Python, si può essere certi che il contenuto sia nella sua forma originale.

I contenuti di una tupla sono scritti in un ordine fisso, che non può essere modificato in seguito. A ogni singolo valore vengono assegnati i numeri di indice noti da qualsiasi [tutorial su Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tutorial-python/), a partire da 0. I singoli contenuti all’interno della tupla in Python possono avere gli stessi valori, in quanto possono comunque essere distinti dai numeri di indice. La sua lunghezza non è limitata e il suo contenuto può **teoricamente essere costituito da tutti i tipi di dati possibili**.

## Come vengono create le tuple in Python?

Le tuple in Python sono formate da **parentesi tonde** e il loro contenuto è separato da virgole. Per l’output si utilizza la funzione print. Una tupla si presenta così:

```none
tup = ("primo_valore", "secondo_valore", "terzo_valore")
print(tup)
```

È anche possibile formare una tupla con un solo elemento. In questo caso, però, è importante che dopo l’elemento venga messa una virgola, altrimenti il programma non può riconoscere le tuple e le considera alla stregua di stringhe con parentesi tonde. Questa è la notazione corretta in questo caso:

```none
tup = ("singolo_valore",)
print(tup)
```

## Esempi di tuple in Python

Quindi, se volete creare tuple in Python, usate le parentesi tonde e mettete tutte le informazioni importanti nel giusto ordine. Come già menzionato, le tuple possono contenere diversi tipi di dati. Sono quindi possibili semplici [stringhe in Python](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/stringhe-in-python/ "Stringhe in Python"):

```none
animali = ("cane", "gatto", "topo")
```

Valori numerici:

```none
numeri = (4, 17, 39, 12)
```

Valori booleani:

```none
booleani = (False, False, True, False)
```

Sono possibili anche diversi valori combinati:

```none
person = ("Rossi", "Mario", 1974, True)
```

## Indirizzare gli elementi nelle tuple in Python

Poiché i singoli elementi di una tupla in Python sono definiti da un indice, possono essere facilmente indirizzati e letti. Il processo è simile a quello di un normale elenco e viene avviato tramite **parentesi quadre**. Per esempio, così:

```none
animali = ("cane", "gatto", "topo")
print(animali[1])
```

Il secondo valore di questa tupla in Python è “gatto”, quindi la parola viene emessa dopo questa richiesta.

Se desiderate leggere più di un valore, procedete come segue:

```none
animali = ("cane", "gatto", "topo", "serpente", "cavallo")
print(animali[1:3])
```

Il risultato ottenuto è ora:

```none
('gatto', 'topo', 'serpente')
```

## Determinazione della lunghezza di una tupla in Python

Per determinare la lunghezza di una tupla in Python, utilizzate la **funzione len**. Funziona così:

```none
animali = ("cane", "gatto", "topo", "serpente", "cavallo")
print(len(animali))
```

Il risultato ottenuto sarà un “5” per i cinque valori contenuti.

## Modifica delle tuple in Python

Le tuple in Python sono immutabili e di conseguenza non possono essere riempite con nuovi elementi. Tuttavia, per **aggiornare una tupla esistente**, potete crearne una nuova e riempirla con i nuovi valori e la tupla originale. Per questo si utilizza l’operatore +. Di seguito un esempio:

```none
alcuni_animali = ("cane", "gatto", "topo", "serpente", "cavallo")
tutti_gli_animali = alcuni_animali + ("criceto", "giraffa")
print(tutti_gli_animali)
```

Il risultato è ora:

```none
('cane', 'gatto', 'topo', 'serpente', 'cavallo', 'criceto', 'giraffa')
```

## Conversione di tuple in liste in Python

Se alcuni valori di una tupla in Python non sono più aggiornati, il metodo spiegato sopra non sarà d’aiuto. Tuttavia, poiché non è possibile modificare i valori all’interno di una tupla, è necessaria un’alternativa, che viene fornita dalla lista classica. Convertendo una tupla in una lista, potete **modificare nuovamente i valori esistenti**. Funziona così:

```none
animali = ("cane", "gatto", "topo", "serpente", "cavallo")
lista_animali = list(animali)
lista_animali[2] = "elefante"
print(lista_animali)
```

Ora ottenete come output:

```none
['cane', 'gatto', 'elefante', 'serpente', 'cavallo']
```

## Conversione delle liste in tuple in Python

Questo metodo funziona anche al contrario. Se avete creato una lista e desiderate mantenere i valori corrispondenti nella loro forma attuale, potete convertire le liste in tuple in Python. Nell’esempio seguente, convertiamo un elenco in una tupla e poi interroghiamo il tipo di dati della tupla in Python per sicurezza:

```none
lista_colori = ["blu", "rosso", "giallo", "arancione"]
colori = tuple(lista_colori)
print(colori)
print(type(colori))
```

Il risultato sarà simile a questo:

```none
("blu", "rosso", "giallo", "arancione")
<class 'tuple'=""></class>
```

## Come eliminare una tupla

Sebbene non sia possibile rimuovere singoli elementi da una tupla, potete eliminare l’intera lista immutabile. A tale scopo, utilizzate il **comando del**. Di seguito il codice corrispondente:

```none
animali = ("cane", "gatto", "topo", "serpente", "cavallo")
del animali
```

## Funzioni integrate

Esistono solo due funzioni integrate per le tuple in Python: index e count.

### La funzione index per le tuple in Python

Con index interrogate l’**indice di un dato valore**. Di seguito il codice corrispondente:

```none
animali = ("cane", "gatto", "topo", "serpente", "cavallo")
animali.index("serpente")
```

In questo caso il risultato sarebbe “3”.

### La funzione count per le tuple in Python

Con count interrogate la **frequenza di un elemento all’interno della tupla in Python**. Di seguito un esempio:

```none
animali = ("cane", "gatto", "topo", "serpente", "cavallo")
animali.count("cane")
```

In questo caso, la risposta è “1”.


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tuple-in-python/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/tuple-in-python/) for AI/LLM consumption.