Última actualización: 2026-11-11

Contenido de esta página

• ¿Qué es pandas en Python y para qué sirve?
• Series y DataFrame: las dos estructuras de datos de pandas
• Cómo seleccionar datos en pandas: loc frente a iloc
• Cómo filtrar filas en pandas: máscaras booleanas y query
• Agrupar, unir y reorganizar tablas: qué herramienta usar
• Fechas y texto en pandas: los accesores dt y str
• ¿Qué hacer cuando el DataFrame no cabe en memoria?
• Lo que pandas hace y lo que va en otras guías
• Lo que sigue diciendo un artículo de 2010

En 2010, Wes McKinney llevó a la conferencia científica de Python, SciPy, un artículo que, en sus primeras páginas, plantea un problema pequeño y muy concreto [1]. El ejemplo: el precio y el volumen negociado de dos acciones, Google y Apple, durante cuatro días de diciembre de 2009. ¿Cómo guardar esa tabla en Python y trabajar con ella? [1].

La herramienta a mano era NumPy, la librería de Python para calcular con arreglos de números. En concreto, un arreglo estructurado: una especie de tabla con nombres de campo. McKinney reconoce que sirve en muchas aplicaciones. Pero escribe que, en su experiencia, no ofrecía la flexibilidad ni la facilidad de uso de otros entornos estadísticos [1]. El de referencia era R, un lenguaje para estadística, cuyo data.frame también guarda datos de tipos mezclados [1].

La respuesta que presenta el artículo es una clase (un molde de código para crear objetos) con un nombre casi igual, DataFrame. Según el artículo, implementa buena parte de lo que hace su par de R, con algunas mejoras importantes, sobre todo la alineación de datos incorporada [1].

Y el nombre de la librería tiene historia económica. Los datos de panel son las mismas personas o empresas observadas en varios momentos: la misma lista de firmas, año tras año [1]. Se usan mucho en econometría, la rama que mide relaciones económicas con estadística. McKinney lo dejó escrito así: «El nombre del paquete viene de panel data, un término para conjuntos de datos de tres dimensiones que se encuentran en estadística y econometría» [1].

De ahí salió el nombre de pandas, la librería con la que Python aprendió a trabajar con tablas.

¿Qué es pandas en Python y para qué sirve?

Pandas es una librería gratuita de Python, es decir, un paquete de código ya escrito, para trabajar con datos en forma de tabla. Su documentación dice que ofrece estructuras de datos rápidas y flexibles para datos «relacionales» o «etiquetados» [2]. Etiquetados quiere decir que cada fila y cada columna tienen un nombre, y que se puede llamar a los datos por ese nombre.

Sirve para el trabajo de todos los días con datos. La misma documentación enumera, entre otras cosas, lo que pandas hace bien [2]:

1. Alinear datos de forma automática según sus etiquetas.
2. Agrupar filas para resumirlas o transformarlas.
3. Unir tablas entre sí, como se hace en una base de datos.
4. Cambiar la forma de una tabla, de larga a ancha y al revés.
5. Trabajar con series de tiempo: rangos de fechas, cambios de frecuencia y ventanas móviles.

Es software libre: se distribuye con una licencia BSD (un tipo de licencia libre) de 3 cláusulas, que permite usarlo y redistribuirlo [2]. Estas son las versiones con las que se escribió esta página:

Pieza	Versión
pandas, la más reciente en el índice oficial de paquetes de Python (publicada el 4 de noviembre de 2026)	3.1.1 [3]
Python mínimo que pide esa versión de pandas	3.11 [3]
Python con el que ejecuté todos los ejemplos	3.13.13
NumPy con el que ejecuté todos los ejemplos	2.5.4
Sistema operativo del equipo	Windows 11

Por costumbre, pandas se importa con el nombre corto pd [4]. Si todavía no tiene dónde correr código, la guía de Python para el análisis de datos arma el kit. Un cuaderno de Jupyter Notebook es el lugar más cómodo para pegar cada bloque de esta página y ver su resultado debajo.

Series y DataFrame: las dos estructuras de datos de pandas

Pandas tiene dos estructuras principales. La Series es una columna con etiquetas: una lista de valores de una dimensión, cada uno con su nombre [4]. El DataFrame es una tabla de dos dimensiones, con filas y columnas [4].

La relación entre las dos es sencilla. La documentación dice que el DataFrame es un contenedor de Series, y la Series, un contenedor de valores sueltos [2]. Cada columna de una tabla es, por dentro, una Series.

