En esta página

Variables y tipos de datos

14 min lectura TextoCap. 1 — Fundamentos de Python

Variables en Python: tipado dinámico

En Python, una variable es simplemente un nombre que apunta a un objeto en memoria. No necesitas declarar el tipo de antemano; Python lo infiere en tiempo de ejecución. A esto se le llama tipado dinámico.

mensaje = "Hola"      # str
mensaje = 42          # ahora es int — esto es válido en Python
mensaje = [1, 2, 3]   # ahora es list — Python no se queja

Esto es muy diferente de lenguajes como TypeScript o Java, donde una variable tiene un tipo fijo desde su declaración. En Python, el tipo pertenece al objeto, no a la variable. La variable es solo una etiqueta que puede pegarse a cualquier objeto.

Sin embargo, a pesar del tipado dinámico, Python tiene tipado fuerte: no hace conversiones implícitas entre tipos incompatibles.

# Esto lanza TypeError — Python no convierte automáticamente
resultado = "La edad es: " + 25  # ¡Error!

# Debes ser explícito
resultado = "La edad es: " + str(25)  # Correcto

Tipo str — Cadenas de texto

Las cadenas en Python son secuencias inmutables de caracteres Unicode. Puedes crearlas con comillas simples, dobles o triples:

simple = 'Hola mundo'
doble = "También funciona"
multilinea = """Esta cadena
ocupa varias
líneas."""

# Las cadenas son inmutables
texto = "Python"
# texto[0] = "J"  # Esto lanzaría TypeError

Métodos esenciales de cadenas

Los strings en Python tienen decenas de métodos útiles. Aquí los más importantes:

frase = "  ¡Bienvenido a Python!  "

# Transformaciones de caso
print(frase.upper())        # "  ¡BIENVENIDO A PYTHON!  "
print(frase.lower())        # "  ¡bienvenido a python!  "
print(frase.title())        # "  ¡Bienvenido A Python!  "
print(frase.capitalize())   # "  ¡bienvenido a python!  "

# Eliminar espacios
print(frase.strip())        # "¡Bienvenido a Python!"
print(frase.lstrip())       # "¡Bienvenido a Python!  "
print(frase.rstrip())       # "  ¡Bienvenido a Python!"

# Búsqueda y reemplazo
print(frase.find("Python"))     # índice donde empieza, o -1
print(frase.count("o"))         # número de ocurrencias
print(frase.replace("Python", "la programación"))

# División y unión
palabras = "uno,dos,tres".split(",")  # ['uno', 'dos', 'tres']
unida = " - ".join(palabras)          # 'uno - dos - tres'

# Verificaciones booleanas
print("123".isdigit())      # True
print("abc".isalpha())      # True
print("abc123".isalnum())   # True
print("  ".isspace())       # True
print("hola".startswith("ho"))  # True
print("hola".endswith("la"))    # True

Tipo int — Enteros

Los enteros en Python no tienen límite de tamaño (a diferencia de otros lenguajes). Python puede manejar números con miles de dígitos sin desbordamiento:

pequeño = 42
negativo = -17
gigante = 10 ** 100  # Un googol — Python lo maneja sin problemas

# Diferentes bases numéricas
binario = 0b1010    # 10 en decimal
octal = 0o17        # 15 en decimal
hexadecimal = 0xFF  # 255 en decimal

# Separadores de miles para legibilidad
millon = 1_000_000
pi_aproximado = 3_141_592_653

print(f"Un millón: {millon:,}")  # 1,000,000 con formato

Tipo float — Números de punto flotante

Los floats siguen el estándar IEEE 754 de doble precisión. Esto significa que tienen precisión limitada y pueden producir resultados sorprendentes:

precio = 9.99
temperatura = -3.5
científico = 1.5e-4   # 0.00015

# ¡Cuidado con la precisión de punto flotante!
print(0.1 + 0.2)  # 0.30000000000000004 — no exactamente 0.3

# Para trabajo financiero, usa Decimal
from decimal import Decimal
precio_exacto = Decimal("0.1") + Decimal("0.2")
print(precio_exacto)  # 0.3 — exacto

Tipo bool — Booleanos

Los booleanos en Python son un subtipo de int: True es 1 y False es 0. Esto significa que puedes hacer aritmética con ellos (aunque rara vez querrás hacerlo):

activo = True
inactivo = False

print(True + True)    # 2
print(True * 5)       # 5
print(False + 10)     # 10

# Valores "truthy" y "falsy"
# Falsy: 0, 0.0, "", [], {}, set(), None, False
# Todo lo demás es truthy

print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(None))   # False
print(bool(42))     # True
print(bool("hola")) # True
print(bool([1]))    # True

Tipo None — La ausencia de valor

None es el objeto singleton de Python que representa la ausencia de un valor. Es similar a null en otros lenguajes, pero en Python es un objeto real de tipo NoneType:

resultado = None
usuario = None

# Siempre compara con None usando 'is', no '=='
if resultado is None:
    print("No hay resultado todavía")

if usuario is not None:
    print(f"Usuario: {usuario}")

# Las funciones que no retornan explícitamente devuelven None
def sin_retorno():
    x = 5  # No hay 'return'

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

La función type() e isinstance()

