Fundamentos de Python: Variables y Tipos de Datos

Serie Fundamentos de Python — Parte 2. Esta publicación continúa Fundamentos de Python: Lo que Todo Principiante Debería Saber, que te dio un recorrido rápido por lo esencial. Cada publicación de la serie toma uno de esos temas y lo explica a fondo. Esta trata sobre variables y tipos de datos.

Todos los programas que escribas harán lo mismo en esencia: tomar información, trabajar con ella y producir un resultado. Un formulario de contacto recibe un nombre y un correo. Una calculadora de propinas recibe el total de la cuenta y un porcentaje. Un script que limpia la hoja de cálculo de un cliente recibe filas de texto y números. Antes de poder hacer algo con esa información, necesitas un lugar donde guardarla, y necesitas saber qué tipo de información es.

De eso se tratan las variables y los tipos de datos. En la Parte 1 viste un ejemplo de cuatro líneas y una lista corta de tipos. En esta publicación aprenderás cómo funcionan realmente las variables, cómo nombrarlas bien y cómo usar con confianza cada uno de los tipos de datos principales de Python, además de los errores que confunden a casi todos los principiantes.

Para seguir los ejemplos, abre una terminal y escribe python3 (o python en Windows) para iniciar el intérprete interactivo de Python. Puedes escribir cada ejemplo y ver el resultado de inmediato.

¿Qué Es una Variable?

Una variable es un nombre que apunta a un valor. La creas con el signo igual, que en Python significa “asignar”, no “es igual a”:

client_name = "Maria"
project_budget = 2500

Una forma útil de imaginarlo es como una etiqueta con nombre. El valor "Maria" existe en la memoria de tu computadora, y client_name es una etiqueta pegada a él. Cada vez que usas client_name en tu código, Python busca la etiqueta y usa el valor al que está pegada:

print(client_name)        # Maria
print(project_budget)     # 2500

Cambiar una Variable

Puedes reasignar una variable en cualquier momento. La etiqueta simplemente se mueve a un valor nuevo:

project_budget = 2500
project_budget = 3000     # el cliente aprobó páginas adicionales
print(project_budget)     # 3000

También puedes actualizar una variable a partir de su valor actual. Estas dos líneas hacen lo mismo:

project_budget = project_budget + 500
project_budget += 500

Python Deduce el Tipo por Ti

En algunos lenguajes tienes que declarar qué tipo de dato guardará una variable. Python no lo necesita: deduce el tipo a partir del valor. Esto se llama tipado dinámico:

page_count = 5            # Python sabe que es un número entero
page_count = "five"       # ahora es texto, y Python lo permite

Python permite que una variable cambie de tipo, pero casi nunca es buena idea. El código es mucho más fácil de leer cuando cada variable siempre guarda el mismo tipo de dato.

Revisar el Tipo de un Valor

Usa la función integrada type() para ver de qué tipo es un valor:

print(type("Maria"))      # <class 'str'>
print(type(2500))         # <class 'int'>
print(type(19.99))        # <class 'float'>
print(type(True))         # <class 'bool'>

Cuando necesites revisar un tipo dentro de tu código, por ejemplo antes de hacer una operación matemática, usa isinstance():

price = 19.99
print(isinstance(price, float))   # True

Cómo Nombrar Variables

Los buenos nombres hacen que tu código se lea casi como lenguaje natural. Python tiene algunas reglas que debes seguir y algunas convenciones que conviene seguir.

Las reglas:

Los nombres pueden contener letras, números y guiones bajos (_).
Los nombres no pueden empezar con un número: 2nd_page es un error, pero page_2 está bien.
Los nombres no pueden tener espacios ni guiones medios: usa client_email, no client email ni client-email.
Los nombres distinguen mayúsculas de minúsculas: price, Price y PRICE son tres variables distintas.
No puedes usar las palabras reservadas de Python, como if, for, class, def, True o None.

Las convenciones (de PEP 8, la guía de estilo oficial de Python):

Usa snake_case: palabras en minúsculas separadas por guiones bajos, como hourly_rate o is_published.
Usa nombres descriptivos. total_price te dice lo que guarda; tp o x no.
Usa MAYÚSCULAS para los valores que nunca deberían cambiar, llamados constantes: TAX_RATE = 0.0775. Python no te impide cambiarlos; las mayúsculas son una señal para otros programadores (y para ti en el futuro).
Empieza las variables de verdadero/falso con is_, has_ o can_: is_paid, has_logo.