La diferencia con el array de NumPy depende del dtype, el tipo de dato: entero, decimal, texto o fecha. La guía oficial la resume en una frase: «los arrays de NumPy tienen un dtype para todo el array, mientras que los DataFrame de pandas tienen un dtype por columna» [4]. Si quiere entender primero cómo calcula ese array, empiece por la guía de NumPy.

El ejemplo de esta página usa datos inventados: diez préstamos de una red de tres bibliotecas públicas. De cada uno se anota la sede, el código del libro, la fecha y los días que duró.

import pandas as pd

# DATOS SINTÉTICOS: diez préstamos inventados de una red de tres bibliotecas
prestamos = pd.DataFrame({
    "id": ["P01", "P02", "P03", "P04", "P05", "P06", "P07", "P08", "P09", "P10"],
    "sede": ["Centro", "Norte", "Centro", "Sur", "Norte",
             "Centro", "Sur", "Norte", "Centro", "Sur"],
    "codigo": ["LIT-014", "HIS-002", "CIE-031", "LIT-007", "HIS-002",
               "CIE-031", "LIT-014", "LIT-007", "HIS-019", "CIE-031"],
    "prestado": pd.to_datetime(["2026-01-08", "2026-01-12", "2026-01-15",
                                "2026-01-20", "2026-01-27", "2026-02-03",
                                "2026-02-05", "2026-02-10", "2026-02-16",
                                "2026-02-24"]),
    "dias": [14, 7, 21, 10, 14, 5, 18, 12, 9, 15],   # días que duró el préstamo
})
prestamos = prestamos.set_index("id")   # el código del préstamo pasa a ser la etiqueta de fila

print(prestamos.head(3))
print(prestamos.dtypes)
print(type(prestamos["dias"]))           # cada columna es una Series

       sede   codigo   prestado  dias
id
P01  Centro  LIT-014 2026-01-08    14
P02   Norte  HIS-002 2026-01-12     7
P03  Centro  CIE-031 2026-01-15    21
sede                   str
codigo                 str
prestado    datetime64[us]
dias                 int64
dtype: object
<class 'pandas.Series'>

Tres cosas para mirar. La columna id dejó de ser columna y se volvió el índice: las etiquetas de las filas. Cada columna tiene su propio tipo: texto, fecha y entero en la misma tabla. Y el texto aparece como str, que desde pandas 3.0 es el tipo por defecto cuando pandas detecta una columna de textos [5].

La alineación por etiquetas: lo que más sorprende al empezar

Cuando pandas opera dos Series, no empareja los valores por su posición sino por su etiqueta. Es la alineación que McKinney destacaba en 2010 [1]. El resultado reúne todas las etiquetas de los dos lados, para que no se pierda información [1].

# Dos Series con etiquetas distintas: pandas suma por etiqueta, no por posición
enero = pd.Series({"Centro": 2, "Norte": 2, "Sur": 1})
febrero = pd.Series({"Sur": 2, "Centro": 2, "Oriente": 1})
print(enero + febrero)

Centro     4.0
Norte      NaN
Oriente    NaN
Sur        3.0
dtype: float64

Centro y Sur se sumaron bien, aunque estaban en orden distinto. Norte y Oriente aparecen solo en un lado, así que su resultado es NaN, la marca de pandas para un dato faltante [1]. Esa marca no es un error del programa: le avisa que una de las dos tablas no tenía ese dato. Qué hacer con los vacíos es tarea de la limpieza de datos, un tema aparte.

Cómo seleccionar datos en pandas: loc frente a iloc

Para seleccionar filas y columnas en código que se va a reutilizar, la guía oficial recomienda dos métodos: loc e iloc [4]. La diferencia está en cómo se señala lo que se quiere. Con loc se usan las etiquetas; con iloc, la posición, contada desde cero [6].

	loc	iloc
Qué recibe	Etiquetas: nombres de filas y columnas	Posiciones: números enteros desde 0
Un tramo como «P02»:«P04» o 1:4	Incluye el inicio y el final	Incluye el inicio y excluye el final, como en Python
Si lo pedido no existe	Error KeyError	Error IndexError, salvo en tramos que se pasan del final
También acepta	Una máscara de verdaderos y falsos	Una máscara de verdaderos y falsos

La tabla resume la guía de indexación de pandas [6]. La fila del tramo es la que más confunde. En loc, el tramo de etiquetas incluye las dos puntas, al contrario de lo usual en Python [6].

# loc: por etiqueta. El tramo "P02":"P04" INCLUYE las dos puntas
print(prestamos.loc["P02":"P04", ["sede", "dias"]])

