Tipos de datos en Python: guía completa con ejemplos

En Python, cada valor tiene un tipo. Entender los tipos de datos es la base de todo: sin esto, no puedes escribir programas que funcionen bien. En esta guía verás todos los tipos nativos de Python, cuándo usar cada uno y cómo operan en la práctica.

1. ¿Qué es un tipo de dato?

Un tipo de dato define qué clase de valor puede almacenar una variable y qué operaciones puedes hacer con ella. No es lo mismo un número que un texto: no puedes dividir una palabra por dos, ni ponerle mayúsculas a un número.

En Python, a diferencia de otros lenguajes, no declaras el tipo explícitamente. Python lo infiere automáticamente al asignar un valor. A esto se le llama tipado dinámico.

edad   = 25        # Python detecta: int
precio = 9.99      # Python detecta: float
nombre = "Ana"     # Python detecta: str
activo = True      # Python detecta: bool

print(type(edad))    # <class 'int'>
print(type(precio))  # <class 'float'>

La función type() es tu mejor aliada al explorar tipos: te dice exactamente con qué estás trabajando.

2. Resumen de tipos nativos

Python tiene ocho tipos de datos incorporados que cubren el 99% de los casos:

• int — números enteros, sin límite de tamaño. Ejemplo: 42, -7, 1_000_000
• float — números decimales (punto flotante). Ejemplo: 3.14, -0.5, 1.2e10
• str — cadenas de texto, inmutables. Ejemplo: "hola", 'mundo'
• bool — valores lógicos verdadero/falso. Ejemplo: True, False
• list — colección ordenada y mutable. Ejemplo: [1, 2, "tres"]
• tuple — colección ordenada e inmutable. Ejemplo: (1, 2, "tres")
• dict — pares clave-valor, acceso rápido. Ejemplo: {"nombre": "Ana"}
• set — colección sin duplicados ni orden. Ejemplo: {1, 2, 3}

3. Tipos numéricos: int, float y complex

Enteros (int)

Los enteros representan números sin parte decimal: negativos, cero o positivos. En Python 3, los enteros no tienen límite de tamaño (salvo la memoria de tu máquina).

a = 10
b = -3
c = 1_000_000   # guión bajo como separador visual (Python 3.6+)
d = 0xFF        # hexadecimal → 255
e = 0b1010      # binario → 10

print(a + b)    # 7
print(a ** 2)   # 100  (potencia)
print(a // 3)   # 3    (división entera)
print(a % 3)    # 1    (módulo / resto)

Consejo: El operador // siempre devuelve un entero aunque dividas floats. Es perfecto para índices y conteos donde no quieres decimales.

Decimales (float)

Los float representan números con parte decimal. Internamente usan el estándar IEEE 754, lo que genera una limitación importante que todo programador debe conocer.

precio = 9.99
pi     = 3.14159
masa   = 1.5e-3     # notación científica → 0.0015

# El problema clásico de precisión
print(0.1 + 0.2)               # 0.30000000000000004  ← sorpresa
print(round(0.1 + 0.2, 2))     # 0.3  ← solución rápida

from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2"))  # 0.3 exacto

Importante: Nunca compares floats con ==. Usa abs(a - b) < 0.0001 o math.isclose(a, b) para comparaciones seguras.

Números complejos (complex)

Python soporta números complejos de forma nativa. Son útiles en matemáticas, señales y física, aunque raramente los verás en proyectos web.

z = 3 + 4j
print(z.real)  # 3.0
print(z.imag)  # 4.0
print(abs(z))  # 5.0  (módulo)

4. Cadenas de texto (str)

El tipo str almacena texto. En Python, las cadenas son inmutables: una vez creadas, no puedes cambiar una letra individual. Pero sí puedes crear nuevas cadenas a partir de ellas.

s1 = "Hola mundo"
s2 = 'También válido'
s3 = """Texto
multilínea"""

nombre = "python"
print(nombre.upper())           # "PYTHON"
print(nombre.capitalize())      # "Python"
print(len(nombre))              # 6
print(nombre[0])                # "p"
print(nombre[1:4])              # "yth"  (slicing)
print(nombre.replace("p", "P")) # "Python"

# f-strings: la forma moderna de formatear (Python 3.6+)
edad = 30
print(f"Tengo {edad} años")     # "Tengo 30 años"
print(f"{edad * 2 = }")         # "edad * 2 = 60"  (modo debug)

Buena práctica: Usa siempre f-strings para formatear texto. Son más legibles y rápidas que % o .format(). Desde Python 3.12, admiten expresiones más complejas dentro de las llaves.

5. Booleanos (bool)

El tipo bool tiene exactamente dos valores: True y False. En Python, los booleanos son una subclase de int, por lo que True == 1 y False == 0.

print(True and False)  # False
print(True or False)   # True
print(not True)        # False

# Valores "falsy" (se evalúan como False en un if)
print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(None))   # False

# Todo lo demás es "truthy"
print(bool(42))     # True
print(bool("hola")) # True

Esta característica permite escribir condiciones más limpias. En lugar de if len(lista) > 0:, puedes escribir simplemente if lista:.

6. Listas (list)

Una lista es una colección ordenada y mutable de elementos. Puede contener cualquier tipo de dato y es el tipo de colección más usado en Python.

frutas = ["manzana", "banana", "cereza"]

print(frutas[0])           # "manzana"
print(frutas[-1])          # "cereza"  (último elemento)
frutas[1] = "pera"         # modificar elemento

