Lección 2.1 · Series y DataFrame

modulo-2Python · Python intermedio
Explorador
▸ modulo-1 · comprensiones-lambda-y-modulos
▾ modulo-2
series-y-dataframe.py
leer-y-escribir-archivos.py
inspeccionar.py
evaluacion-2
▸ modulo-3 · elegir-filtrar-y-modificar-datos
# módulo 2 de 10

Series, DataFrame, archivos e inspección

Las piezas de pandas: leer una tabla y conocerla antes de calcular.

Series y DataFrame2.1 · Las dos piezas de pandas: una columna con etiquetas y una tabla completa.
Leer y escribir archivos2.2 · De un archivo a un DataFrame en una línea, y de vuelta.
Inspeccionar2.3 · Conocer la tabla antes de sacar conclusiones.
Módulo 2
1 / 24
series-y-dataframe.pyPython · 2.1
1 2 3 4 5 6 7
# Python intermedio · módulo 2 · Series, DataFrame, archivos e inspección

Series y DataFrame

Las dos piezas de pandas: una columna con etiquetas y una tabla completa.

# Crear Series y DataFrames de pandas a partir de listas y diccionarios, y conocer su forma: columnas, índice, tamaño, primeras y últimas filas.
Lección 2.1
16 láminas · ejemplo resuelto · 8 ejercicios · 5 preguntas · tarea
Series y DataFrame
2 / 24
Lo que dice la voz

Te damos la bienvenida al módulo dos. La bodega de Santiago anotó su inventario en tres listas, productos, unidades y precios, y quiere verlo como una tabla. ¿Cómo lo habrías hecho en el curso básico? Recorrías las filas con un for, convertías cada dato y acumulabas en un diccionario. ¿Funciona? Sí. Pero es mucho código para una pregunta simple, ¿no? Desde hoy trabajas con pandas, la biblioteca de Python hecha para analizar tablas. Te voy a mostrar sus dos piezas básicas: la Series, que es una columna de datos con etiquetas, y el DataFrame, que es una tabla completa. En la próxima lección leerás el archivo de ventas de la tienda, y en la siguiente aprenderás a revisarlo antes de calcular.

que-es-pandas.mdPython · 2.1

Qué es pandas

1Una biblioteca externa: no viene con Python, se instala con pip
2En el navegador del curso ya está instalada
3Lee tablas desde archivos CSV y JSON
4Calcula sobre columnas enteras, sin escribir un for
Qué es pandas
3 / 24
Lo que dice la voz

¿Qué es pandas? Una biblioteca externa. No viene con Python, se instala aparte con pip, como viste en el módulo uno. ¿Y aquí tienes que instalarla? No. En el navegador del curso ya está, así que solo la importas. ¿Para qué sirve? Para leer tablas desde archivos CSV y JSON, y para calcular sobre columnas enteras sin escribir un for. Más adelante la vas a usar para filtrar, agrupar, combinar tablas y preparar gráficos. Es una de las herramientas más usadas en análisis de datos con Python.

import-pandas-as-pd.pyPython · 2.1
1import pandas as pd
2
3print(pd.__version__)
Salida
3.0.2
import pandas as pd
4 / 24
Lo que dice la voz

Todo programa con pandas empieza igual: importa pandas con el apodo pd. ¿Te suena? Es el import con as del módulo uno. En vez de escribir pandas completo cada vez, escribes pd. ¿Es obligatorio? No, pero lo usa todo el mundo, en la documentación, en los foros y en el código que vas a encontrar. Yo te recomiendo usarlo siempre. ¿Y la segunda línea? Muestra la versión instalada: tres punto cero punto dos. La versión tres cambió varias cosas respecto de la dos, y a lo largo del curso te voy a avisar cuando un tutorial antiguo muestre algo que ya no funciona así.

la-series-datos-con-indice.pyPython · 2.1
1import pandas as pd
2
3unidades = pd.Series([12, 5, 30, 8])
4print(unidades)
Salida
0 12 1 5 2 30 3 8 dtype: int64
La Series: datos con índice
5 / 24
Lo que dice la voz