# iloc: por posición, desde 0. El tramo 1:4 EXCLUYE la posición 4, como en Python
print(prestamos.iloc[1:4, [0, 3]])

# Un solo valor: fila P05, columna dias
print(prestamos.loc["P05", "dias"], prestamos.iloc[4, 3])

       sede  dias
id
P02   Norte     7
P03  Centro    21
P04     Sur    10
       sede  dias
id
P02   Norte     7
P03  Centro    21
P04     Sur    10
14 14

Las dos primeras instrucciones devuelven lo mismo por caminos distintos. Para llegar a la fila P04 con iloc hay que escribir 4 como final, porque la posición 4 queda por fuera. Con etiquetas, en cambio, se escribe P04 y entra.

¿Vista o copia? El Copy-on-Write de pandas 3

Copy-on-Write significa «copiar al escribir»: cada tabla o columna que sale de otra se comporta como una copia, y pandas solo copia de verdad cuando alguien la modifica. Es el modo por defecto y el único desde pandas 3.0; se introdujo por primera vez en la versión 1.5.0 [7].

Antes, el comportamiento era difícil de predecir. La propia guía admite que algunas operaciones devolvían vistas y otras copias, así que modificar un objeto podía modificar otro por accidente [7]. Con Copy-on-Write, una sola instrucción ya no puede cambiar más de un objeto [7]. Quien viene de NumPy debe notar el contraste: allí el rebanado básico de un array siempre crea una vista, que sí comparte los datos [18].

# Copy-on-Write (pandas 3): cambiar un subconjunto NO cambia la tabla original
subconjunto = prestamos["dias"]
subconjunto.iloc[0] = 100
print(prestamos.loc["P01", "dias"])      # sigue en 14

# Asignación encadenada (dos corchetes seguidos): nunca cambia la tabla
prestamos["dias"][prestamos["sede"] == "Sur"] = 0   # pandas avisa con ChainedAssignmentError
print(prestamos.loc["P04", "dias"])      # sigue en 10

# La forma correcta: loc, con fila y columna en un solo paso
prestamos.loc["P01", "dias"] = 15
print(prestamos.loc["P01", "dias"])      # ahora 15
prestamos.loc["P01", "dias"] = 14        # se deja como estaba para los ejemplos siguientes

14
10
15

La línea del medio es la trampa más común de los tutoriales viejos. La asignación encadenada, que actualiza con dos selecciones seguidas, nunca funciona con Copy-on-Write: pandas lanza el aviso ChainedAssignmentError y la tabla queda igual [7]. La documentación indica usar loc como alternativa [7]. Al correrlo, el aviso salió en pantalla, la tabla no cambió y loc sí hizo el cambio.

Cómo filtrar filas en pandas: máscaras booleanas y query

Filtrar es quedarse solo con las filas que cumplen una condición. En pandas se hace con una máscara booleana: una columna de verdaderos y falsos, uno por fila, que sale de una comparación como dias > 12. Las condiciones se combinan con & (y) y | (o), cada una entre paréntesis.

El método query hace lo mismo con la condición escrita como texto, casi como una frase [6]. Según la guía, su motor de cálculo rápido, numexpr, solo muestra ventaja con tablas de más de aproximadamente 100.000 filas [6]. Con tablas pequeñas, elija la forma que le resulte más fácil de leer.

# Filtro con una máscara booleana: préstamos de más de 12 días en Centro o Sur
largos = prestamos[(prestamos["dias"] > 12) & (prestamos["sede"].isin(["Centro", "Sur"]))]
print(largos)

# El mismo filtro escrito con query, como una frase
print(prestamos.query("dias > 12 and sede in ['Centro', 'Sur']").equals(largos))

       sede   codigo   prestado  dias
id
P01  Centro  LIT-014 2026-01-08    14
P03  Centro  CIE-031 2026-01-15    21
P07     Sur  LIT-014 2026-02-05    18
P10     Sur  CIE-031 2026-02-24    15
True

El True del final confirma que los dos caminos dan la misma tabla. Quien viene de R reconocerá la idea: la tabla de equivalencias de pandas pone el filter de dplyr, el paquete de R para manipular datos, junto a query [8][9].

Agrupar, unir y reorganizar tablas: qué herramienta usar

Tres familias de herramientas cubren casi todo el trabajo de transformar tablas: agrupar, unir y cambiar de forma. Esta tabla dice cuál usar para cada necesidad, con el ejemplo de los préstamos.

