Quali sono i tipi di dati incorporati di Python?

Question

Accepted Answer

Python ha un ricco set di tipi incorporati che coprono numeri, testo, raccolte e altro. Conoscerli — e quali sono **mutabili** vs **immutabili** — è fondamentale.

## Tipi numerici

```python
x = 42          # int  — arbitrary precision (no overflow!)
y = 3.14        # float
z = 2 + 3j      # complex
b = True        # bool (a subclass of int: True == 1)
```

Nota: Python `int` ha **precisione arbitraria** — non va mai in overflow (a differenza degli int a dimensione fissa in C/Java); `2 ** 1000` funziona semplicemente.

## Testo e byte

```python
s = "hello"     # str  — Unicode text (immutable)
data = b"bytes" # bytes — raw binary (immutable)
```

## Tipi di raccolta

```python
lst = [1, 2, 3]            # list  — ordered, MUTABLE, allows duplicates
tup = (1, 2, 3)            # tuple — ordered, IMMUTABLE
d = {"a": 1, "b": 2}       # dict  — key→value, mutable, insertion-ordered
s = {1, 2, 3}              # set   — unordered, unique elements, mutable
fs = frozenset({1, 2})     # frozenset — immutable set
```

## Il tipo speciale None

```python
result = None   # NoneType — represents "no value" (like null)
if result is None:   # always compare to None with `is`, not ==
    ...
```

## Verifica dei tipi

```python
type(x)             # <class 'int'>
isinstance(x, int)  # True — the preferred check (handles subclasses)
```

## Riepilogo mutabile vs immutabile

```text
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable:   list, dict, set, bytearray
```

Questa distinzione è molto importante — gli oggetti immutabili possono essere chiavi dict e sono sicuri da condividere; gli oggetti mutabili possono cambiare inaspettatamente se aliasati.

## Perché è importante

I tipi incorporati sono il vocabolario di tutto il codice Python.

Conoscere lo scopo di ciascuno — lista per sequenze ordinate, dict per coppie chiave-valore, set per unicità, tuple per record fissi, interi a precisione arbitraria, e soprattutto la divisione **mutabile-vs-immutabile** (che governa le chiavi dict, i bug di aliasing e ciò che può essere condiviso in modo sicuro) è fondamentale.

Scegliere il tipo giusto per il lavoro — e comprendere la sua mutabilità — è un'abilità Python fondamentale che influisce sulla correttezza e sulle prestazioni in tutto il programma.