Python · Lección 04 de 27

Variables y constantes

Las variables son el mecanismo fundamental para guardar, reutilizar y transformar datos en cualquier programa. Cómo las nombres y organices define si tu código es profesional o un desastre inmantenible.

70–90 min Prerrequisitos: 03 Tipos de datos

Concepto teórico

¿Qué es una variable?

Una variable es un nombre que le asignás a un valor para poder usarlo después. Internamente, Python crea un objeto en memoria con el valor y hace que el nombre "apunte" a ese objeto. Cuando escribís edad = 28, Python reserva espacio para el número 28 y asocia el nombre edad a esa ubicación de memoria.

A diferencia de lenguajes como Java o C++ donde declarás el tipo explícitamente (int edad = 28;), Python usa tipado dinámico: el tipo se infiere automáticamente del valor que asignás. Esto significa que la misma variable puede cambiar de tipo durante la ejecución del programa:

x = 42          # x es int
x = "cuarenta"  # ahora x es str — Python no se queja
x = [1, 2, 3]   # ahora x es list — sigue sin quejarse

Analogía: las cajas con etiquetas. Imaginá un depósito con cajas. Cada caja tiene una etiqueta (el nombre de la variable) y adentro guardás algo (el valor). Podés abrir la caja y cambiar el contenido (reasignar), podés leer lo que tiene (usar la variable), o podés pegarle una etiqueta nueva a otra caja. Lo importante es que la etiqueta sea descriptiva: una caja que dice "saldo_cuenta" es mucho más útil que una que dice "x".

Crear y reasignar variables

Crear una variable es simplísimo: nombre = valor. El signo = es el operador de asignación — NO significa "es igual a" (eso es ==). Significa "guardá este valor con este nombre".

Python ofrece algunas formas avanzadas de asignación que son muy útiles:

Asignación múltiple: a, b, c = 1, 2, 3 — asigná varios valores en una línea
Mismo valor a varias: x = y = z = 0 — inicializar varias variables en cero
Intercambio (swap): a, b = b, a — intercambiá dos valores SIN variable temporal. En otros lenguajes necesitarías una variable auxiliar temp. Python lo hace en una línea.
Desempaquetado: nombre, edad = ["García", 35] — extraé valores de una lista/tupla directamente a variables

Reglas de naming (obligatorias)

Python tiene reglas estrictas sobre qué nombres son válidos:

Regla	Válido	Inválido	Por qué
Solo letras, números y `_`	`saldo_1`	`saldo-1`, `saldo.1`	Guión y punto son operadores
Debe empezar con letra o `_`	`_temp`, `edad`	`1er_nombre`	Empezar con número es inválido
Case-sensitive	`Edad` ≠ `edad` ≠ `EDAD`	—	Son 3 variables distintas
No usar palabras reservadas	`mi_clase`	`class`, `if`, `for`	Son palabras del lenguaje

Convenciones de estilo (PEP 8)