Necesidad	Herramienta	Ejemplo con los préstamos
Resumir por grupos	groupby + agg	Cuántos préstamos y cuántos días en promedio por sede
Traer columnas de otra tabla por una clave	merge	Añadir el título de cada libro desde el catálogo
Unir tablas por su índice	join	Juntar dos tablas que comparten el código del préstamo como etiqueta
Apilar tablas con las mismas columnas	concat	Juntar los préstamos de enero y de febrero
Pasar de formato largo a ancho	pivot o pivot_table	Sedes en filas, meses en columnas
Pasar de formato ancho a largo	melt	Volver a una fila por sede y mes

groupby en pandas: separar, aplicar y combinar

Según la guía de pandas, agrupar con groupby es un proceso que combina uno o más de estos tres pasos [10]:

1. Separar los datos en grupos según un criterio, por ejemplo la sede.
2. Aplicar una función a cada grupo por separado, como contar o promediar.
3. Combinar los resultados en una nueva tabla.

No es una idea exclusiva de pandas. McKinney anotaba en 2010 que agrupar viene incorporado en muchos lenguajes orientados a datos, como R y SQL, el lenguaje con el que se consultan las bases de datos [1].

# groupby: separar por sede, aplicar las cuentas a cada grupo y combinar
resumen = prestamos.groupby("sede").agg(
    prestamos=("dias", "size"),          # cuántos préstamos
    dias_promedio=("dias", "mean"),      # duración promedio
    dias_max=("dias", "max"),            # el préstamo más largo
)
print(resumen)

        prestamos  dias_promedio  dias_max
sede
Centro          4      12.250000        21
Norte           3      11.000000        14
Sur             3      14.333333        18

Cada par entre paréntesis dice qué columna se resume y con qué función, y el nombre de la izquierda es el de la columna nueva. Sur tiene menos préstamos que Centro, pero más largos en promedio: 14,33 días contra 12,25.

merge, join y concat: cómo unir tablas en pandas

La función merge une dos tablas por una columna en común, de forma parecida a las uniones de las bases de datos relacionales [11]. Su opción how decide qué filas sobreviven, y cada valor equivale a un tipo de JOIN, la instrucción de SQL que une tablas [11]:

how	Equivale en SQL a	Qué conserva
left	LEFT OUTER JOIN	Las claves de la tabla izquierda
right	RIGHT OUTER JOIN	Las claves de la tabla derecha
outer	FULL OUTER JOIN	La unión de las claves de ambas
inner	INNER JOIN	Solo las claves que están en las dos
cross	CROSS JOIN	Todas las combinaciones de filas

Si ya conoce los JOIN de SQL, la lógica es la misma. La guía describe también join, que une tablas a lo largo de las columnas, y concat, que pega varias tablas a lo largo de un eje [11]. Un eje es la dirección de la unión: una tabla debajo de otra o una al lado de otra.

# DATOS SINTÉTICOS: catálogo inventado. Falta a propósito el libro HIS-019
catalogo = pd.DataFrame({
    "codigo": ["LIT-007", "LIT-014", "HIS-002", "CIE-031"],
    "titulo": ["Cuentos del río", "Crónicas de barrio", "Caminos reales", "El agua en casa"],
})

# merge: unir por la columna en común, como un JOIN de SQL
completo = prestamos.reset_index().merge(catalogo, on="codigo", how="left", indicator=True)
print(completo[["id", "codigo", "titulo", "_merge"]].tail(3))
print(len(prestamos), len(completo))     # el left join conserva las 10 filas

    id   codigo           titulo     _merge
7  P08  LIT-007  Cuentos del río       both
8  P09  HIS-019              NaN  left_only
9  P10  CIE-031  El agua en casa       both
10 10

El préstamo P09 no encontró su libro en el catálogo, y el left join lo conservó con el título vacío. La opción indicator añade la columna _merge, que dice de qué lado vino cada fila. Contar las filas antes y después de unir es un hábito que evita sorpresas. Para eso la guía ofrece además la opción validate, que revisa si las claves son únicas [11].

pivot y melt: de formato largo a formato ancho

Una tabla larga tiene una fila por observación; una ancha reparte una variable en varias columnas. El método pivot hace ese cambio, pero solo acepta combinaciones únicas de fila y columna. Si hay repetidas, la guía remite a pivot_table, que agrega los valores [12]. El método melt hace el camino inverso, de ancho a largo [12]. El artículo de 2010 ya mostraba un pivot: los precios de las dos acciones pasaban a una columna por empresa [1].