Para inspeccionar el tipo de un objeto usa type(). Para verificar si un objeto es de cierto tipo (respetando herencia), usa isinstance():

x = 42

# type() devuelve el tipo exacto
print(type(x))           # <class 'int'>
print(type(x) is int)    # True

# isinstance() es más flexible (recomendado)
print(isinstance(x, int))          # True
print(isinstance(x, (int, float))) # True — acepta tupla de tipos

# Con herencia, isinstance() es superior
class Animal:
    pass

class Perro(Animal):
    pass

rex = Perro()
print(type(rex) is Animal)      # False — tipo exacto
print(isinstance(rex, Animal))  # True — respeta herencia
print(isinstance(rex, Perro))   # True

Conversión de tipos (Type Casting)

Python ofrece funciones integradas para convertir entre tipos:

# A entero
print(int("42"))      # 42
print(int(3.9))       # 3 — trunca, no redondea
print(int(True))      # 1
print(int(False))     # 0

# A float
print(float("3.14"))  # 3.14
print(float(10))      # 10.0
print(float("inf"))   # inf (infinito)

# A string
print(str(42))        # "42"
print(str(3.14))      # "3.14"
print(str(True))      # "True"
print(str(None))      # "None"

# A bool
print(bool(1))        # True
print(bool(0))        # False
print(bool("texto"))  # True
print(bool(""))       # False

# Conversión con validación
entrada = "abc"
try:
    numero = int(entrada)
except ValueError:
    print(f"'{entrada}' no es un número válido")

F-strings: la forma moderna de formatear texto

Las f-strings (cadenas de formato literal, introducidas en Python 3.6) son la forma más legible y eficiente de incluir expresiones dentro de strings:

nombre = "Carlos"
edad = 32
salario = 75000.5

# Básico — evalúa expresiones directamente
print(f"Hola, {nombre}!")
print(f"En 10 años tendrá {edad + 10} años")
print(f"Es mayor de edad: {edad >= 18}")

# Formateo de números
print(f"Salario: ${salario:,.2f}")      # $75,000.50
print(f"Salario: ${salario:.0f}")       # $75001
print(f"Porcentaje: {0.752:.1%}")       # 75.2%
print(f"Hex: {255:#x}")                 # 0xff
print(f"Número con ceros: {42:05d}")    # 00042
print(f"Alineado izquierda: {nombre:<15}|")  # Ana García     |
print(f"Alineado derecha: {nombre:>15}|")    # "    Ana García|"
print(f"Centrado: {nombre:^15}|")            # "  Ana García   |"

# Expresiones complejas dentro de f-strings
frutas = ["manzana", "pera", "uva"]
print(f"Primera fruta: {frutas[0].upper()}")
print(f"Cantidad: {len(frutas)}")

# Debugging con = (Python 3.8+)
x = 42
print(f"{x = }")      # x = 42 — muy útil para depurar
print(f"{nombre = }") # nombre = 'Carlos'

Variables múltiples y asignación en Python

Python soporta asignaciones elegantes que no encontrarás en otros lenguajes:

# Asignación múltiple en una línea
x = y = z = 0
print(x, y, z)  # 0 0 0

# Asignación por desempaquetado (tuple unpacking)
a, b, c = 1, 2, 3
print(a, b, c)  # 1 2 3

# Intercambio sin variable temporal
a, b = b, a
print(a, b)  # 2 1

# Desempaquetado con asterisco
primero, *resto = [1, 2, 3, 4, 5]
print(primero)  # 1
print(resto)    # [2, 3, 4, 5]

*inicio, ultimo = [1, 2, 3, 4, 5]
print(inicio)   # [1, 2, 3, 4]
print(ultimo)   # 5

Constantes en Python

Python no tiene constantes verdaderas, pero por convención se usan nombres en mayúsculas para indicar que un valor no debe modificarse:

# Convención: MAYÚSCULAS para constantes
MAX_INTENTOS = 3
URL_BASE = "https://api.ejemplo.com"
PI = 3.141592653589793
COLORES_VALIDOS = ("rojo", "verde", "azul")

# En Python 3.8+ puedes usar Final del módulo typing para mayor rigor
from typing import Final

NOMBRE_APP: Final = "Bemore Learn"
VERSION: Final[int] = 1

Resumen

Las variables en Python son dinámicamente tipadas pero fuertemente tipadas. Los tipos fundamentales son str, int, float, bool y None. Usa isinstance() en lugar de type() para verificaciones, f-strings para formatear texto de manera legible, y la convención de nombres snake_case para variables y funciones. En la próxima lección exploraremos los operadores y el control de flujo, donde estos tipos cobrarán vida real.

Evita usar type() para comparar tipos
Usa isinstance() en lugar de type(x) == int. isinstance() respeta la herencia de clases, lo que lo hace más robusto y Pythónico.
Tipado dinámico no significa sin tipos
Python tiene tipos fuertes — no hace conversiones implícitas raras como JavaScript. '5' + 5 lanza un TypeError, no devuelve '55' ni 10.
Convención de nombres en Python
Usa snake_case para variables y funciones (mi_variable), PascalCase para clases (MiClase), y SCREAMING_SNAKE_CASE para constantes (MAX_INTENTOS).