Nota: en esta serie los nombres de las variables están en inglés, como es costumbre en la mayoría de los proyectos de Python. Python acepta nombres en español (por ejemplo, precio_total), pero evita los acentos y la ñ para no tener problemas.

# Difícil de entender
x = 85
y = 12
z = x * y

# Claro
HOURLY_RATE = 85
hours_worked = 12
invoice_total = HOURLY_RATE * hours_worked

Asignar Varias Variables a la Vez

Python te permite asignar varias variables en una sola línea:

width, height = 1920, 1080
print(width)    # 1920
print(height)   # 1080

Esto también hace muy fácil intercambiar dos valores, algo que en muchos otros lenguajes requiere tres líneas:

width, height = height, width
print(width, height)   # 1080 1920

Los Tipos de Datos Principales de Python

Un tipo de dato le dice a Python qué clase de valor es algo y, por lo tanto, qué puedes hacer con él. Puedes multiplicar dos números, pero no dos nombres. Puedes poner un texto en mayúsculas, pero no un número.

Estos son los tipos que usarás todos los días.

Cadenas (`str`): Texto

Una cadena (string) es cualquier texto entre comillas. Las comillas simples y dobles funcionan igual; solo sé consistente:

business_name = "Bright Bakery"
tagline = 'Fresh bread every morning'

Si tu texto contiene un apóstrofo, enciérralo en comillas dobles (o al revés):

message = "We're open on Sundays"

Para texto de varias líneas, usa comillas triples:

address = """123 Main Street
El Centro, CA 92243"""

Combinar Cadenas con f-strings

La forma más limpia de construir texto a partir de variables es una f-string: pon una f antes de las comillas de apertura y escribe las variables entre llaves:

client_name = "Maria"
pages = 5
print(f"Hi {client_name}, your website has {pages} pages.")
# Hi Maria, your website has 5 pages.

Las f-strings también pueden dar formato a los números. :.2f muestra dos decimales y :, agrega separadores de miles:

total = 2450.5
print(f"Total due: ${total:,.2f}")   # Total due: $2,450.50

También puedes unir cadenas con +, pero solo cadena con cadena. Verás por qué en la sección de errores comunes.

Métodos Útiles de las Cadenas

Las cadenas traen métodos integrados: acciones que llamas con un punto. Estos son algunos de los más útiles para limpiar datos:

email = "  [email protected]  "

print(email.strip())            # "[email protected]"   (quita los espacios de ambos extremos)
print(email.strip().lower())    # "[email protected]"
print(email.upper())            # "  [email protected]  "

title = "web design services"
print(title.title())            # "Web Design Services"
print(title.replace("web", "logo"))   # "logo design services"
print(title.split())            # ['web', 'design', 'services']
print(len(title))               # 19  (número de caracteres)

Los métodos de las cadenas no cambian la cadena original: devuelven una nueva. Para conservar el resultado, asígnalo a una variable:

email = email.strip().lower()

Índices y Rebanadas

Cada carácter de una cadena tiene una posición, llamada índice, que empieza en 0. Los índices negativos cuentan desde el final:

word = "Python"
print(word[0])      # P   (primer carácter)
print(word[-1])     # n   (último carácter)
print(word[0:3])    # Pyt (del índice 0 hasta el 3, sin incluirlo)
print(word[2:])     # thon (del índice 2 hasta el final)

Enteros (`int`): Números Enteros

Un entero es un número sin punto decimal, positivo o negativo:

pages = 8
year_founded = 2019
temperature = -4

Para números grandes, puedes usar guiones bajos para que sean más fáciles de leer. Python los ignora:

monthly_visitors = 1_250_000
print(monthly_visitors)   # 1250000

Flotantes (`float`): Números Decimales

Un flotante es un número con punto decimal:

price = 19.99
tax_rate = 0.0775