# concat: apilar dos tablas con las mismas columnas, una debajo de la otra
enero = prestamos[prestamos["prestado"].dt.month == 1]
febrero = prestamos[prestamos["prestado"].dt.month == 2]
print(len(enero), len(febrero), len(pd.concat([enero, febrero])))

# pivot_table: sedes en filas, meses en columnas, número de préstamos en las celdas
prestamos["mes"] = prestamos["prestado"].dt.month
ancha = prestamos.pivot_table(index="sede", columns="mes", values="dias",
                              aggfunc="count")
print(ancha)

# melt: la operación inversa, de formato ancho a formato largo
larga = ancha.reset_index().melt(id_vars="sede", var_name="mes", value_name="prestamos")
print(larga.sort_values(["sede", "mes"]).head(4))

5 5 10
mes     1  2
sede
Centro  2  2
Norte   2  1
Sur     1  2
     sede mes  prestamos
0  Centro   1          2
3  Centro   2          2
1   Norte   1          2
4   Norte   2          1

Aquí hizo falta pivot_table y no pivot, porque cada sede tiene varios préstamos en el mismo mes y hay que contarlos. La versión ancha se lee mejor en pantalla. La larga, con una fila por sede y mes, es la que conviene para seguir agrupando con groupby.

Fechas y texto en pandas: los accesores dt y str

Un accesor es una puerta a funciones especiales para un tipo de columna. El accesor dt devuelve propiedades de fechas, como el mes o el día de la semana, para cada fila de una columna de fechas [13]. El accesor str aplica métodos de texto a toda la columna, y deja por fuera los valores faltantes de forma automática [5].

# .dt: propiedades de una columna de fechas
prestamos["devuelto"] = prestamos["prestado"] + pd.to_timedelta(prestamos["dias"], unit="D")
prestamos["dia_semana"] = prestamos["prestado"].dt.day_of_week   # 0 = lunes, 6 = domingo
print(prestamos[["prestado", "devuelto", "dia_semana"]].head(3))

# .str: métodos de texto aplicados a toda la columna
prestamos["area"] = prestamos["codigo"].str.split("-").str[0]
print(prestamos["area"].value_counts())
print(prestamos["codigo"].str.startswith("LIT").sum())

      prestado   devuelto  dia_semana
id
P01 2026-01-08 2026-01-22           3
P02 2026-01-12 2026-01-19           0
P03 2026-01-15 2026-02-05           3
area
LIT    4
HIS    3
CIE    3
Name: count, dtype: int64
4

Sumar días a una fecha da otra fecha: el préstamo P03, del 15 de enero y de 21 días, tiene como fecha de devolución el 5 de febrero. Y el código del libro, partido por el guion, dejó una columna de área sin escribir un solo bucle.

¿Qué hacer cuando el DataFrame no cabe en memoria?

Pandas trabaja con los datos cargados en la memoria del computador, y eso tiene un límite. La guía oficial lo dice sin rodeos: analizar datos más grandes que la memoria es «algo complicado» [14]. Hasta los que ocupan una parte grande de la memoria se vuelven difíciles de manejar, porque algunas operaciones hacen copias intermedias [14].

La misma guía propone cuatro salidas [14]:

1. Cargar menos datos: leer solo las columnas que se van a usar.
2. Usar tipos de datos más eficientes. Un texto con pocos valores distintos, como la sede, ocupa mucho menos como categoría, que guarda cada valor una vez. Los números se pueden pasar al tipo más pequeño que los contenga.
3. Trabajar por fragmentos: partir un problema grande en varios pequeños, siempre que cada fragmento quepa en memoria. Funciona cuando los fragmentos casi no tienen que coordinarse; un groupby, por ejemplo, es mucho más difícil de hacer por partes.
4. Pasar a otras librerías que imitan la forma de trabajar de pandas y reparten el cálculo.

El segundo punto se puede medir. En el ejemplo de la guía, la tabla quedó en la quinta parte de su tamaño original [14]. Probé lo mismo con un millón de préstamos inventados:

import numpy as np
import pandas as pd

# DATOS SINTÉTICOS: un millón de préstamos inventados, con solo tres sedes posibles
rng = np.random.default_rng(7)
grande = pd.DataFrame({
    "sede": rng.choice(["Centro", "Norte", "Sur"], size=1_000_000),
    "dias": rng.integers(1, 31, size=1_000_000),
})
antes = grande.memory_usage(deep=True).sum()

grande["sede"] = grande["sede"].astype("category")                  # cada texto se guarda una vez
grande["dias"] = pd.to_numeric(grande["dias"], downcast="unsigned")  # entero más pequeño
despues = grande.memory_usage(deep=True).sum()