Mira lo que aparece al mostrar esta Series. ¿Cuántas columnas ves? Dos. La de la derecha son tus datos, las unidades vendidas en cuatro días. ¿Y la de la izquierda? Es el índice, las etiquetas de cada dato. Si no le das otras, pandas las numera desde cero, como las posiciones de una lista. Eso es una Series: una columna de datos donde cada dato lleva una etiqueta. Se crea con Series, con ese mayúscula, a partir de una lista. ¿Y esa última línea, dtype int sesenta y cuatro? Es el tipo de los datos. Int sesenta y cuatro es un número entero.

tus-propias-etiquetas-index.pyPython · 2.1
1import pandas as pd
2
3nombres = ["Resma de papel carta", "Archivador", "Teclado"]
4precios = pd.Series([4990, 6490, 24990], index=nombres)
5print(precios)
6print()
7print(precios["Teclado"])
Salida
Resma de papel carta 4990 Archivador 6490 Teclado 24990 dtype: int64 24990
Tus propias etiquetas: index
6 / 24
Lo que dice la voz

¿El índice tiene que ser un número? No. Con el argumento index le das una lista de etiquetas propias, en el mismo orden que los datos. Aquí, el nombre de cada producto. ¿A qué se parece ahora? A un diccionario del curso básico, porque cada precio tiene su nombre. Y se consulta igual, con la etiqueta entre corchetes. ¿Cuánto cuesta el teclado? Veinticuatro mil novecientos noventa. Un cuidado: la lista de etiquetas y la de datos tienen que tener el mismo largo. ¿Si no? Pandas se detiene con un ValueError que dice cuántos datos y cuántas etiquetas encontró.

desde-un-diccionario-y-sus-cuentas.pyPython · 2.1
1import pandas as pd
2
3stock = pd.Series({"Resma de papel carta": 120, "Archivador": 60, "Teclado": 35})
4print(stock)
5print()
6print("Productos:", len(stock))
7print("Total:", stock.sum())
8print("Mayor:", stock.max())
9print("Promedio:", stock.mean())
Salida
Resma de papel carta 120 Archivador 60 Teclado 35 dtype: int64 Productos: 3 Total: 215 Mayor: 120 Promedio: 71.66666666666667
Desde un diccionario, y sus cuentas
7 / 24
Lo que dice la voz

¿Y si ya tienes un diccionario? Series lo convierte directo. Las claves pasan a ser el índice, y los valores, los datos. ¿Cuántos datos hay? Eso lo cuenta len, igual que con una lista. Y la Series trae sus propios métodos para resumir: sum suma, max entrega el mayor, min el menor y mean el promedio. ¿Viste algún for? Ninguno. Pandas recorre los datos por dentro. ¿Te acuerdas de lo que costaba sumar el stock en el curso básico? Un acumulador y un ciclo. Aquí es una sola palabra.

predice.pyPython · 2.1
¿Qué crees que muestra? Piénsalo antes de seguir.
1import pandas as pd
2
3nombres = ["Resma de papel carta", "Archivador", "Teclado"]
4precios = pd.Series([4990, 6490, 24990], index=nombres)
5print(precios["Resma de papel carta"])
6try:
7 print(precios[0])
8except Exception as error:
9 print("Error:", repr(error))
Salida
?
Antes de seguir, predice
8 / 24
Lo que dice la voz

Un cambio de pandas tres que te conviene conocer desde ya. En esta Series las etiquetas son nombres. ¿Qué crees que pasa al pedir el cero entre corchetes, como la primera posición de una lista?

pedir-el-cero-a-una-series-con-nombres.pyPython · 2.1
1import pandas as pd
2
3nombres = ["Resma de papel carta", "Archivador", "Teclado"]
4precios = pd.Series([4990, 6490, 24990], index=nombres)
5print(precios["Resma de papel carta"])
6try:
7 print(precios[0])
8except Exception as error:
9 print("Error:", repr(error))
Salida
4990 Error: KeyError(0)
Pedir el cero a una Series con nombres
9 / 24
Lo que dice la voz

