Tipi di dati in Python: una guida completa

Ogni valore in Python ha un tipo di dato che indica all'interprete che tipo di informazione contiene e quali operazioni sono consentite su di esso. Poiché Python è tipizzato dinamicamente, non è mai necessario dichiarare esplicitamente un tipo — l'interprete lo deduce in fase di esecuzione. Comprendere i tipi integrati è quindi fondamentale: scegliere il tipo sbagliato può causare bug, copie non necessarie o prestazioni scadenti.

Questo capitolo tratta tutti i tipi di dati integrati:

Usa la funzione integrata type() in qualsiasi momento per verificare il tipo di un valore:

print(type(42))       # <class 'int'>
print(type(3.14))     # <class 'float'>
print(type("hello"))  # <class 'str'>
print(type(True))     # <class 'bool'>
print(type([1, 2]))   # <class 'list'>
print(type((1, 2)))   # <class 'tuple'>
print(type({1, 2}))   # <class 'set'>
print(type({"a": 1})) # <class 'dict'>
print(type(None))     # <class 'NoneType'>

Tipi numerici

Python dispone di tre tipi numerici: int, float e complex. Tutti e tre supportano gli operatori aritmetici standard (+, -, *, /, //, %, **).

int

Un int memorizza un numero intero di dimensione illimitata — gli interi Python non sono limitati a 32 o 64 bit.

Operatori principali

Nota che / restituisce sempre un float anche quando il risultato è un numero intero. Usa // quando hai bisogno di un quoziente intero.

Tipo di dato Integer in Python

# Integer addition
print(1 + 2)    # 3

# Integer subtraction
print(3 - 1)    # 2

# Integer multiplication
print(2 * 3)    # 6

# True division always returns float
print(6 / 2)    # 3.0

# Floor division returns int
print(7 // 2)   # 3

# Exponentiation
print(2 ** 10)  # 1024

float

Un float memorizza un numero decimale usando la doppia precisione IEEE 754. Usa i float quando hai bisogno di valori frazionari.

Attenzione — rappresentazione in virgola mobile: 0.1 + 0.2 non è esattamente 0.3 nella rappresentazione binaria in virgola mobile. Usa round() o il modulo decimal quando è necessaria un'aritmetica decimale esatta (ad esempio, per le valute).

complex

Un numero complex ha una parte reale e una parte immaginaria, scritto come a + bj in Python (usando j, non i). I numeri complessi sono usati principalmente nel calcolo scientifico, nell'elaborazione dei segnali e nei calcoli ingegneristici.

str (Stringhe)

Una str è una sequenza immutabile di caratteri Unicode. Le stringhe possono essere racchiuse tra virgolette singole, virgolette doppie o virgolette triple (per le stringhe multiriga).

single = 'Hello'
double = "World"
multi  = """This spans
multiple lines."""

Operazioni comuni sulle stringhe

Metodi utili per le stringhe

s = "  Hello World  "
print(s.strip())          # "Hello World"  — remove whitespace
print(s.strip().lower())  # "hello world"
print(s.strip().upper())  # "HELLO WORLD"
print("Hello World".split())   # ['Hello', 'World']
print(",".join(["a", "b", "c"]))  # a,b,c
print("Hello World".replace("World", "Python"))  # Hello Python
print(len("Hello"))       # 5

f-string (stringhe letterali formattate)

Le f-string (introdotte in Python 3.6) sono il modo preferito per incorporare valori all'interno delle stringhe:

name = "Alice"
age  = 30
print(f"{name} is {age} years old.")   # Alice is 30 years old.
print(f"Next year she will be {age + 1}.")  # Next year she will be 31.

Poiché le stringhe sono immutabili, ogni operazione che "modifica" una stringa ne crea in realtà una nuova. Per ulteriori informazioni sui metodi delle stringhe, consulta il capitolo Python Strings.

bool (Boolean)

Un bool ha esattamente due valori: True e False. I boolean sono una sottoclasse di int in Python — True equivale a 1 e False equivale a 0.

print(type(True))   # <class 'bool'>
print(True + 1)     # 2  (True is treated as 1)
print(False + 10)   # 10 (False is treated as 0)

Valori truthy e falsy

Ogni oggetto Python può essere valutato in un contesto boolean. I seguenti valori sono falsy (valutati come False); tutto il resto è truthy:

• False, None
• Zero numerico: 0, 0.0, 0j
• Sequenze vuote: "", [], (), set()
• Mappatura vuota: {}

print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(None))   # False

print(bool(42))     # True
print(bool("hi"))   # True
print(bool([0]))    # True  — list with one item is truthy

Per un trattamento completo consulta il capitolo Python Booleans.

list

Una list è una sequenza ordinata e mutabile. Può contenere elementi di qualsiasi tipo, inclusa una combinazione di tipi, e ammette duplicati.

# Creating a list
fruits = ["apple", "banana", "cherry"]

# Modifying an item
fruits[1] = "orange"
print(fruits)  # ['apple', 'orange', 'cherry']

# Adding items
fruits.append("mango")
print(fruits)  # ['apple', 'orange', 'cherry', 'mango']

# Removing an item
fruits.remove("orange")
print(fruits)  # ['apple', 'cherry', 'mango']

# Length
print(len(fruits))  # 3

Quando usare una list: quando hai bisogno di una raccolta ordinata che cambierà — aggiungere elementi, rimuovere elementi o aggiornare i valori sul posto. Per una copertura approfondita consulta il capitolo Python Lists.

tuple

Una tuple è una sequenza ordinata e immutabile. Una volta creata, i suoi elementi non possono essere modificati.

# Creating a tuple
coords = (10, 20)
print(coords[0])    # 10
print(len(coords))  # 2

# Tuple unpacking
x, y = coords
print(x, y)  # 10 20

# Single-element tuple needs a trailing comma
single = (42,)
print(type(single))  # <class 'tuple'>

Quando usare una tuple invece di una list:

• I dati non devono cambiare (ad esempio, coordinate GPS, valori RGB dei colori, righe di database).
• Vuoi usare il valore come chiave di un dizionario (le list non possono essere usate come chiavi di dict perché sono mutabili; le tuple possono).
• Vuoi comunicare l'intenzione: "questa sequenza è fissa."

Per ulteriori informazioni consulta il capitolo Python Tuples.

set

Un set è una raccolta non ordinata di elementi unici. I valori duplicati vengono silenziosamente scartati durante la creazione o l'aggiunta.

# Duplicates are automatically removed
unique = {1, 2, 2, 3, 3, 3}
print(unique)  # {1, 2, 3}

# Adding an item
unique.add(4)
print(unique)  # {1, 2, 3, 4}

# Membership test — O(1) average
print(3 in unique)  # True

# Set operations
a = {1, 2, 3}
b = {2, 3, 4}
print(a | b)  # {1, 2, 3, 4}  union
print(a & b)  # {2, 3}        intersection
print(a - b)  # {1}           difference

Quando usare un set: quando hai bisogno di un test di appartenenza veloce o vuoi eliminare i duplicati da una raccolta. Per ulteriori informazioni consulta il capitolo Python Sets.

dict (Dizionario)

Un dict è una mappatura non ordinata di coppie chiave-valore. A partire da Python 3.7, i dizionari preservano l'ordine di inserimento. Le chiavi devono essere uniche e immutabili (le stringhe e i numeri sono le scelte più comuni).

person = {"name": "John", "age": 32, "city": "New York"}

# Access by key
print(person["name"])  # John

# Add a key
person["country"] = "United States"
print(person)
# {'name': 'John', 'age': 32, 'city': 'New York', 'country': 'United States'}

# Remove a key
del person["city"]
print(person)
# {'name': 'John', 'age': 32, 'country': 'United States'}

# Safe access with a default value
print(person.get("email", "not provided"))  # not provided

# Iterate over keys and values
for key, value in person.items():
    print(f"{key}: {value}")

Quando usare un dict: quando i dati sono strutturati naturalmente come coppie chiave-valore e hai bisogno di una ricerca veloce per nome. Per ulteriori informazioni consulta il capitolo Python Dictionary Methods.

NoneType

None è il valore null di Python — rappresenta l'assenza di un valore. È l'unica istanza di NoneType.

result = None
print(result)         # None
print(type(result))   # <class 'NoneType'>

# Functions that do not explicitly return a value return None
def greet(name):
    print(f"Hello, {name}!")

x = greet("Alice")    # prints: Hello, Alice!
print(x)              # None

Usa sempre is None (controllo di identità) anziché == None (controllo di uguaglianza):

if result is None:
    print("No result yet")

Mutabilità a colpo d'occhio

La mutabilità determina se un valore può essere modificato sul posto dopo la creazione. Questo influisce sulla correttezza (alias accidentali), sulle prestazioni (copia vs. riferimento) e su ciò che può essere usato come chiave di dict.

Conversione di tipo

Python fornisce funzioni integrate per convertire tra tipi. Questa operazione è chiamata conversione di tipo esplicita (o casting).

# To int
print(int("42"))      # 42
print(int(3.9))       # 3  (truncates, does not round)
print(int(True))      # 1

# To float
print(float(7))       # 7.0
print(float("3.14"))  # 3.14

# To str
print(str(3.14))      # '3.14'
print(str(True))      # 'True'

# Between sequences
print(list((1, 2, 3)))   # [1, 2, 3]
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(set([1, 2, 2, 3])) # {1, 2, 3}

int() tronca (non arrotonda): int(3.9) restituisce 3, non 4. Usa round() prima di int() se è necessario l'arrotondamento.

Per una discussione completa sulle regole di casting consulta il capitolo Python Casting.

Verifica di un tipo nel codice

Usa isinstance() (preferito) o type() per i controlli di tipo:

x = 42
print(isinstance(x, int))    # True
print(isinstance(x, float))  # False

# isinstance also works with a tuple of types
print(isinstance(x, (int, float)))  # True

Preferisci isinstance() rispetto a type(x) == int perché rispetta l'ereditarietà — un bool è anche un int, quindi isinstance(True, int) restituisce True, che di solito è il comportamento desiderato.

Riepilogo rapido

* Ordine di inserimento preservato da Python 3.7+.

Pratica