Escribe los pasos una vez. Deja que la computadora los repita.
La historia hasta ahora Tu hoja de cálculo de afinaciones (Lección 17.1) funciona. Ahora quieres poner $200 al mes, o sea $2,400 al año, de las afinaciones en un fondo indexado (Lección 5.3). Si gana 7% al año, ¿cuánto vas a tener en 30 años? ¿Y si gana 4%, o 10%? En una hoja de cálculo son 30 filas por cada intento. En Python son cuatro líneas, y la computadora las repite por ti. Por eso los bancos, los fondos y las empresas fintech contratan a gente que sabe programar.
Python es un lenguaje de programación: escribes pasos en un texto fácil de leer, y la computadora los corre en orden.
Repite trabajo en un instante, maneja millones de filas que romperían una hoja de cálculo y vuelve a correr el mismo reporte mañana con un clic.
Guarda números en variables, junta muchos en una lista, repite pasos con un bucle y agrupa los pasos que reusas en una función.
Los equipos de análisis cuantitativo prueban ideas de inversión con él. Los equipos de riesgos corren miles de escenarios. En los bancos, el análisis de datos limpia y estudia enormes bases de datos.
Qué estás viendo: un programa corto de Python. Empieza con $0 y, 30 veces, hace crecer el saldo un 7% y le suma los $2,400 del año. La última línea imprime el resultado: unos $226,706. La línea verde de abajo es lo que imprime.
El código es una receta que la computadora sigue.
Python corre tus líneas de arriba abajo. Una variable es un nombre que guarda un valor: el signo = significa "guarda esto", no "es igual a". print() muestra un resultado en la pantalla. Los nombres en el código van en inglés, como se usa en el trabajo.
price = 40
tune_ups = 25
revenue = price * tune_ups
print(revenue)1000- price y tune_ups
- Variables con el precio, 40, y las afinaciones, 25, como las celdas B1 y B2 de la Lección 17.1.
- revenue
- Los ingresos: 40 × 25 = 1000. Igual que en una hoja de cálculo, * significa por.
Listas: muchos números con un solo nombre
Una lista guarda muchos valores entre corchetes. sum() los suma y len() los cuenta. Python divide con la barra diagonal: sum(months) / len(months) significa sum(months)len(months), el promedio.
months = [20, 25, 30]
print(sum(months))
print(len(months))
print(sum(months) / len(months))75
3
25.0- sum(months)
- 20 + 25 + 30 = 75 afinaciones.
- len(months)
- 3 meses en la lista: 3.
- El promedio
- 753 = 25.0. Python muestra .0 después de una división.
Bucles: repite los pasos
Un bucle for repite las líneas que tienen sangría debajo de él. range(3) da los números 0, 1 y 2, así que el bucle corre 3 veces. Los espacios al inicio de la línea importan: las líneas con sangría están dentro del bucle, y la primera línea sin sangría corre cuando el bucle termina. Cada vez, balance = balance * 1.10 toma el saldo anterior, lo hace crecer 10% y guarda el nuevo con el mismo nombre.
balance = 1000
for year in range(3):
balance = balance * 1.10
print(round(balance))1331- Cada vuelta
- $1,000 → $1,100 → $1,210 → $1,331, el mismo crecimiento compuesto de la Lección 10.1.
- round()
- Redondea a un número entero, para que no veas 1331.0000000000005.
Tus ahorros, 30 años en cuatro líneas
Cambia dos números y el bucle responde una pregunta nueva. Aquí, cada año el saldo crece según el rendimiento y luego sumas $2,400. Mueve el control para cambiar la tasa y mira cómo cambian el código y lo que imprime.
Qué estás viendo: el código, lo que imprime y tu saldo cada 5 años, con barras para los años 5 a 30. El verde es lo que pones tú ($2,400 al año); el dorado de arriba es el crecimiento por los rendimientos.
- Al 0%
- 30 × $2,400 = $72,000: solo lo que pusiste.
- Al 7%
- $226,706. $154,706 son crecimiento.
- Al 10%
- $394,786. Tres puntos más de rendimiento, $168,080 más de dinero.
Funciones y decisiones
Una función agrupa pasos que reusas: def le pone nombre y return devuelve la respuesta. Un if deja que el código decida: la línea con sangría debajo del if corre solo si la prueba es verdadera; si no, corre la línea debajo de else.
def profit(tune_ups):
return tune_ups * 30 - 300
print(profit(20))
npv = 1372
if npv > 0:
print("Build it")
else:
print("Skip it")300
Build it- profit(20)
- La ganancia: 20 × ($40 − $10) − $300 = 300, la de enero en la Lección 17.1.
- El if
- El VPN de la camioneta de reparaciones es $1,372 (Lección 13.2), mayor que 0, así que imprime Build it ("constrúyelo").
pandas: una hoja de cálculo dentro de tu código
Python tiene complementos gratis llamados bibliotecas. La que más se usa en finanzas es pandas. Su DataFrame es una tabla, como una hoja de cálculo que controlas con código. Una hoja de Excel llega hasta 1,048,576 filas; los registros de operaciones de un banco pueden tener cientos de millones. pandas los lee y suma una columna en una sola línea.
import pandas as pd
df = pd.DataFrame({"month": ["Jan", "Feb", "Mar"], "profit": [300, 450, 600]})
print(df["profit"].sum())1350- La tabla
- Dos columnas, mes y ganancia, y tres filas: tus primeros tres meses de la Lección 17.1.
- df["profit"].sum()
- $300 + $450 + $600 = 1350. La misma línea funciona con 300 filas o con 300 millones.
Dos minutos. Solo escucha.
Toca cualquier línea para saltar a ella.
Revisa el código.
Ocho programas cortos. Lee cada uno y elige lo que imprime. Un intento por pregunta.
Qué estás viendo: programas inventados. Cada uno muestra el código y luego hace una pregunta sobre él.
La lógica, paso a paso.
Para leer cualquier programa corto, sigue cuatro pasos.
Paso 1: Lee de arriba abajo
- El código de ahorro
- Pone balance en 0, luego el bucle, luego imprime.
Paso 2: Sigue cada variable
- balance
- Empieza en 0.
Paso 3: Cuenta las vueltas
- range(30)
- 30 vueltas: crecer 7% y sumar $2,400.
Paso 4: Revisa la primera vuelta a mano
- Año 1
- $0 × 1.07 + $2,400 = $2,400. Año 2: $2,400 × 1.07 + $2,400 = $4,968.
Ejemplo resuelto: prueba tres tasas a la vez
Quieres el saldo a 30 años al 4%, al 7% y al 10% sin correr el código tres veces. Estos son los datos:
- Ahorras: $2,400 al año durante 30 años.
- Las tasas: 4%, 7% y 10%, guardadas en una lista: [0.04, 0.07, 0.10].
- La herramienta: un bucle dentro de otro bucle.
for rate in [0.04, 0.07, 0.10]:
balance = 0
for year in range(30):
balance = balance * (1 + rate) + 2400
print(rate, round(balance))0.04 134604
0.07 226706
0.1 394786- Bucle de afuera. Corre 3 veces, una por cada tasa.
- Reinicia. balance = 0 está dentro del bucle de afuera, así que cada tasa empieza desde cero.
- Bucle de adentro. 30 vueltas, con la misma regla de ahorro de antes.
- La respuesta. $134,604, $226,706 y $394,786. Pasar del 4% al 10% casi triplica tu dinero. Por eso importan tanto las comisiones bajas y una buena mezcla de inversiones.
Un girasol corre una línea de código.
Mira de cerca el centro de un girasol y verás espirales. La planta sigue una sola regla: cada semilla nueva crece unos 137.5° más allá de la anterior, un poco más afuera. Repetida cientos de veces, esa regla acomoda las semillas casi sin huecos.
Qué estás viendo: un dibujo hecho con la regla del propio girasol. Cada una de las 239 semillas se puso a 137.5° de la anterior, un poco más lejos del centro.
Por qué se te queda. El girasol no planea cada semilla; repite un paso. El código funciona igual: escribes una regla con cuidado, y un bucle la aplica 30 veces, o 30 millones.
La página que copiarías.
- Variable: price = 40 guarda 40. print() muestra un resultado.
- Lista: months = [20, 25, 30]. sum = 75, len = 3, promedio 753 = 25.0.
- Bucle for: repite las líneas con sangría. range(3) = 0, 1, 2. $1,000 al 10% por 3 años = 1331.
- $2,400 al año durante 30 años: $72,000 al 0%, $226,706 al 7%, $394,786 al 10%.
- Función: def le pone nombre, return responde. profit(20) = 300.
- if / else: corre una línea solo si la prueba es verdadera. VPN $1,372 > 0: "Build it".
- DataFrame de pandas: una tabla en código. Excel llega a 1,048,576 filas; pandas no tiene ese límite.
- Siempre revisa a mano la primera vuelta de un bucle.
Completa los espacios
Busca a alguien o a tu grupo de estudio.
Sean la computadora
Una persona lee en voz alta un bucle corto. Las demás siguen las variables en papel, vuelta por vuelta, y dicen qué imprime.
Pruébenlo de verdad
Abran un cuaderno gratis como Google Colab, escriban el bucle de ahorro y cambien la tasa y los años. ¿Quién llega primero a $1 millón, y cómo?
¿Hoja de cálculo o código?
Hagan una lista de cinco tareas de finanzas, como un presupuesto o revisar todas las operaciones del año pasado. Decidan qué herramienta conviene para cada una, y por qué.
Solo tú y tu dinero.
Esto se queda en este dispositivo. Nadie más lo ve.
Preguntas tipo examen.
Escritas como las haría un examen universitario. Cada respuesta correcta al primer intento vale 10 xp.
En el trabajo: haces análisis en una firma de gestión patrimonial
Una persona cliente de 25 años puede invertir $500 al mes, o $6,000 al año, hasta los 65. Pregunta cuánto podría tener. Tu gerente quiere tres casos. Esta es la situación:
- Años: 40.
- Casos: 5% (prudente), 7% (medio), 9% (fuerte).
- Regla: cada año el saldo crece y luego se suman los $6,000 del año.
Tu tarea: escribe el código, da los tres resultados y agrega una frase para la persona cliente.
Ver una respuesta modelo
for rate in [0.05, 0.07, 0.09]:
balance = 0
for year in range(40):
balance = balance * (1 + rate) + 6000
print(rate, round(balance))0.05 724799
0.07 1197811
0.09 2027295Para la persona cliente: vas a poner $240,000 de tu bolsillo (40 × $6,000). Según los rendimientos, podría crecer a unos $725,000, $1.2 millones o $2 millones. Empezar a los 25 es tu mayor ventaja: la mayor parte de ese dinero es crecimiento, no ahorro.
Hacia dónde va.
Qué estás viendo: un mapa de dónde encaja esta lección en el curso. Léelo de izquierda a derecha: las lecciones en las que se basa, esta lección en el centro y hacia dónde va.
- Antes · Unidad 17Hojas de cálculo para finanzas
- Antes · Unidad 10Porcentajes y crecimiento
- Antes · Unidad 10El valor del dinero en el tiempo
- Estás aquíPython para finanzas
- Muy pronto · Unidad 17SQL para finanzas