print(grande.dtypes)
print(round(antes / 1e6, 1), "MB ->", round(despues / 1e6, 1), "MB")

sede    category
dias       uint8
dtype: object
61.7 MB -> 2.0 MB

La tabla pasó de 61,7 a 2,0 megabytes (MB), la unidad con que se mide la memoria. Leo ese resultado con cautela. Es mi medición, en mi equipo y sin PyArrow, una librería opcional que cambia la forma en que pandas guarda el texto [5]. Con PyArrow instalado, el punto de partida sería otro. Lo que sí se sostiene es la dirección: una columna de texto repetitivo es la primera candidata a categoría.

Cuando ni así alcanza, aparece Dask, que la lista oficial de herramientas compatibles con pandas presenta como una librería de cálculo en paralelo con una interfaz de DataFrame familiar [15]. Según su documentación, un DataFrame de Dask es una colección de muchos DataFrame de pandas, repartidos por filas [16]. Es perezoso: no calcula nada hasta que se le pide el resultado con compute [16]. Su versión más reciente es la 2026.8.0, del 24 de agosto de 2026 [16].

Hay dos salidas más, que solo nombro. Polars es otra librería de tablas, con su núcleo escrito en Rust, otro lenguaje de programación [17]. Y para datos repartidos entre muchos computadores existe la interfaz de pandas sobre Apache Spark (un motor de cálculo distribuido), dentro de PySpark (su interfaz para Python) [15]. Cuándo un volumen de datos deja de caber en un solo equipo es tema de la guía de big data.

Lo que pandas hace y lo que va en otras guías

Esta página se quedó en la manipulación de tablas. Hay cuatro temas que van en guías aparte. Son leer archivos de texto separado por comas (CSV) o de Excel, limpiar valores faltantes y duplicados, el recorrido exploratorio con describe y los gráficos. Todas usan lo de aquí: Series, DataFrame, loc, groupby y merge.

Lo que sigue diciendo un artículo de 2010

Vuelvo a las dos acciones de diciembre de 2009. El problema de McKinney no era la falta de cálculo, porque NumPy ya calculaba bien. Le faltaba una tabla con nombres, columnas de tipos distintos y operaciones que respetaran esas etiquetas [1].

Tomo partido. Si tiene una semana para aprender pandas, no la gaste memorizando funciones. Dedíquela a tres cosas: la alineación por etiquetas, la diferencia entre loc e iloc y el conteo de filas antes y después de cada merge. Los errores que más cuestan en pandas no rompen el programa. Dejan un NaN donde no había que dejarlo, o una tabla con más filas de las que había.

Y el acceso cuenta. Pandas no cobra licencia [2], corre en un computador personal como el que usé para esta página y su documentación está abierta. Una biblioteca municipal o una secretaría con poco presupuesto puede hacer, con la misma herramienta, el conteo de préstamos de este ejemplo con sus datos reales.

Preguntas frecuentes

¿Pandas es gratis? Sí. Pandas es software libre y se distribuye con una licencia BSD de 3 cláusulas [2]. Esa licencia permite usarlo, modificarlo y redistribuirlo sin pagar, también en el trabajo. Lo que sí exige es tiempo para aprenderlo y un computador con Python instalado.

¿Qué versión de Python necesito para usar pandas? Depende de la versión de pandas. La 3.1.1, la más reciente en el índice oficial de paquetes en la fecha de esta revisión, pide Python 3.11 o superior [3]. Con una versión más vieja de Python tendrá que usar un pandas anterior, que se comporta distinto en puntos como las copias. Antes de comparar resultados con otra persona, revisen los dos la versión que tienen.

¿Qué es un DataFrame en pandas? Es la tabla de pandas: un objeto de dos dimensiones, con filas y columnas que tienen nombre [4]. Cada columna puede tener su propio tipo de dato, así que en la misma tabla caben textos, fechas y cifras [4]. Por dentro, cada columna es una Series [2].

¿Por qué aparece el aviso ChainedAssignmentError? Aparece cuando se intenta cambiar un valor con dos selecciones seguidas, por ejemplo una columna y luego una condición entre corchetes. Desde pandas 3.0 esa asignación nunca modifica la tabla original, porque tendría que cambiar en un mismo paso la selección intermedia y la tabla, algo que Copy-on-Write no permite [7]. La solución es hacer el cambio en un solo paso con loc, indicando la fila y la columna a la vez [7].