Pandas busca una etiqueta llamada cero, no la encuentra y se detiene con KeyError. ¿Y antes? En versiones anteriores eso entregaba el primer precio, y vas a ver tutoriales que todavía lo hacen. Aquí lo atrapé con try, del curso básico, para mostrar el error sin detener el programa. ¿Y cómo se pide un dato por su posición? Con iloc, que verás en el módulo tres.

cada-series-tiene-un-tipo.pyPython · 2.1
1import pandas as pd
2
3print(pd.Series(["Santiago", "Concepción", "Antofagasta"]))
4print(pd.Series([2.5, 12.8]))
5print(pd.Series([True, False]))
Salida
0 Santiago 1 Concepción 2 Antofagasta dtype: str 0 2.5 1 12.8 dtype: float64 0 True 1 False dtype: bool
Cada Series tiene un tipo
10 / 24
Lo que dice la voz

Cada Series tiene un tipo. ¿Quién lo elige? Pandas, mirando los datos. Los textos son str, el mismo nombre del curso básico. ¿Los números con decimales? Float sesenta y cuatro. ¿Y los verdaderos y falsos? Bool. Ojo con los tutoriales anteriores a pandas tres: ahí una columna de texto aparece con el tipo object. Desde la versión tres, el texto tiene su tipo propio, str. ¿Por qué importa tanto el tipo? Lo vas a ver en la lección tres de este módulo: un número guardado como texto no se suma como número.

el-dataframe-una-tabla.pyPython · 2.1
1import pandas as pd
2
3productos = pd.DataFrame({
4 "producto": ["Resma de papel carta", "Mouse inalámbrico", "Silla de escritorio", "Archivador"],
5 "categoria": ["Oficina", "Tecnología", "Hogar", "Oficina"],
6 "precio": [4990, 12990, 89990, 6490],
7})
8print(productos)
Salida
producto categoria precio 0 Resma de papel carta Oficina 4990 1 Mouse inalámbrico Tecnología 12990 2 Silla de escritorio Hogar 89990 3 Archivador Oficina 6490
El DataFrame: una tabla
11 / 24
Lo que dice la voz

La segunda pieza, y la que más vas a usar, es el DataFrame: una tabla con filas y columnas, como una hoja de planilla. ¿Cómo se crea? Lo más directo es con un diccionario. Cada clave es el nombre de una columna, y cada valor, la lista de datos de esa columna, de arriba hacia abajo. ¿Cuántas columnas hay aquí? Tres: producto, categoría y precio. A la izquierda aparece el índice, igual que en la Series, numerado desde cero. ¿Y las filas? Cada posición de las listas es una fila. La fila cero es la resma, de oficina, a cuatro mil novecientos noventa pesos.

todas-las-columnas-del-mismo-largo.pyPython · 2.1
1import pandas as pd
2
3productos = pd.DataFrame({
4 "producto": ["Resma de papel carta", "Mouse inalámbrico", "Archivador"],
5 "precio": [4990, 12990],
6})
Terminal
Traceback (most recent call last): File "<tu código>", line 3, in <module> productos = pd.DataFrame({ "producto": ["Resma de papel carta", "Mouse inalámbrico", "Archivador"], "precio": [4990, 12990], }) ValueError: All arrays must be of the same length
Todas las columnas del mismo largo
12 / 24
Lo que dice la voz

¿Qué pasa si a una columna le falta un dato? Pandas no adivina dónde va el hueco. Aquí hay tres productos y solo dos precios, y el programa se detiene con ValueError, All arrays must be of the same length: todas las listas deben tener el mismo largo. ¿Qué hago yo cuando veo ese mensaje? Cuento los elementos de cada lista. ¿Y qué encuentro casi siempre? Un dato olvidado, o dos textos sin la coma que los separa, que Python junta en uno solo.