Python hace las operaciones con enteros y flotantes como esperarías. Observa que la división normal (/) siempre devuelve un flotante, mientras que la división entera (//) descarta la parte decimal:

print(10 + 3)    # 13
print(10 * 3)    # 30
print(10 / 3)    # 3.3333333333333335
print(10 // 3)   # 3   (división entera)
print(10 % 3)    # 1   (residuo)
print(2 ** 3)    # 8   (2 elevado a la 3)

Los flotantes no son perfectamente precisos. Las computadoras guardan los decimales en binario, así que algunos valores no se pueden representar con exactitud. Prueba print(0.1 + 0.2): obtendrás 0.30000000000000004. Para mostrar el resultado, redondéalo con round(0.1 + 0.2, 2) o dale formato con una f-string. Para dinero en software financiero serio, el módulo decimal de Python evita el problema por completo.

Booleanos (`bool`): Verdadero o Falso

Un booleano solo tiene dos valores posibles: True o False (siempre con mayúscula inicial). Los booleanos son lo que tu programa usa para tomar decisiones:

is_published = True
has_ssl = False

Casi siempre obtendrás booleanos a partir de comparaciones:

budget = 3000
print(budget > 2000)      # True
print(budget == 2500)     # False
print(budget != 2500)     # True

Combínalos con and, or y not:

is_paid = True
is_approved = False

print(is_paid and is_approved)   # False (ambos deben ser True)
print(is_paid or is_approved)    # True  (al menos uno es True)
print(not is_approved)           # True  (invierte el valor)

Valores Verdaderos y Falsos

En Python, todo valor cuenta como verdadero o falso cuando se usa en una condición. Estos valores son falsos (falsy): False, 0, 0.0, el texto vacío "", una lista vacía [], un diccionario vacío {} y None. Casi todo lo demás es verdadero (truthy). Puedes revisar cualquier valor con bool():

print(bool(""))          # False
print(bool("Maria"))     # True
print(bool(0))           # False
print(bool([]))          # False
print(bool([1, 2]))      # True

Esto te permite escribir revisiones cortas y legibles, como asegurarte de que un campo de un formulario no esté vacío:

client_name = ""
if not client_name:
    print("Please enter your name.")

None: La Ausencia de un Valor

None es un valor especial que significa “todavía no hay nada aquí”. Es útil cuando una variable tiene que existir antes de que conozcas su valor:

launch_date = None    # todavía no está programada

if launch_date is None:
    print("Launch date to be decided.")

Para revisar si algo es None, usa is None en lugar de == None. Es el estilo estándar de Python y siempre es confiable.

Convertir Entre Tipos

A veces tienes el dato correcto en el tipo equivocado. El ejemplo más común: la función input(), que le pide al usuario que escriba algo, siempre devuelve una cadena, aunque el usuario escriba un número.

age = input("How old are you? ")   # el usuario escribe 28
print(type(age))                   # <class 'str'>

Para hacer operaciones con ese valor, primero conviértelo. Python tiene una función integrada para cada tipo:

print(int("28"))        # 28      texto → entero
print(float("19.99"))   # 19.99   texto → flotante
print(str(2500))        # "2500"  número → texto
print(int(9.99))        # 9       flotante → entero (corta el decimal, no redondea)
print(float(5))         # 5.0     entero → flotante

Si el texto no se puede convertir, Python lanza un ValueError:

int("twenty")   # ValueError: invalid literal for int() with base 10: 'twenty'

En la Parte 8: Archivos y Excepciones aprenderás a manejar errores como este de forma elegante. Por ahora, solo recuerda que convertir lo que escribe el usuario es una de las fuentes de errores más comunes entre principiantes.

Colecciones: Guardar Muchos Valores

Hasta ahora, cada variable ha guardado un solo valor. Los programas reales casi siempre necesitan trabajar con grupos de valores: una lista de servicios, los datos de contacto de un cliente, un conjunto de etiquetas. Python tiene cuatro tipos de colección integrados para eso.

Listas: Ordenadas y Modificables

Una lista guarda una secuencia ordenada de valores entre corchetes. Es la colección que más usarás:

services = ["Web Design", "SEO", "Hosting"]

print(services[0])      # Web Design (los índices empiezan en 0, igual que en las cadenas)
print(services[-1])     # Hosting
print(len(services))    # 3

Las listas son mutables, es decir, puedes cambiarlas después de crearlas:

services.append("Logo Design")     # agrega al final
services.remove("Hosting")         # quita por valor
services[0] = "Website Design"     # reemplaza un elemento
print(services)
# ['Website Design', 'SEO', 'Logo Design']

Puedes revisar si algo está en una lista con in:

print("SEO" in services)   # True

Tuplas: Ordenadas e Inmutables

Una tupla se parece a una lista, pero usa paréntesis y no se puede cambiar después de crearla. Usa tuplas para valores que van juntos y no deberían cambiar, como coordenadas o el tamaño de una pantalla:

screen_size = (1920, 1080)
brand_color = (91, 33, 182)    # un color RGB

print(screen_size[0])   # 1920

Intentar cambiar una tupla produce un error:

screen_size[0] = 1280   # TypeError: 'tuple' object does not support item assignment

Diccionarios: Pares Clave-Valor

Un diccionario (dict) guarda valores bajo claves, como las etiquetas de un formulario. En lugar de buscar los elementos por posición, los buscas por nombre:

client = {
    "name": "Maria",
    "business": "Bright Bakery",
    "budget": 2500,
}

print(client["name"])       # Maria

Los diccionarios son mutables. Asignar un valor a una clave la agrega, o la actualiza si ya existe:

client["budget"] = 3000           # actualiza una clave existente
client["email"] = "[email protected]"   # agrega una clave nueva

Buscar una clave que no existe produce un KeyError. Usa .get() cuando una clave podría faltar: devuelve None (o el valor predeterminado que elijas) en lugar de fallar:

print(client.get("phone"))                    # None
print(client.get("phone", "No phone given"))  # No phone given

Para recorrer todo un diccionario, usa un ciclo sobre .items():

for key, value in client.items():
    print(f"{key}: {value}")

Los diccionarios están en todas partes en Python. Cuando trabajas con JSON de una API, se convierte en diccionarios y listas.

Conjuntos: Solo Valores Únicos

Un conjunto (set) guarda valores sin duplicados y sin un orden particular. Los conjuntos son perfectos para eliminar repeticiones:

tags = ["python", "web", "python", "seo", "web"]
unique_tags = set(tags)
print(unique_tags)   # {'python', 'web', 'seo'}  (el orden puede variar)

¿Qué Colección Deberías Usar?

Tipo	Sintaxis	¿Ordenada?	¿Modificable?	¿Duplicados?	Úsala para
Lista	`["a", "b"]`	Sí	Sí	Sí	Una secuencia de elementos que vas a agregar o cambiar
Tupla	`("a", "b")`	Sí	No	Sí	Grupos fijos de valores, como coordenadas
Diccionario	`{"key": "value"}`	Sí	Sí	Las claves deben ser únicas	Buscar valores por nombre
Conjunto	`{"a", "b"}`	No	Sí	No	Valores únicos, eliminar duplicados

Las listas y los diccionarios son las dos colecciones que más usarás. La Parte 3 de esta serie las explica a fondo: cómo ordenarlas, buscar en ellas, comprensiones, datos anidados y más.

Mutables vs. Inmutables: Por Qué Importa

Algunos tipos se pueden cambiar después de crearlos (mutables: listas, diccionarios y conjuntos) y otros no (inmutables: cadenas, números, booleanos, tuplas y None).

Esto importa por la forma en que funcionan las variables. Recuerda la imagen de las etiquetas: asignar una variable a otra no copia el valor, sino que pone una segunda etiqueta en el mismo valor. Con valores inmutables eso nunca causa sorpresas. Con los mutables, sí puede:

original = ["Home", "About", "Contact"]
menu = original          # ambos nombres apuntan a la MISMA lista
menu.append("Blog")

print(original)   # ['Home', 'About', 'Contact', 'Blog']  ← ¡también cambió!

Si quieres una copia independiente, pídela con .copy():

original = ["Home", "About", "Contact"]
menu = original.copy()   # una lista separada
menu.append("Blog")

print(original)   # ['Home', 'About', 'Contact']
print(menu)       # ['Home', 'About', 'Contact', 'Blog']

Todo Junto: Una Cotización Sencilla

Este es un script corto que usa todo lo que viste en esta publicación para armar la cotización de un proyecto web:

# Constantes: valores que no cambian
HOURLY_RATE = 85
TAX_RATE = 0.0775

# Datos del cliente en un diccionario
client = {"name": "Maria", "business": "Bright Bakery"}

# Páginas y las horas que toma cada una
pages = {"Home": 6, "About": 3, "Menu": 4, "Contact": 2}
extras = ["SEO setup", "Google Analytics"]
is_rush_job = False

# Cálculos
total_hours = sum(pages.values())
subtotal = total_hours * HOURLY_RATE
if is_rush_job:
    subtotal = subtotal * 1.25
tax = round(subtotal * TAX_RATE, 2)
total = subtotal + tax

# Resultado
print(f"Quote for {client['name']} ({client['business']})")
print(f"Pages: {', '.join(pages)}")
print(f"Extras: {', '.join(extras)}")
print(f"{total_hours} hours x ${HOURLY_RATE}/hour = ${subtotal:,.2f}")
print(f"Tax: ${tax:,.2f}")
print(f"Total: ${total:,.2f}")

Al ejecutarlo, imprime:

Quote for Maria (Bright Bakery)
Pages: Home, About, Menu, Contact
Extras: SEO setup, Google Analytics
15 hours x $85/hour = $1,275.00
Tax: $98.81
Total: $1,373.81

Prueba a cambiar los valores (agrega una página, cambia is_rush_job a True o modifica la tarifa por hora) y ejecútalo de nuevo.

Errores Comunes de Principiantes

Sumar texto y un número. Python no adivina lo que quieres decir:

pages = 5
print("Pages: " + pages)   # TypeError: can only concatenate str (not "int") to str

Usa una f-string, print(f"Pages: {pages}"), o convierte el número con str(pages).

Olvidar que input() devuelve texto. input("Budget? ") * 2 repite el texto en lugar de duplicar el número. Primero conviértelo con int() o float().

Usar = cuando quieres decir ==. Un solo = asigna un valor; el doble == compara dos valores.

Ponerle a una variable el nombre de una función integrada. Nombres como list, str, dict, type o input ya los usa Python. Si escribes list = [1, 2, 3], ya no podrás usar la función list() en ese programa. Elige un nombre más específico, como page_list.

Esperar resultados exactos de los flotantes. 0.1 + 0.2 == 0.3 es False. Redondea antes de comparar o mostrar.

Copiar una lista con una asignación. menu = original no copia la lista; usa original.copy().

Buscar una clave que no existe en un diccionario. client["phone"] falla si no hay una clave "phone". Usa client.get("phone") cuando la clave podría no existir.

Ejercicios de Práctica

Intenta resolverlos por tu cuenta antes de seguir:

Crea variables con tu nombre, tu edad y tu lenguaje de programación favorito, y luego imprime una oración con una f-string.
Pide un precio al usuario con input(), conviértelo a flotante, súmale 7.75% de impuesto e imprime el total con dos decimales.
Toma la cadena " [email protected] " y conviértela en una dirección de correo limpia y en minúsculas.
Crea una lista con tres páginas de un sitio web, agrega una cuarta, quita la primera e imprime cuántas quedan.
Crea un diccionario que describa un sitio web (nombre, número de páginas, ¿está publicado?) e imprime cada clave y su valor.
Elimina los duplicados de ["red", "blue", "red", "green", "blue"].

Si quieres práctica más estructurada, el Reto de 100 Días de Python construye un pequeño proyecto cada día, y los primeros días se apoyan justamente en estas habilidades.

Conclusión

Las variables y los tipos de datos son la base de todo programa en Python. Una variable es un nombre que apunta a un valor, y el tipo de ese valor (cadena, entero, flotante, booleano, None, lista, tupla, diccionario o conjunto) decide qué puedes hacer con él. Cuando sepas elegir el tipo correcto, convertir entre tipos y evitar las trampas comunes, como sumar texto con números o compartir una lista por accidente, estarás listo para todo lo que viene.

Sigue experimentando en el intérprete de Python: la forma más rápida de entender un tipo de dato es crear uno y ver lo que puede hacer.

Siguiente en la serie Fundamentos de Python: Listas y Diccionarios, una mirada a fondo a las dos colecciones más usadas de Python.

Serie Fundamentos de Python: Parte 1: Lo que Todo Principiante Debería Saber · Parte 2: Variables y Tipos de Datos · Parte 3: Listas y Diccionarios · Parte 4: La Sentencia If · Parte 5: Entrada del Usuario y Ciclos While · Parte 6: Funciones · Parte 7: Clases · Parte 8: Archivos y Excepciones · Parte 9: Cómo Probar tu Código