¿Cuál es la diferencia entre merge y concat? La función merge empareja filas de dos tablas por una clave en común, como el código de un libro, y su opción how decide qué filas se conservan [11]. La función concat no empareja nada: pega tablas una debajo de otra o una al lado de otra, a lo largo de un eje [11]. Si las tablas comparten una clave, casi siempre la herramienta es merge; si son trozos de la misma tabla, es concat.

Referencias

Las citas en otro idioma son traducción propia.

1. McKinney, Wes. Data Structures for Statistical Computing in Python, Proceedings of the 9th Python in Science Conference (SciPy 2010), pp. 56-61, artículo de acceso abierto con licencia Creative Commons Attribution — ejemplo de dos acciones (GOOG y AAPL) entre el 28 y el 31 de diciembre de 2009; los arreglos estructurados de NumPy «do not provide the same level of flexibility and ease of use as other statistical environments» y no se integran bien con el resto de NumPy, pensado para un solo dtype; el data.frame de R guarda datos de tipos mezclados; el DataFrame de pandas implementa buena parte de su par de R «with some important enhancements (namely, built-in data alignment)»; «The package’s name derives from panel data, which is a term for 3-dimensional data sets encountered in statistics and econometrics»; los datos de panel observan un conjunto de individuos o entidades a lo largo de un periodo; la suma de objetos alineados contiene «the union of the labels between the two objects so that no information is lost»; NaN representa datos faltantes; ejemplo de pivot con los precios por empresa; el «group by» viene incorporado en muchos lenguajes orientados a datos, como R y SQL. SciPy Proceedings: Data Structures for Statistical Computing in Python · DOI 10.25080/Majora-92bf1922-00a — Consultada: 2026-11-11.
2. pandas development team. Package overview, documentación de pandas 3.1.1 — estructuras de datos para trabajar con datos «relational» o «labeled»; lista de lo que pandas hace bien (alineación automática y explícita, group by de tipo split-apply-combine, unión de conjuntos de datos, cambio de forma y pivot, funciones de series de tiempo); «DataFrame is a container for Series, and Series is a container for scalars»; Series como arreglo de una dimensión y DataFrame como estructura tabular de dos dimensiones; licencia BSD 3-Clause. pandas: Package overview — Consultada: 2026-11-11.
3. Python Package Index (PyPI). pandas — versión 3.1.1, publicada el 2026-11-04; requiere Python 3.11 o superior; licencia BSD-3-Clause. La portada del proyecto anuncia «Latest version: 3.1.1». PyPI: pandas 3.1.1 · pandas: portada — Consultada: 2026-11-11.
4. pandas development team. 10 minutes to pandas, documentación de pandas 3.1.1 — importación habitual «import pandas as pd»; Series: «a one-dimensional labeled array holding data of any type»; DataFrame: estructura de dos dimensiones como una tabla con filas y columnas; «NumPy arrays have one dtype for the entire array while pandas DataFrames have one dtype per column»; para código de producción se recomiendan los métodos at, iat, loc e iloc. pandas: 10 minutes to pandas — Consultada: 2026-11-11.
5. pandas development team. Working with text data, documentación de pandas 3.1.1 — desde la versión 3.0, cuando pandas infiere el tipo de una colección de textos usa dtype «str», respaldado por PyArrow si está instalado o por un arreglo object de NumPy si no lo está; los métodos de texto se usan con el atributo str y «exclude missing/NA values automatically». pandas: Working with text data — Consultada: 2026-11-11.
6. pandas development team. Indexing and selecting data, documentación de pandas 3.1.1 — «.loc is primarily label based» y lanza KeyError si no encuentra la etiqueta; en un tramo de etiquetas, a diferencia de los tramos usuales de Python, se incluyen el inicio y el final; «.iloc is primarily integer position based» y lanza IndexError fuera de rango, salvo en tramos; ambos aceptan arreglos booleanos; el método query selecciona con una expresión; con numexpr solo se ve ventaja de rendimiento en tablas de más de aproximadamente 100.000 filas. pandas: Indexing and selecting data — Consultada: 2026-11-11.
7. pandas development team. Migration Guides: Copy-on-Write (CoW), documentación de pandas 3.1.1 — «Copy-on-Write is the default and only mode in pandas 3.0»; se introdujo por primera vez en la versión 1.5.0; antes algunas operaciones devolvían vistas y otras copias, y modificar un objeto podía modificar otro por accidente; con CoW no se puede actualizar más de un objeto con una sola instrucción y las copias se retrasan «as long as possible»; la asignación encadenada «will consistently never work» y lanza un aviso ChainedAssignmentError; se debe usar loc como alternativa. pandas: Copy-on-Write (CoW) — Consultada: 2026-11-11.
8. pandas development team. Comparison with R / R libraries, documentación de pandas 3.1.1 — tabla de referencia rápida que pone operaciones comunes de R con dplyr junto a su equivalente en pandas, entre ellas filter(df, col1 == 1, col2 == 1) junto a df.query(‘col1 == 1 & col2 == 1’). pandas: Comparison with R — Consultada: 2026-11-11.
9. Equipo de tidyverse. dplyr, sitio oficial del paquete (versión 1.2.1) — «dplyr is a grammar of data manipulation, providing a consistent set of verbs»; filter() selecciona casos según sus valores; group_by() permite operar por grupo. dplyr: portada oficial — Consultada: 2026-11-11.
10. pandas development team. Group by: split-apply-combine, documentación de pandas 3.1.1 — el group by es un proceso de uno o más pasos: separar los datos en grupos según un criterio, aplicar una función a cada grupo de forma independiente y combinar los resultados en una estructura de datos. pandas: Group by — Consultada: 2026-11-11.
11. pandas development team. Merge, join, concatenate and compare, documentación de pandas 3.1.1 — concat() une objetos a lo largo de un eje; DataFrame.join() une tablas a lo largo de las columnas; merge() «performs join operations similar to relational databases like SQL»; equivalencias de how: left (LEFT OUTER JOIN), right (RIGHT OUTER JOIN), outer (FULL OUTER JOIN), inner (INNER JOIN) y cross (CROSS JOIN); el argumento validate revisa la unicidad de las claves. pandas: Merge, join, concatenate and compare — Consultada: 2026-11-11.
12. pandas development team. Reshaping and pivot tables, documentación de pandas 3.1.1 — «pivot() can only handle unique rows specified by index and columns. If your data contains duplicates, use pivot_table()»; pivot_table() pivota con agregación; melt() pasa un DataFrame de formato ancho a formato largo. pandas: Reshaping and pivot tables — Consultada: 2026-11-11.
13. pandas development team. Essential basic functionality, sección .dt accessor, documentación de pandas 3.1.1 — la Series tiene un accesor que devuelve propiedades de fecha y hora de sus valores si es una Series de fechas o periodos. pandas: Essential basic functionality — Consultada: 2026-11-11.
14. pandas development team. Scaling to large datasets, documentación de pandas 3.1.1 — pandas ofrece estructuras para análisis en memoria, lo que hace «somewhat tricky» analizar datos más grandes que la memoria; algunas operaciones hacen copias intermedias; recomendaciones: cargar menos datos, usar tipos de datos eficientes (categoría para texto con pocos valores únicos, números reducidos con to_numeric), trabajar por fragmentos y usar otras librerías; en su ejemplo la tabla queda en 1/5 de su tamaño original; operaciones como groupby son «much harder to do chunkwise». pandas: Scaling to large datasets — Consultada: 2026-11-11.
15. pandas development team. Ecosystem — Dask: «a flexible parallel computing library for analytics» que ofrece «a familiar DataFrame interface for out-of-core, parallel and distributed computing»; pandas API on Spark (pyspark.pandas) ofrece una interfaz de DataFrame de pandas sobre Apache Spark, en una máquina o en un clúster. pandas: Ecosystem — Consultada: 2026-11-11.
16. Dask developers. Dask DataFrame, documentación de Dask — «Dask DataFrames are a collection of many pandas DataFrames»; se particiona por filas; «Dask is lazy; when you want an in-memory result add .compute()». Versión 2026.8.0, publicada en PyPI el 2026-08-24. Dask: Dask DataFrame · PyPI: dask 2026.8.0 — Consultada: 2026-11-11.
17. Polars. Polars user guide — «Polars is a blazingly fast DataFrame library for manipulating structured data. The core is written in Rust». Polars: User guide — Consultada: 2026-11-11.
18. NumPy Developers. Copies and views, manual de NumPy 2.5 — «basic indexing always creates views»; una vista comparte los datos del array original. NumPy: Copies and views — Consultada: 2026-11-11.

Cómo investigamos esta página

• Pregunta que responde: qué es pandas y cómo se seleccionan, filtran, agrupan, unen y reorganizan tablas con él
• Fuentes: identificadas 23 → incluidas 20
• Criterios de inclusión: documentación oficial de pandas, Dask, dplyr, Polars, NumPy y PyPI, y McKinney 2010, leídos en texto crudo
• Fecha de corte de los datos: 2026-11-11