columnas-e-indice.pyPython · 2.1
1import pandas as pd
2
3productos = pd.DataFrame({
4 "producto": ["Resma de papel carta", "Mouse inalámbrico", "Silla de escritorio", "Archivador"],
5 "categoria": ["Oficina", "Tecnología", "Hogar", "Oficina"],
6 "precio": [4990, 12990, 89990, 6490],
7})
8print(productos.columns)
9print(productos.columns.tolist())
10print(productos.index)
Salida
Index(['producto', 'categoria', 'precio'], dtype='str') ['producto', 'categoria', 'precio'] RangeIndex(start=0, stop=4, step=1)
Columnas e índice
13 / 24
Lo que dice la voz

Todo DataFrame tiene dos rótulos: los nombres de las columnas y el índice de las filas. Columns entrega los nombres, en el formato propio de pandas, Index, con el tipo str porque son textos. ¿Y si prefieres una lista común? Agrega tolist. Index entrega el índice de las filas: un RangeIndex que parte en cero y termina antes del cuatro, igual que range. ¿Viste que columns e index van sin paréntesis? Son datos que el DataFrame ya tiene, y se llaman atributos. ¿Para qué sirven? Cuando recibes una tabla ajena, columns te dice el nombre exacto de cada columna. Aquí categoría va sin tilde, y si la pides con tilde, pandas no la encuentra.

cada-columna-es-una-series.pyPython · 2.1
1import pandas as pd
2
3productos = pd.DataFrame({
4 "producto": ["Resma de papel carta", "Mouse inalámbrico", "Silla de escritorio", "Archivador"],
5 "precio": [4990, 12990, 89990, 6490],
6})
7print(productos["precio"])
8print()
9print("Más alto:", productos["precio"].max())
Salida
0 4990 1 12990 2 89990 3 6490 Name: precio, dtype: int64 Más alto: 89990
Cada columna es una Series
14 / 24
Lo que dice la voz

Con el nombre de una columna entre corchetes, el DataFrame te entrega esa columna. ¿Y qué es lo que entrega? Una Series. Mírala: tiene su índice, sus datos, su tipo y, al final, su nombre, precio. Entonces, ¿sirve todo lo que viste de las Series? Sí, para cada columna. Aquí max entrega el precio más alto. Un DataFrame es, en el fondo, un grupo de Series que comparten el mismo índice. ¿Y elegir varias columnas a la vez, o algunas filas? Eso lo verás a fondo en el módulo tres.

predice.pyPython · 2.1
¿Qué crees que muestra? Piénsalo antes de seguir.
1import pandas as pd
2
3productos = pd.DataFrame({
4 "producto": ["Resma de papel carta", "Mouse inalámbrico", "Silla de escritorio", "Archivador"],
5 "categoria": ["Oficina", "Tecnología", "Hogar", "Oficina"],
6 "precio": [4990, 12990, 89990, 6490],
7})
8print(productos.shape)
9filas, columnas = productos.shape
10print("Filas:", filas, "Columnas:", columnas)
11print(len(productos))
12print(list(productos))
Salida
?
Antes de seguir, predice
15 / 24
Lo que dice la voz

Shape, también sin paréntesis, entrega el tamaño de la tabla, y len, aplicado a un DataFrame, cuenta las filas. La última línea convierte el DataFrame en una lista. ¿Qué crees que trae esa lista?

el-tamano-shape-y-len.pyPython · 2.1
1import pandas as pd
2
3productos = pd.DataFrame({
4 "producto": ["Resma de papel carta", "Mouse inalámbrico", "Silla de escritorio", "Archivador"],
5 "categoria": ["Oficina", "Tecnología", "Hogar", "Oficina"],
6 "precio": [4990, 12990, 89990, 6490],
7})
8print(productos.shape)
9filas, columnas = productos.shape
10print("Filas:", filas, "Columnas:", columnas)
11print(len(productos))
12print(list(productos))
Salida
(4, 3) Filas: 4 Columnas: 3 4 ['producto', 'categoria', 'precio']
El tamaño: shape y len
16 / 24
Lo que dice la voz

