¿Cuáles son los tipos de datos integrados de Python?

Question

Accepted Answer

Python tiene un rico conjunto de tipos integrados que cubren números, texto, colecciones y más. Conocerlos —y saber cuáles son **mutables** frente a **inmutables**— es fundamental.

## Tipos numéricos

```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: el `int` de Python tiene **precisión arbitraria**: nunca desborda (a diferencia de los enteros de tamaño fijo en C/Java); `2 ** 1000` simplemente funciona.

## Texto y bytes

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

## Tipos de colección

```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
```

## El tipo especial None

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

## Comprobar tipos

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

## Resumen de mutable frente a inmutable

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

Esta distinción importa mucho: los objetos inmutables pueden ser claves de un dict y es seguro compartirlos; los mutables pueden cambiar inesperadamente si hay alias.

## Por qué es importante

Los tipos integrados son el vocabulario de todo el código Python.

Conocer el propósito de cada uno (list para secuencias ordenadas, dict para clave-valor, set para unicidad, tuple para registros fijos), los enteros de precisión arbitraria y, sobre todo, la división **mutable frente a inmutable** (que rige las claves de dict, los errores por alias y lo que puede compartirse con seguridad) es fundamental.

Elegir el tipo adecuado para cada tarea —y comprender su mutabilidad— es una habilidad esencial de Python que afecta a la corrección y al rendimiento de todo un programa.