Tipos de datos en Python: Guía completa

Todo valor en Python tiene un tipo de dato que indica al intérprete qué clase de dato es y qué operaciones se permiten sobre él. Como Python es de tipado dinámico, nunca se declara un tipo de forma explícita — el intérprete lo infiere en tiempo de ejecución. Por eso es fundamental comprender los tipos integrados: elegir el tipo incorrecto puede provocar errores, copias innecesarias o un rendimiento deficiente.

Este capítulo cubre todos los tipos de datos integrados:

Usa la función integrada type() en cualquier momento para inspeccionar qué tipo tiene un valor:

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

Tipos numéricos

Python tiene tres tipos numéricos: int, float y complex. Los tres admiten los operadores aritméticos estándar (+, -, *, /, //, %, **).

int

Un int almacena un número entero de tamaño ilimitado — los enteros de Python no están limitados a 32 ni a 64 bits.

Operadores clave

Ten en cuenta que / siempre devuelve un float aunque el resultado sea un número entero. Usa // cuando necesites un cociente entero.

Tipo de dato entero en 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 almacena un número decimal usando la doble precisión IEEE 754. Usa floats siempre que necesites valores fraccionarios.

Advertencia — representación en punto flotante: 0.1 + 0.2 no es exactamente 0.3 en punto flotante binario. Usa round() o el módulo decimal cuando la aritmética decimal exacta sea importante (por ejemplo, divisas).

complex

Un número complex tiene una parte real y una parte imaginaria, escrito como a + bj en Python (usando j, no i). Los números complejos se utilizan principalmente en computación científica, procesamiento de señales y cálculos de ingeniería.

str (Cadenas de texto)

Un str es una secuencia inmutable de caracteres Unicode. Las cadenas pueden encerrarse entre comillas simples, comillas dobles o comillas triples (para cadenas multilínea).

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

Operaciones comunes con cadenas

Métodos de cadena útiles

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-strings (literales de cadena con formato)

Las f-strings (introducidas en Python 3.6) son la forma preferida de incrustar valores dentro de cadenas:

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.

Como las cadenas son inmutables, cada operación que "modifica" una cadena en realidad crea una nueva. Para más información sobre los métodos de cadena, consulta el capítulo Python Strings.

bool (Boolean)

Un bool tiene exactamente dos valores: True y False. Los booleanos son una subclase de int en Python — True equivale a 1 y 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)

Valores verdaderos y falsos

Cualquier objeto de Python puede evaluarse en un contexto boolean. Los siguientes valores son falsos (se evalúan como False); todo lo demás es verdadero:

• False, None
• Cero numérico: 0, 0.0, 0j
• Secuencias vacías: "", [], (), set()
• Mapeo vacío: {}

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

Para un tratamiento completo, consulta el capítulo Python Booleans.

list

Una list es una secuencia ordenada y mutable. Puede contener elementos de cualquier tipo, incluso una mezcla de tipos, y permite duplicados.

# 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

Cuándo usar una list: cuando necesitas una colección ordenada que cambiará — agregar elementos, eliminar elementos o actualizar valores en el lugar. Para una cobertura más detallada, consulta el capítulo Python Lists.

tuple

Una tuple es una secuencia ordenada e inmutable. Una vez creada, sus elementos no pueden modificarse.

# 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'>

Cuándo usar una tuple en lugar de una list:

• Los datos no deben cambiar (por ejemplo, coordenadas GPS, valores de color RGB, filas de base de datos).
• Quieres usar el valor como clave de diccionario (las listas no pueden ser claves de dict porque son mutables; las tuplas sí).
• Quieres comunicar la intención: "esta secuencia es fija."

Para más información, consulta el capítulo Python Tuples.

set

Un set es una colección no ordenada de elementos únicos. Los valores duplicados se descartan silenciosamente al crearlo o al agregarlos.

# 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

Cuándo usar un set: cuando necesitas pruebas de pertenencia rápidas o quieres eliminar duplicados de una colección. Para más información, consulta el capítulo Python Sets.

dict (Diccionario)

Un dict es un mapeo no ordenado de pares clave-valor. A partir de Python 3.7, los diccionarios conservan el orden de inserción. Las claves deben ser únicas e inmutables (las cadenas y los números son las opciones más comunes).

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}")

Cuándo usar un dict: cuando los datos tienen una estructura natural de clave-valor y necesitas una búsqueda rápida por nombre. Para más información, consulta el capítulo Python Dictionary Methods.

NoneType

None es el valor nulo de Python — representa la ausencia de un valor. Es la única instancia de 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 siempre is None (comprobación de identidad) en lugar de == None (comprobación de igualdad):

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

Mutabilidad de un vistazo

La mutabilidad determina si un valor puede modificarse en su lugar después de su creación. Esto afecta la corrección (alias accidentales), el rendimiento (copiar frente a referenciar) y qué puede usarse como clave de dict.

Conversión de tipos

Python proporciona funciones integradas para convertir entre tipos. Esto se denomina conversión de tipos explícita (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() trunca (no redondea): int(3.9) devuelve 3, no 4. Usa round() antes de int() si se necesita redondeo.

Para una discusión completa de las reglas de casting, consulta el capítulo Python Casting.

Verificar un tipo en tu código

Usa isinstance() (preferido) o type() para comprobaciones de 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

Prefiere isinstance() sobre type(x) == int porque respeta la herencia — un bool también es un int, así que isinstance(True, int) devuelve True, que es generalmente lo que se desea.

Resumen de referencia rápida

* Orden de inserción preservado desde Python 3.7+.

Práctica