Los nombres de las columnas, no las filas. Y lo mismo pasa si lo recorres con un for. ¿Por qué? Porque un DataFrame se parece más a un diccionario de columnas que a una lista de filas. ¿Y shape? Entrega una tupla: primero las filas y después las columnas, cuatro y tres. Como es una tupla, la puedes desempaquetar en dos variables, como en el curso básico.

las-primeras-y-las-ultimas-filas-head-y-.pyPython · 2.1
1import pandas as pd
2
3ventas = pd.DataFrame({
4 "fecha": ["2026-09-01", "2026-09-02", "2026-09-03", "2026-09-04",
5 "2026-09-05", "2026-09-07", "2026-09-08", "2026-09-09"],
6 "unidades": [14, 9, 22, 7, 11, 5, 18, 12],
7})
8print(ventas.head(3))
9print()
10print(ventas.tail(2))
Salida
fecha unidades 0 2026-09-01 14 1 2026-09-02 9 2 2026-09-03 22 fecha unidades 6 2026-09-08 18 7 2026-09-09 12
Las primeras y las últimas filas: head y tail
17 / 24
Lo que dice la voz

Una tabla real tiene cientos o miles de filas. ¿Sirve de algo mostrarla entera? No mucho. Head entrega las primeras filas y tail las últimas. Entre paréntesis va cuántas quieres. ¿Y si no pones nada? Son cinco. Aquí head muestra las tres primeras ventas de septiembre, y tail, las dos últimas. Ahora fíjate en el índice de tail. ¿Por qué dice seis y siete, y no cero y uno? Porque cada fila conserva su etiqueta de la tabla original. Yo hago esto con cada archivo, antes que nada: mirar cómo empieza y cómo termina.

un-indice-con-etiquetas.pyPython · 2.1
1import pandas as pd
2
3sucursales = pd.DataFrame(
4 {"comuna": ["Providencia", "Concepción", "Antofagasta"], "metros2": [180, 120, 95]},
5 index=["Santiago", "Concepción", "Antofagasta"],
6)
7print(sucursales)
8print(sucursales.index.tolist())
Salida
comuna metros2 Santiago Providencia 180 Concepción Concepción 120 Antofagasta Antofagasta 95 ['Santiago', 'Concepción', 'Antofagasta']
Un índice con etiquetas
18 / 24
Lo que dice la voz

¿El DataFrame también acepta index? Sí, igual que la Series. Aquí cada fila lleva el nombre de su sucursal en vez de un número, y la tabla se lee mejor. ¿Vas a usar esto seguido? Al comienzo, poco. Casi siempre vas a trabajar con el índice numerado que pandas pone solo, porque tus datos van a venir de archivos. Pero cuando agrupes datos, en el módulo siete, pandas pondrá él mismo etiquetas como estas en el índice, y te va a servir haberlas visto aquí.

resumen.mdPython · 2.1

Lo que te llevas de esta lección

import pandas as pd; en pandas 3.0 el texto es del tipo str
Series: datos con índice; desde una lista o un diccionario, con sum, max, min y mean
DataFrame: una tabla desde un diccionario de listas del mismo largo; cada columna es una Series
columns, index y shape van sin paréntesis; len cuenta filas; head y tail muestran los extremos
Ahora te toca
1Ejemplo resueltoEl inventario de la bodega
8EjerciciosSe corrigen al instante
5PreguntasComprueba lo que aprendiste
1TareaEl catálogo en una tabla
Siguiente2.2 Leer y escribir archivos
Lo que te llevas de esta lección
19 / 24
Lo que dice la voz