Además de las reglas obligatorias, Python tiene convenciones de estilo que todo programador profesional sigue. Están documentadas en PEP 8 (Python Enhancement Proposal #8):

Variables y funciones: snake_case — todo en minúsculas, palabras separadas por guión bajo. Ejemplo: saldo_cuenta, ingreso_mensual, calcular_cuota
Constantes: UPPER_SNAKE_CASE — todo en mayúsculas. Ejemplo: IVA, DOLAR_OFICIAL, MAX_INTENTOS
Clases: PascalCase — cada palabra empieza en mayúscula. Ejemplo: CuentaBancaria, ClientePremium
Variables privadas: empiezan con _. Ejemplo: _cache_interno

Error común: usar nombres genéricos. Variables como x, data, temp, valor no dicen nada. ¿x es un precio, un score, una edad? Nadie lo sabe sin leer todo el contexto. Usá nombres descriptivos: precio_unitario, score_crediticio, edad_cliente. Tu yo de dentro de 3 meses te lo va a agradecer.

Constantes (por convención)

Python no tiene constantes reales. A diferencia de JavaScript (const) o Java (final), no hay forma de forzar que una variable no cambie. La convención es escribirla en MAYÚSCULAS para indicar que no debería modificarse. Es un acuerdo entre programadores, no una restricción del lenguaje.

Las constantes se usan para valores que definen la configuración de tu programa y no deberían cambiar durante la ejecución: tasas impositivas, límites, URLs de APIs, claves de configuración.

Tip profesional: poné todas las constantes al inicio del archivo, después de los imports. Así cualquier persona que lea tu código sabe inmediatamente qué parámetros usa y puede ajustarlos sin buscar en todo el programa. Esto es estándar en cualquier equipo profesional.

f-strings: formateo moderno de texto

Los f-strings (format strings) son la forma moderna y preferida de incluir variables dentro de texto. Se escriben con una f antes de las comillas y las variables van entre llaves {}:

print(f"Hola, {nombre}. Tenés {edad} años.")

Dentro de las llaves podés poner cualquier expresión de Python, incluyendo cálculos, llamadas a funciones y formatos especiales:

{precio:,.2f} — formato con separador de miles y 2 decimales: 1,234,567.89
{porcentaje:.1%} — formato como porcentaje con 1 decimal: 15.3%
{nombre:>20} — alineado a la derecha en 20 caracteres
{nombre:<20} — alineado a la izquierda
{nombre:^20} — centrado

En análisis de datos: el formato :,.2f (separador de miles + 2 decimales) lo vas a usar en CADA reporte. ${saldo:,.2f} muestra $1,234,567.89 en vez de $1234567.89. Esa diferencia es la que hace que tu reporte parezca profesional o amateur.

Ejemplos explicados paso a paso

Ejemplo 1: Crear, reasignar y verificar tipos

Fijate cómo Python permite cambiar el tipo de una variable sin quejarse. Esto es el tipado dinámico en acción.

ejemplo_01_variables.pyPython

# Crear variables
nombre = "Rodrigo González"
edad = 28
salario = 850000.50
es_empleado = True
comentario = None

# Imprimir con formato
print(f"Nombre: {nombre}")
print(f"Edad: {edad}")
print(f"Salario: ${salario:,.2f}")
print(f"Empleado: {es_empleado}")
print(f"Comentario: {comentario}")

# Reasignar (cambiar el valor)
edad = 29
print(f"\nEdad actualizada: {edad}")

# Incluso cambiar el tipo (tipado dinámico)
x = 100
print(f"\nx = {x}, tipo: {type(x).__name__}")
x = "cien"
print(f"x = {x}, tipo: {type(x).__name__}")
x = [1, 0, 0]
print(f"x = {x}, tipo: {type(x).__name__}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Asignación múltiple, swap y desempaquetado

Python tiene formas elegantes de asignar valores que en otros lenguajes requerirían varias líneas.

ejemplo_02_asignacion.pyPython

# Asignación múltiple en una línea
nombre, edad, ciudad = "García", 35, "Buenos Aires"
print(f"{nombre}, {edad} años, {ciudad}")

# Mismo valor a múltiples variables
error_count = warning_count = info_count = 0
print(f"Contadores: {error_count}, {warning_count}, {info_count}")

# Swap (intercambiar sin variable temporal)
a = "primer valor"
b = "segundo valor"
print(f"\nAntes: a='{a}', b='{b}'")
a, b = b, a  # ¡Una sola línea!
print(f"Después: a='{a}', b='{b}'")

# Desempaquetado de lista
datos_cliente = ["López", 42, "Córdoba", 720]
nombre, edad, ciudad, score = datos_cliente
print(f"\nCliente: {nombre}, Score: {score}")

# Desempaquetado parcial con *
primero, *resto = [100, 200, 300, 400, 500]
print(f"\nPrimero: {primero}, Resto: {resto}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Constantes y configuración profesional

Así se estructura un archivo Python profesional: constantes arriba, lógica abajo. Cualquiera puede ajustar los parámetros sin buscar en el código.

ejemplo_03_constantes.pyPython

# ═══ CONSTANTES (configuración del programa) ═══
IVA = 0.21
IMPUESTO_GANANCIAS = 0.17
IMPUESTO_JUBILACION = 0.11
IMPUESTO_OBRA_SOCIAL = 0.03
DOLAR_OFICIAL = 1150.50
DOLAR_MEP = 1280.00
SCORE_MINIMO_CREDITO = 650
MAX_RATIO_CUOTA_INGRESO = 0.35

# ═══ DATOS DEL CASO ═══
sueldo_bruto = 950000
precio_producto = 45000
ahorro_usd = 2000

# ═══ CÁLCULOS ═══
# Sueldo neto
deduccion_jub = sueldo_bruto * IMPUESTO_JUBILACION
deduccion_os = sueldo_bruto * IMPUESTO_OBRA_SOCIAL
deduccion_gan = sueldo_bruto * IMPUESTO_GANANCIAS
sueldo_neto = sueldo_bruto - deduccion_jub - deduccion_os - deduccion_gan

print(f"{'═'*40}")
print(f"  RECIBO DE SUELDO")
print(f"{'═'*40}")
print(f"  Bruto:        ${sueldo_bruto:>12,.0f}")
print(f"  Jubilación:   ${deduccion_jub:>12,.0f}")
print(f"  Obra social:  ${deduccion_os:>12,.0f}")
print(f"  Ganancias:    ${deduccion_gan:>12,.0f}")
print(f"{'─'*40}")
print(f"  NETO:         ${sueldo_neto:>12,.0f}")
print(f"{'═'*40}")

# Precio con IVA
print(f"\nProducto ${precio_producto:,} + IVA = ${precio_producto * (1 + IVA):,.0f}")

# Conversión de ahorros
print(f"\nUSD {ahorro_usd:,} = ${ahorro_usd * DOLAR_OFICIAL:,.0f} (oficial)")
print(f"USD {ahorro_usd:,} = ${ahorro_usd * DOLAR_MEP:,.0f} (MEP)")

Hacé clic en ▶ Ejecutar

Ejemplo 4: f-strings avanzados — formato de números

Dominá el formato de números en f-strings. Esto es lo que hace que tus reportes se vean profesionales.

ejemplo_04_fstrings.pyPython

nombre = "García"
saldo = 1234567.891
tasa = 0.0653
cantidad = 42

# Formato de moneda (separador de miles + decimales)
print(f"Saldo: ${saldo:,.2f}")          # $1,234,567.89
print(f"Saldo entero: ${saldo:,.0f}")   # $1,234,568

# Formato de porcentaje
print(f"Tasa: {tasa:.2%}")              # 6.53%
print(f"Tasa: {tasa:.1%}")              # 6.5%

# Alineación (útil para tablas)
print(f"\n{'─'*35}")
print(f"{'Concepto':<20} {'Monto':>12}")
print(f"{'─'*35}")
print(f"{'Sueldo bruto':<20} ${450000:>10,.0f}")
print(f"{'Jubilación':<20} ${-49500:>10,.0f}")
print(f"{'Ganancias':<20} ${-76500:>10,.0f}")
print(f"{'─'*35}")
print(f"{'NETO':<20} ${324000:>10,.0f}")

# Padding con ceros (útil para IDs)
for i in range(1, 6):
    print(f"Factura: FAC-{i:05d}")     # FAC-00001, FAC-00002...

# Expresiones dentro de f-strings
print(f"\n2 + 2 = {2 + 2}")
print(f"{'PAR' if cantidad % 2 == 0 else 'IMPAR'}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Nombres buenos vs malos — el impacto en código real

Compará dos versiones del mismo programa. El de la izquierda es ilegible; el de la derecha se explica solo.

ejemplo_05_naming.pyPython

# ❌ VERSIÓN ILEGIBLE (nombres genéricos)
a = 500000
b = 0.65
c = 12
d = a * b
e = a + d
f = e / c
print(f"Resultado: {f}")
# ¿Qué calcula esto? Sin leer cada línea no tenés idea.

print()

# ✅ VERSIÓN PROFESIONAL (nombres descriptivos)
capital_prestamo = 500000
tasa_anual = 0.65
plazo_meses = 12
interes_total = capital_prestamo * tasa_anual
monto_total = capital_prestamo + interes_total
cuota_mensual = monto_total / plazo_meses
print(f"Cuota mensual: ${cuota_mensual:,.0f}")
# Se entiende SOLO con los nombres, sin comentarios.

# Moraleja: el código se lee 10 veces más de lo que se escribe.
# Invertí 5 segundos en un buen nombre y ahorrá 5 minutos cada vez
# que alguien (incluido vos) lea el código.

Hacé clic en ▶ Ejecutar

Referencia rápida

Operación	Sintaxis	Ejemplo
Crear variable	`nombre = valor`	`edad = 28`
Reasignar	`nombre = nuevo_valor`	`edad = 29`
Asignación múltiple	`a, b, c = v1, v2, v3`	`x, y = 10, 20`
Swap	`a, b = b, a`	Intercambia valores
Desempaquetado	`a, b = lista`	`nombre, edad = ["Ana", 25]`
Verificar tipo	`type(variable)`	`type(edad).__name__`

Convención	Estilo	Ejemplo	Uso
Variables/funciones	`snake_case`	`saldo_cuenta`	Todo el código general
Constantes	`UPPER_SNAKE_CASE`	`IVA`, `DOLAR_MEP`	Valores que no cambian
Clases	`PascalCase`	`CuentaBancaria`	Definiciones de clases
Privadas	`_prefijo`	`_cache`	Uso interno

Formato f-string	Ejemplo	Resultado
`:,.2f`	`f"${1234.5:,.2f}"`	`$1,234.50`
`:.1%`	`f"{0.153:.1%}"`	`15.3%`
`:>12`	`f"{'hola':>12}"`	`hola`
`:<12`	`f"{'hola':<12}"`	`hola`
`:05d`	`f"{42:05d}"`	`00042`

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Crear e imprimir variables

Creá variables nombre, edad y ciudad con tus datos e imprimilas usando f-string en una sola línea. Debe incluir años.

ejercicio_01.pyDebe incluir "años"

# Creá 3 variables e imprimilas:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Reasignación

Creá saldo = 100000. Imprimilo. Reasignalo a 150000. Imprimilo de nuevo. Debe incluir 150000.

ejercicio_02.pyDebe incluir "150000"

saldo = 100000
# Imprimí, reasigná e imprimí de nuevo:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Asignación múltiple y swap

Asigná a = "primero" y b = "segundo" en una línea. Intercambialos con swap e imprimí ambos. Debe incluir a = segundo.

ejercicio_03.pyDebe incluir "a = segundo"

# Asignación múltiple + swap:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Sueldo neto con constantes

Definí constantes JUBILACION = 0.11 y GANANCIAS = 0.17. Con sueldo_bruto = 750000, calculá e imprimí el neto. Debe incluir 540000.

ejercicio_04.pyDebe incluir "540000"

# Constantes y cálculo de sueldo neto:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Formateo de moneda

Dado monto = 2345678.5, imprimilo con formato de moneda argentina: $2,345,678.50. Debe incluir $2,345,678.50.

ejercicio_05.pyDebe incluir "$2,345,678.50"

monto = 2345678.5

# Imprimí con formato:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Desempaquetado de datos

Tenés datos = ["Fernández", 30, "Mendoza", 710, 280000]. Desempaquetá en variables con nombres descriptivos e imprimí un resumen. Debe incluir Score: 710.

ejercicio_06.pyDebe incluir "Score: 710"

datos = ["Fernández", 30, "Mendoza", 710, 280000]

# Desempaquetá e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Tabla formateada con f-strings

Imprimí esta tabla alineada usando f-strings con :<20 y :>10. Debe incluir Total.

Concepto              Monto
──────────────────────────────
Sueldo               $450,000
Alquiler             -$85,000
Servicios            -$32,000
──────────────────────────────
Total                $333,000

ejercicio_07.pyDebe incluir "Total"

# Armá la tabla con f-strings:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Conversión de moneda con constantes

Definí DOLAR_OFICIAL = 1150 y DOLAR_MEP = 1280. Dado ahorro_usd = 3500, imprimí cuánto es en pesos con cada tipo de cambio y la diferencia (brecha). Debe incluir Brecha.

ejercicio_08.pyDebe incluir "Brecha"

DOLAR_OFICIAL = 1150
DOLAR_MEP = 1280
ahorro_usd = 3500

# Calculá e imprimí oficial, MEP y brecha:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Generador de IDs con padding

Generá 5 IDs de factura con formato FAC-2025-00001 a FAC-2025-00005. Usá un for con range y f-string con :05d. Debe incluir FAC-2025-00003.

ejercicio_09.pyDebe incluir "FAC-2025-00003"

ANIO = 2025

# Generá los 5 IDs:
for i in range(1, 6):
    pass  # reemplazá pass

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Recibo de sueldo completo con formato profesional

Construí un recibo de sueldo formateado. Bruto: $1,200,000. Deducciones: jubilación 11%, obra social 3%, ganancias 17%. Calculá cada deducción, el total de deducciones y el neto. Imprimí todo con alineación y formato de moneda. Debe incluir Neto: y 828,000.

ejercicio_10_desafio.pyDebe incluir "828,000"

# Constantes
JUBILACION = 0.11
OBRA_SOCIAL = 0.03
GANANCIAS = 0.17

sueldo_bruto = 1200000

# Armá el recibo completo con formato:

Hacé clic en ▶ Ejecutar

Resumen y conexión

Las variables se crean con = (asignación). Python infiere el tipo automáticamente (tipado dinámico).
Podés hacer asignación múltiple (a, b = 1, 2), swap (a, b = b, a) y desempaquetado en una línea.
Convención PEP 8: variables en snake_case, constantes en UPPER_CASE, clases en PascalCase.
Los f-strings (f"...") son la forma moderna de formatear texto. Usá :,.2f para moneda y :.1% para porcentajes.
Nombres descriptivos (saldo_cuenta) valen 100 veces más que nombres genéricos (x).
Las constantes van al inicio del archivo para que cualquiera pueda ajustar la configuración.

En la siguiente lección (05 · Operaciones básicas) vas a aprender a usar operadores aritméticos, de comparación y lógicos para calcular, comparar y tomar decisiones con los datos que acabás de aprender a guardar en variables.

Recursos: PEP 8 — Style Guide · Python docs — f-strings

Hecho con ❤️ por Rodri Gonzalez