frutas.append("mango")     # agrega al final
frutas.insert(1, "kiwi")   # inserta en posición 1
frutas.remove("pera")      # elimina por valor
frutas.pop()               # elimina y retorna el último
frutas.sort()              # ordena in-place
print(len(frutas))         # número de elementos

# List comprehension: crear listas elegantemente
cuadrados = [x**2 for x in range(5)]
print(cuadrados)           # [0, 1, 4, 9, 16]

7. Tuplas (tuple)

Las tuplas son como las listas pero inmutables: una vez creadas, no puedes cambiarlas. Se usan cuando quieres garantizar que los datos no se modifiquen accidentalmente.

coordenadas = (40.4168, -3.7038)  # lat, lon de Madrid
rgb = (255, 128, 0)

# Unpacking: asignar múltiples variables a la vez
lat, lon = coordenadas
print(f"Latitud: {lat}, Longitud: {lon}")

# Las funciones suelen retornar tuplas
def min_max(lista):
    return min(lista), max(lista)

minimo, maximo = min_max([3, 1, 7, 2])
print(minimo, maximo)   # 1  7

¿Cuándo usar tuple vs list? Usa tuple cuando los datos son fijos por naturaleza (coordenadas, colores RGB, un registro de base de datos). Usa list cuando necesitas agregar, eliminar o modificar elementos.

8. Diccionarios (dict)

Un diccionario almacena pares clave → valor. Es el equivalente en Python a los objetos JSON. Desde Python 3.7, mantienen el orden de inserción.

usuario = {
    "nombre": "Laura",
    "edad": 28,
    "activo": True
}

print(usuario["nombre"])            # "Laura"
print(usuario.get("email", "N/A"))  # "N/A"  (evita KeyError)

usuario["email"] = "laura@mail.com"  # agregar clave
usuario["edad"]  = 29                # modificar valor
del usuario["activo"]                # eliminar clave

for clave, valor in usuario.items():
    print(f"{clave}: {valor}")

# Dict comprehension
cuadrados = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

9. Conjuntos (set)

Un set es una colección sin duplicados y sin orden garantizado. Es ideal para verificar si un elemento existe y para operaciones matemáticas de conjuntos.

# Elimina duplicados automáticamente
numeros = {1, 2, 2, 3, 3, 3}
print(numeros)           # {1, 2, 3}

# Uso clásico: limpiar duplicados de una lista
lista   = [1, 2, 2, 3, 4, 4]
sin_dup = list(set(lista))

# Operaciones de conjuntos
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a | b)   # Unión:                {1, 2, 3, 4, 5, 6}
print(a & b)   # Intersección:         {3, 4}
print(a - b)   # Diferencia:           {1, 2}
print(a ^ b)   # Diferencia simétrica: {1, 2, 5, 6}

print(3 in a)  # True  (búsqueda O(1))

10. El tipo especial: None

None representa la ausencia de valor. Es el equivalente a null en otros lenguajes. Su tipo es NoneType.

resultado = None

# Comparar con None: usa "is", no "=="
if resultado is None:
    print("No hay resultado todavía")

# Las funciones sin return devuelven None implícitamente
def saludar():
    print("Hola")

x = saludar()
print(x)   # None

Buena práctica: Usa siempre is None o is not None para comparar con None. El operador == puede dar resultados inesperados con objetos que sobreescriben __eq__.

11. Conversión entre tipos (casting)

Python ofrece funciones para convertir entre tipos. Esto se llama casting o type casting.

# str → int / float
edad   = int("25")       # 25
precio = float("9.99")   # 9.99

# int / float → str
str(42)    # "42"
str(3.14)  # "3.14"

# list ↔ tuple ↔ set
mi_lista = [1, 2, 3]
tuple(mi_lista)   # (1, 2, 3)
set(mi_lista)     # {1, 2, 3}

# Cuidado con conversiones inválidas
try:
    int("hola")
except ValueError as e:
    print(f"Error: {e}")  # Error: invalid literal...

12. Type hints: tipado estático opcional

Desde Python 3.5, puedes anotar tipos en tu código. Esto no afecta la ejecución, pero ayuda a los editores y herramientas como mypy a detectar errores antes de correr el programa.

nombre: str  = "Ana"
edad:   int  = 28
activo: bool = True

def saludar(nombre: str, veces: int = 1) -> str:
    return (f"Hola, {nombre}! ") * veces

# Colecciones tipadas (Python 3.9+)
frutas: list[str]      = ["manzana", "pera"]
config: dict[str, int] = {"timeout": 30}

# Tipos opcionales (Python 3.10+)
def buscar(id: int) -> str | None:
    return None

Comparativa rápida: mutabilidad y orden

13. Resumen final

Lo que debes recordar:

• Usa int y float para números; ten cuidado con la precisión de los floats.
• Usa str para texto y f-strings para formatear.
• Recuerda que 0, "", [] y None son falsy en un if.
• Elige list cuando necesitas mutabilidad, tuple cuando los datos son fijos.
• Usa dict para pares clave-valor y set cuando necesitas unicidad o hacer intersecciones.
• Compara siempre con is None, nunca con == None.
• Añade type hints a tus funciones: mejoran la legibilidad sin coste alguno.

Dominar los tipos de datos es fundamental porque cada decisión al elegir entre una lista, una tupla o un diccionario afecta la legibilidad y el rendimiento de tu código. Con el tiempo, elegirás el tipo correcto de forma intuitiva.

El siguiente paso natural es aprender a trabajar con estos tipos en estructuras más complejas: listas de diccionarios, diccionarios anidados, y cómo aplicarlos en funciones reales.