Repasemos. Pandas se importa con el apodo pd. ¿Qué es una Series? Una columna de datos con índice. Se crea desde una lista o un diccionario, y se resume con sum, max, min y mean. ¿Y un DataFrame? Una tabla que se crea desde un diccionario de listas del mismo largo, y cada una de sus columnas es una Series. Columns, index y shape describen la tabla y van sin paréntesis. Len cuenta las filas, y head y tail muestran el comienzo y el final. En la práctica vas a armar tus primeras tablas. ¿Y de dónde salen las tablas de verdad? De archivos, y eso viene en la próxima lección.

ejemplo.mdPython · 2.1

El inventario de la bodega

La bodega de Santiago anotó su inventario en tres listas: productos, unidades y precios. Lo convertimos en una tabla de pandas y la revisamos.

El inventario de la bodega
20 / 24
ejemplo-paso-1.pyPython · 2.1
Paso 1 de 4 · Primero, las unidades en una Series, con el nombre de cada producto como índice.
1import pandas as pd
2
3nombres = ["Resma de papel carta", "Archivador", "Teclado", "Cuaderno universitario", "Mouse inalámbrico"]
4unidades = [120, 60, 35, 200, 18]
5
6stock = pd.Series(unidades, index=nombres)
7print(stock)
Salida
Resma de papel carta 120 Archivador 60 Teclado 35 Cuaderno universitario 200 Mouse inalámbrico 18 dtype: int64
Ejemplo resuelto · El inventario de la bodega
21 / 24
ejemplo-paso-2.pyPython · 2.1
Paso 2 de 4 · Ahora la tabla completa, con un diccionario de tres columnas. Un error típico: la lista de precios quedó con un dato menos.
1import pandas as pd
2
3nombres = ["Resma de papel carta", "Archivador", "Teclado", "Cuaderno universitario", "Mouse inalámbrico"]
4unidades = [120, 60, 35, 200, 18]
5precios = [4990, 6490, 24990, 2490]
6
7bodega = pd.DataFrame({"producto": nombres, "unidades": unidades, "precio": precios})
Terminal
Traceback (most recent call last): File "<tu código>", line 7, in <module> bodega = pd.DataFrame({"producto": nombres, "unidades": unidades, "precio": precios}) ValueError: All arrays must be of the same length
Ejemplo resuelto · El inventario de la bodega
22 / 24
ejemplo-paso-3.pyPython · 2.1
Paso 3 de 4 · Con el precio del mouse que faltaba, la tabla se crea. Revisamos su tamaño y sus primeras filas.
1import pandas as pd
2
3nombres = ["Resma de papel carta", "Archivador", "Teclado", "Cuaderno universitario", "Mouse inalámbrico"]
4unidades = [120, 60, 35, 200, 18]
5precios = [4990, 6490, 24990, 2490, 12990]
6
7bodega = pd.DataFrame({"producto": nombres, "unidades": unidades, "precio": precios})
8print(bodega.shape)
9print(bodega.head(3))
Salida
(5, 3) producto unidades precio 0 Resma de papel carta 120 4990 1 Archivador 60 6490 2 Teclado 35 24990
Ejemplo resuelto · El inventario de la bodega
23 / 24
ejemplo-paso-4.pyPython · 2.1
Paso 4 de 4 · Para cerrar, dos preguntas de la jefatura, columna por columna: cuántas unidades hay en total y cuál es el precio más alto.
1import pandas as pd
2
3nombres = ["Resma de papel carta", "Archivador", "Teclado", "Cuaderno universitario", "Mouse inalámbrico"]
4unidades = [120, 60, 35, 200, 18]
5precios = [4990, 6490, 24990, 2490, 12990]
6
7bodega = pd.DataFrame({"producto": nombres, "unidades": unidades, "precio": precios})
8print("Unidades en bodega:", bodega["unidades"].sum())
9print("Precio más alto:", bodega["precio"].max())
Salida
Unidades en bodega: 433 Precio más alto: 24990
Ejemplo resuelto · El inventario de la bodega
24 / 24