Código Python: leer una serie de precios y describirla (descarga gratis)

Código Python: leer una serie de precios y describirla (descarga gratis)

Una serie de precios es una lista de números con fecha: lo que costó algo cada día. Leerla bien, saber cuánto cambió, cuánto se movió y qué forma tiene, es la primera tarea de quien mira mercados, y también la de un dueño de negocio que quiere comparar los precios de su producto con los de meses anteriores. Este programa de Python hace justamente eso: abre un archivo con dos columnas, calcula el resumen de la serie y la dibuja en la consola con caracteres, sin gráficos de ventana y sin librerías de terceros. Está escrito para gente que no programa: se ejecuta con un comando y no hay que instalar absolutamente nada más.

Aviso: este programa es material educativo. No es una recomendación de compra ni de venta. Los precios de ejemplo que viajan dentro del ZIP son inventados y los datos históricos se citan solo para practicar. Un resultado pasado no garantiza nada en el futuro. Consulta a un profesional autorizado antes de invertir.

Qué trae el ZIP

Fuente de los datos históricos: CoinGecko (api.coingecko.com) para el bitcoin y la Reserva Federal de St. Louis, serie SP500, para el índice (https://fred.stlouisfed.org/series/SP500). Las dos series se descargaron el 25 de septiembre de 2026 y se usan únicamente como datos de práctica. Si prefieres trabajar con tus propios números, reemplaza el archivo de la carpeta datos/ por tu propio CSV: el formato está explicado en la tabla de más abajo y no hay que tocar ni una línea del programa.

Qué hace el programa

1. Lee datos/precios.csv, la serie de ejemplo inventada, con 180 cierres diarios.
2. Calcula el retorno diario de cada día: cuánto cambió el cierre frente al día anterior, en porcentaje.
3. Resume la serie: número de datos, fecha inicial y final, cierre mínimo y máximo, primer y último cierre, variación total, variación media diaria y volatilidad.
4. Comprueba su propia aritmética: que el último cierre sea el de la última fila del archivo y que la variación total, calculada de dos maneras distintas, coincida.
5. Repite el mismo resumen con datos/precios_reales.csv, esta vez agrupando por activo: una fila por activo.
6. Dibuja la serie de ejemplo en la consola como sesenta columnas hechas de bloques, con una leyenda que señala el mínimo y el máximo.
7. Guarda el resumen completo en salida/resumen_series.csv, listo para abrir en Excel.
8. Imprime el aviso legal al empezar y al terminar.

Cómo ejecutarlo

Necesitas Python 3.11 o superior. En Windows se instala desde python.org y conviene marcar la casilla que agrega Python al PATH. Después descomprime el ZIP en una carpeta cualquiera, abre la terminal en esa carpeta y escribe el comando de abajo. En Windows puedes abrir la terminal con el botón derecho del ratón sobre la carpeta y la opción de abrir la terminal ahí mismo.

python serie_precios.py

No hay que instalar nada más: el programa usa solo la biblioteca estándar. Tampoco hace falta una conexión a internet, porque los dos archivos de precios viajan dentro del ZIP. Si la consola de Windows no sabe dibujar los bloques del gráfico, el propio programa cambia la salida a UTF-8 en vez de reventar, y lo mismo da que lo ejecutes en Windows, en Linux o en un Mac.

El formato del archivo de datos

El archivo de la serie real agrega una columna más, activo, con el nombre del activo, para que el programa sepa dónde empieza y dónde termina cada serie. Las cabeceras van en la primera línea y cada fila es un día. Si tu archivo trae más de cien días, mejor: la volatilidad y el gráfico se leen con más calma. Lo único que hay que respetar es el orden de las columnas y el punto decimal en el archivo; el programa se encarga del resto.

El código, explicado

El programa tiene menos de doscientas cincuenta líneas y está comentado en español. Estos son los cinco fragmentos que conviene entender, copiados literalmente del archivo del ZIP.

Las herramientas y las rutas

Los cuatro import son toda la caja de herramientas: csv para leer el archivo, sys para saber cómo dibuja la consola, Decimal para que los precios y los porcentajes no arrastren errores de redondeo, y pathlib para armar rutas que funcionan igual en Windows, Linux y Mac. La variable BASE es la carpeta del propio programa, así que el programa corre desde cualquier sitio: no depende de dónde estés parado cuando lo llamas.

import csv                                        # csv: leer el archivo de precios sin instalar nada
import sys                                        # sys: saber con qué juego de caracteres dibuja la consola
from decimal import Decimal, ROUND_HALF_UP        # Decimal: precios y porcentajes exactos, sin sorpresas binarias
from pathlib import Path                          # pathlib: rutas que funcionan en Windows, Linux y Mac

# La carpeta de este mismo archivo: así el programa corre desde cualquier sitio
BASE = Path(__file__).resolve().parent
ENTRADA = BASE / "datos" / "precios.csv"      # serie de ejemplo inventada, que viaja dentro del ZIP
ENTRADA_REAL = BASE / "datos" / "precios_reales.csv"    # serie histórica citada solo para practicar (dos activos)
SALIDA = BASE / "salida" / "resumen_series.csv"   # resumen de las series, listo para abrir en Excel

El retorno diario: la materia prima

El retorno de un día es cuánto cambió el cierre frente al día anterior, en porcentaje. La función recorre los cierres con un índice y divide cada uno entre el anterior; el menos uno deja el cambio en forma de porcentaje limpio. Con esa lista ya se puede medir la variación media y, sobre todo, la volatilidad. La función devuelve un diccionario con las fechas, los extremos, el primer cierre, el último y los tres porcentajes del resumen.

def estadisticas(filas: list[dict]) -> dict:
    """Calcula el resumen de la serie: fechas, extremos, variación y volatilidad."""
    fechas = [fila["fecha"] for fila in filas]
    cierres = [Decimal(fila["cierre"]) for fila in filas]
    # Retorno diario (%): cuánto cambió el cierre de un día al siguiente
    retornos = [(cierres[i] / cierres[i - 1] - 1) * CIEN for i in range(1, len(cierres))]

La volatilidad: una desviación estándar

La volatilidad no es más que la desviación estándar de esos retornos: un solo número que resume cuánto se alejan los cambios diarios de su promedio. Si el precio se mueve poco, la desviación es pequeña; si da saltos, crece. Se usa la fórmula poblacional, que divide entre el número de retornos y no entre el número menos uno, y de ahí sale la raíz cuadrada. Comparar esta cifra entre dos series dice bastante más que mirar los precios sueltos.

def desviacion(valores: list[Decimal]) -> Decimal:
    """Desviación estándar poblacional de una lista de números."""
    media = sum(valores) / len(valores)
    # Poblacional: la varianza divide entre el número de retornos, no entre n-1
    varianza = sum((valor - media) ** 2 for valor in valores) / len(valores)
    return varianza.sqrt()

El gráfico de la consola: un nivel por carácter

Como la terminal no tiene ventanas, el gráfico se dibuja con caracteres. La función nivel traduce un cierre a un número del cero al siete, que es la posición del carácter dentro de la escalera de bloques; el valor se escala entre el mínimo y el máximo de la serie. Después, la función dibujar promedia varios días en cada una de las sesenta columnas y escribe la línea. Así se ve la forma de la serie de un vistazo, sin abrir una hoja de cálculo.

def nivel(valor: Decimal, minimo: Decimal, maximo: Decimal) -> int:
    """Traduce un cierre a un nivel de 0 a 7: el índice del carácter del gráfico."""
    if maximo == minimo:
        return 0
    posicion = (valor - minimo) / (maximo - minimo)
    indice = (posicion * (len(ESCALONES) - 1)).quantize(Decimal("1"), rounding=ROUND_HALF_UP)
    return max(0, min(len(ESCALONES) - 1, int(indice)))

Las comprobaciones: no fiarse de uno mismo

El programa calcula el último cierre de dos maneras y la variación total también de dos maneras, y compara. Cuando las dos cuentas coinciden imprime que cuadra. Es una costumbre sana: cuando un número se repite por dos caminos distintos, uno se fía mucho más de él que de un resultado suelto. En la práctica, esto es lo que separa un resumen utilizable de una cifra inventada.

def comprobar(filas: list[dict], datos: dict) -> None:
    """Imprime las dos comprobaciones de la serie."""
    # Comprobación 1: el último cierre es el de la última fila del archivo
    cuadra1 = Decimal(filas[-1]["cierre"]) == datos["ultimo"]
    # Comprobación 2: la variación total, calculada de otra forma, debe dar lo mismo
    directa = (datos["ultimo"] / datos["primero"] - 1) * CIEN
    cuadra2 = redondear(directa * 10000) == redondear(datos["var_total"] * 10000)

Qué vas a ver en pantalla

Al ejecutarlo, lo primero que aparece es el aviso legal; después, la tabla de la serie de ejemplo con su resumen: 180 datos, el primer y el último día del archivo y las tres cifras de siempre. Abajo vienen las dos comprobaciones. En la serie real, la tabla se imprime una fila por activo. Esto es el trozo de la salida real, copiado tal cual:

SERIE DE EJEMPLO
---------------------------------------------------------------------------------------------------------------------------------------------------
Serie                    Datos       Inicio         Fin       Mínimo       Máximo      Primero       Último      Var. % Var. media %  Volatilidad %
---------------------------------------------------------------------------------------------------------------------------------------------------
Ejemplo                  180     2026-01-02  2026-06-30        92,25       123,61        99,94       117,24     17,31 %       0,10 %         1,23 %
---------------------------------------------------------------------------------------------------------------------------------------------------
    Comprobación: último cierre = última fila del archivo: CUADRA
    Comprobación: variación total = (último/primero - 1) × 100: CUADRA
DATOS REALES
  Fuente de los datos reales: CoinGecko, api.coingecko.com y Reserva Federal de St. Louis (serie SP500), descargados el 2026-09-25
RESUMEN POR ACTIVO
---------------------------------------------------------------------------------------------------------------------------------------------------
Serie                    Datos       Inicio         Fin       Mínimo       Máximo      Primero       Último      Var. % Var. media %  Volatilidad %
---------------------------------------------------------------------------------------------------------------------------------------------------
Bitcoin (USD)            120     2026-05-30  2026-09-25    58.566,09    86.596,74    73.500,92    83.706,64     13,89 %       0,13 %         2,16 %
S&P 500 (índice)         120     2026-04-06  2026-09-24     6.611,83     7.798,99     6.611,83     7.704,13     16,52 %       0,13 %         0,79 %
---------------------------------------------------------------------------------------------------------------------------------------------------

Y al final llega el momento didáctico: el gráfico. Cada carácter es el promedio de tres días consecutivos, y la escalera de bloques va del nivel más bajo al más alto. Leyendo de izquierda a derecha se ve la forma de los seis meses: sube, corrige, se aplana y vuelve a subir, con el mínimo marcado cerca de la mitad del período. Un gráfico hecho con caracteres no predice nada, pero ordena la mirada mejor que una lista de números.

GRÁFICO DE LA SERIE DE EJEMPLO (60 columnas)
---------------------------------------------------------------------------------------------------------------------------------------------------
  ▃▃▃▄▄▄▃▃▄▄▄▅▅▅▅▅▅▅▅▆▅▄▄▃▃▂▂▂▂▂▂▁▁▁▂▂▃▃▃▃▃▄▄▅▆▆▇▇▇▇▇█▇▇▇▇▇▇▆▇
---------------------------------------------------------------------------------------------------------------------------------------------------
Leyenda: ▁ mínimo 92,25 (2026-04-08) | █ máximo 123,61 (2026-06-04)

Errores comunes y consejos

• Si la terminal contesta que python no es un programa reconocido, prueba con el nombre python3, que es el que usan Linux y algunos Mac.
• Ejecuta el programa desde la carpeta donde descomprimiste el ZIP, o pásale la ruta completa del archivo. Si lo mueves de sitio, la carpeta datos/ se tiene que mover con él.
• Si cambias el archivo de precios, respeta las cabeceras y los nombres de las columnas. Una coma de más en una fila desordena el análisis sin dar ningún aviso.
• Cuida el punto decimal en el archivo de datos: el programa lee el punto, no la coma, incluso cuando después imprime los números con el formato local.
• Una serie de pocos días da una volatilidad poco fiable. Con meno de veinte cierres, el resumen sirve para practicar, no para sacar conclusiones.
• Si un día falta en el archivo, el salto se cuenta como un solo retorno. Los huecos no se rellenan solos.

Cuándo esto no alcanza

Este programa es un buen ejercicio y sirve para una serie, o para dos. Cuando el inventario de una pyme entra en juego, la cosa cambia: llegan las compras, las ventas, los saldos por bodega, los costos y el rastro que hay que dejar para poder revisar un movimiento meses después. Ahí es donde Kardex Tauro empieza a tener sentido, porque lleva el inventario y el costo de verdad y guarda el historial. Si tu problema es un solo archivo de precios, quédate con el script; cuando los movimientos se multiplican y hay que cuadrar con contabilidad, el script se queda corto.

Aviso: este artículo y el programa son material educativo. No es una recomendación de compra ni de venta. La fuente de los datos está citada arriba y el ZIP trae el descargo legal por escrito, junto con las instrucciones. Los precios de ejemplo son inventados y los históricos se citan solo para practicar: un resultado pasado no garantiza nada en el futuro, así que consulta a un profesional autorizado antes de invertir.

Descarga el ZIP, ejecuta el programa con una sola línea de comandos y mira tu primera serie de precios descrita con números y con caracteres. Después cambia el archivo por tus propios precios y compara: el mismo ejercicio, con datos que te importan.