Preparación de datos con pandas

Un dato faltante significa que un valor es desconocido o no está disponible. pandas almacena un marcador especial en su lugar. Detecta el marcador antes de calcular totales o decidir qué filas se pueden utilizar.

Reconoce los marcadores

El marcador depende del tipo de datos. Las columnas de tipo flotante usan NaN, las columnas de fecha y hora usan NaT, y los tipos que admiten valores faltantes, como "Int64", "boolean" y "string", usan pd.NA. pandas 3 infiere las columnas de texto como str, con NaN para el texto faltante. El valor None de Python también se reconoce como faltante. Usa import pandas as pd e import numpy as np para los ejemplos.

df.isna() produce una tabla booleana con las mismas filas y columnas que df. Un True marca un valor faltante; df.notna() marca los valores presentes. Los alias isnull() y notnull() hacen lo mismo. No compares una columna con np.nan: NaN es distinto incluso de sí mismo, por lo que s == np.nan no detecta los valores faltantes.

Cuenta las celdas y las filas afectadas

Considera estas mediciones meteorológicas:

Un True booleano cuenta como 1, por lo que df.isna().sum() da 0 ciudades faltantes, 2 temperaturas y 2 mediciones de lluvia. df.isna().mean() da las proporciones 0,0, 0,5 y 0,5. La proporción de cada columna usa las cuatro filas como denominador.

Para detectar las filas afectadas, usa df.isna().any(axis=1). Devuelve False, True, True, True; al sumar se obtiene 3. En cambio, df.isna().sum().sum() da 4 celdas con valores faltantes. Kyiv aporta dos celdas, pero solo una fila afectada. Usa la medida que responda a tu pregunta.

Reconoce los códigos ocultos de valores faltantes

Un instrumento puede registrar una medición no disponible como -999, "-" o "unknown". Son valores ordinarios hasta que los conviertas. Tras confirmar el significado del código, usa df.replace([-999, "unknown"], np.nan). Durante la carga de un CSV, na_values=[-999, "unknown"] añade estos códigos a los marcadores reconocidos. Los campos CSV vacíos y las cadenas habituales como "NA", "n/a" y "NULL" ya se reconocen por defecto.

Una medición de lluvia igual a cero puede significar que no llovió, por lo que sustituir todos los ceros destruiría observaciones reales. Además, una cadena vacía creada en memoria, "", y una cadena que contiene espacios no son valores faltantes para isna(). Inspecciona el texto almacenado además de los recuentos de marcadores. Para incluir categorías faltantes en una tabla de frecuencias, usa value_counts(dropna=False).

Comprueba los cálculos y los tipos de datos

Para s = pd.Series([4, np.nan, 8]), s.mean() es 6,0: usa los dos valores conocidos. s.count() es 2, mientras que len(s) es 3. Dividir s.sum() entre len(s) da 4,0 y trata incorrectamente el valor faltante como cero. La mayoría de los estadísticos omiten los valores faltantes por defecto; una columna en la que faltan todos los valores tiene suma 0, pero media NaN.

Un valor faltante también puede cambiar el almacenamiento. pd.Series([3, None, 5]) se convierte en float64 y contiene 3,0, NaN y 5,0. Al indicar dtype="Int64" se conservan los valores enteros con <NA> para el valor faltante. La I mayúscula identifica el tipo entero de pandas que admite valores faltantes.

Eliminar una fila quita sus valores conocidos junto con los faltantes. Rellenar un valor faltante conserva la fila, pero introduce una estimación. Elige según el significado de la observación y las columnas que necesite el análisis.

Controla qué filas se eliminan

df.dropna() elimina todas las filas con algún valor faltante. En la tabla meteorológica, solo queda Lima. Limita la decisión con subset o exige un número mínimo de celdas con valores presentes mediante thresh.

axis="columns" elimina las columnas con valores faltantes y aquí conserva solo city. En una tabla ancha, la regla predeterminada para filas puede descartar gran parte de los datos, porque basta un valor faltante en cualquier columna. Compara len(df) antes y después de la eliminación.

Asigna el resultado

Aprende la forma con reasignación: df = df.dropna(). Por defecto, los métodos de limpieza devuelven un objeto nuevo. pandas 3.1 desaconseja inplace=True para métodos como dropna, drop_duplicates y rename.

Para una columna, escribe df["temp_c"] = df["temp_c"].fillna(0). Una llamada encadenada como df["temp_c"].fillna(0, inplace=True) nunca actualiza el DataFrame original con la copia al escribir de pandas 3. La asignación hace explícito el destino.

Rellena con un valor compatible

Un diccionario por columna permite que una tabla mixta reciba valores adecuados: df.fillna({"rain_mm": 0, "city": "Unknown"}). Las columnas omitidas del diccionario conservan sus valores faltantes. Un escalar como 0 es práctico para una tabla íntegramente numérica cuyas columnas lo acepten todas. Rellenar texto con un número es incompatible; pandas 3.1 advierte de ello y una versión futura lo rechazará.

Las temperaturas conocidas son 18,0 y 31,0. Su media es 24,5, por lo que df["temp_c"].fillna(df["temp_c"].mean()) coloca 24,5 en ambos huecos. Un valor extremo puede desplazar mucho la media; la mediana es menos sensible. Antes de rellenar, conserva un indicador con df["temp_missing"] = df["temp_c"].isna() para que los valores estimados y observados sigan siendo distinguibles.

El relleno con la media reduce la dispersión aparente de la columna. Un valor fijo alejado puede aumentarla. Rellenar la precipitación con 0 afirma que no llovió, lo que es inapropiado para un sensor que estaba apagado.

Usa mediciones vecinas cuando el orden importe

ffill() lleva el último valor conocido hacia adelante; bfill() lleva el siguiente valor conocido hacia atrás. Para 12,0, NaN, NaN, NaN, 15,0, el relleno hacia adelante da cuatro valores de 12,0 seguidos de 15,0. ffill(limit=1) rellena solo el primer hueco de esa secuencia. Un valor faltante al comienzo no tiene valor anterior y sigue faltando. Usa ffill() directamente; fillna(method="ffill") se eliminó en pandas 3.

interpolate() estima entre posiciones vecinas. Para 10, NaN, NaN, 16, la interpolación lineal da 10, 12, 14, 16. Es adecuada para mediciones que cambian suavemente en un orden significativo. Propagar valores o interpolar entre ciudades no relacionadas impondría una relación que las filas no tienen.

Después de cualquier operación, vuelve a ejecutar isna().sum() y comprueba también los recuentos de filas. Una llamada correcta a un método indica que el código se ejecutó; estas comprobaciones indican qué cambió.

Dos filas pueden parecer iguales sin describir el mismo acontecimiento. Antes de eliminar duplicados, decide qué valores identifican un registro. Un identificador de pedido puede identificar un pedido; el cliente y la fecha por sí solos pueden identificar varias compras legítimas.

Marca las copias adicionales

df.duplicated() devuelve un valor booleano por fila. Por defecto compara todas las columnas, conserva la primera aparición y marca las copias posteriores como True. Sumar el resultado cuenta las copias adicionales, no todos los miembros de los grupos repetidos.

Considera seis filas de pedidos con los identificadores 101, 102, 102, 103, 104, 104. Las dos filas de 102 son idénticas. Las dos filas de 104 tienen distintos pesos registrados, 0,5 kg y 0,8 kg. Al comparar todas las columnas hay una copia adicional: df.duplicated().sum() es 1. df.drop_duplicates() conserva cinco filas porque las dos filas distintas de 104 no son copias exactas.

Compara las columnas que definen la identidad

df.duplicated(subset=["order_id"]) compara solo los identificadores. Marca el segundo 102 y el segundo 104, lo que da dos copias adicionales. Los valores de las demás columnas ya no afectan a esta decisión. Inspecciona los pesos que discrepan antes de elegir qué registro de pedido conservar.

df.drop_duplicates(subset="order_id", keep="last") conserva la versión de 0,8 kg del pedido 104 en este orden. Conservar la última fila no significa por sí mismo conservar el registro más reciente. Establece primero ese orden:

latest = df.sort_values("updated").drop_duplicates(
    subset="customer_id", keep="last"
)

Ordenar por updated coloca los registros antiguos antes de los más recientes. La comprobación de duplicados compara después solo customer_id, por lo que las distintas horas de actualización no impiden reconocer dos filas como versiones del mismo cliente.

Separa los valores de las filas de las etiquetas del índice

Estos métodos comparan valores e ignoran las etiquetas del índice. Las filas idénticas con etiquetas 4 y 9 siguen contando como duplicadas. Para esta comprobación, los valores faltantes en posiciones correspondientes cuentan como iguales. Para comprobar las propias etiquetas repetidas, usa df.index.duplicated().

La comparación exacta también conserva las diferencias de mayúsculas, minúsculas y espacios en blanco. Los valores « Lisbon», «lisbon» y «LISBON » son distintos. Limpia con .str.strip().str.lower() antes de buscar duplicados cuando esas variantes representen la misma ciudad. De lo contrario, nunique() contará tres nombres para un mismo lugar.

Comprueba la unicidad donde la relación la necesite

Una tabla de consulta debe tener una fila por clave de consulta cuando cada registro deba recibir un solo conjunto de datos. lookup["customer_id"].is_unique comprueba ese requisito. Los identificadores de cliente repetidos en una tabla de pedidos son normales porque un cliente puede hacer varios pedidos.

Si una clave de consulta se repite, una combinación posterior repite cada pedido coincidente por cada fila coincidente de la tabla de consulta. Eliminar duplicados de los pedidos descartaría compras reales sin corregir la tabla de consulta. Comprueba la clave prevista en la tabla correcta, inspecciona los registros que discrepan y compara el número de filas después de la eliminación.

Una sustitución modifica los valores coincidentes, una correspondencia transforma valores y un cambio de nombre modifica etiquetas. Estas tareas pueden parecer similares en el código, pero producen resultados distintos cuando un valor no aparece en un diccionario.

Sustituye valores exactos

s.replace("N/A", np.nan) cambia solo las celdas iguales a "N/A". Una lista puede indicar varios valores anteriores: s.replace(["-", "?"], np.nan). Un diccionario proporciona sustituciones distintas, como s.replace({"M": "male", "F": "female"}). Los valores sin coincidencia permanecen como estaban.

Para una tabla completa, un diccionario anidado limita la modificación a una columna: df.replace({"status": {0: "open", 1: "closed"}}). Esto evita cambiar ceros y unos no relacionados en otras partes. Asigna el resultado devuelto para conservar el cambio.

replace busca coincidencias con celdas completas. Con «Main St» y «St», s.replace("St", "Street") solo cambia «St». Para modificar partes de una cadena, usa s.str.replace("St", "Street", regex=False), que también produce «Main Street».

Transforma mediante una correspondencia

Para los códigos «PT», «JP» y «KE», compara el mismo diccionario en dos métodos:

Un diccionario pasado a map define los resultados disponibles. Una clave ausente no tiene resultado y pasa a ser un valor faltante. Comprueba después isna().sum() para que una correspondencia incompleta quede visible.

map también acepta una función: s.map(lambda x: x * 1000) convierte valores de kilómetros a metros. Para esta operación aritmética, s * 1000 es más sencillo y rápido porque opera sobre toda la columna. DataFrame.map aplica una función celda a celda; sustituye al método eliminado applymap.

Convierte texto a números

astype solicita un tipo de datos, como "float64", "Int64" o "category". Genera un error si un valor no se puede convertir. Para el texto "12", "7.5" y "n/a", pd.to_numeric(s, errors="coerce") produce, en cambio, 12,0, 7,5 y NaN. La coerción conserva los números que se pueden interpretar, pero requiere inspeccionar los fallos.

El formato puede impedir la conversión incluso cuando el número es válido. Para «1,200» y «950», elimina primero el separador de millares:

cleaned = s.str.replace(",", "", regex=False)
numbers = pd.to_numeric(cleaned, errors="coerce")
failed = s.notna() & numbers.isna()

Aquí failed marca los valores que estaban presentes antes de la conversión pero pasaron a ser faltantes. Comparar solo los recuentos de valores faltantes da un total útil; la máscara también localiza el texto original para inspeccionarlo. Elimina las unidades conocidas del texto de mediciones de la misma manera deliberada antes de convertir.

Cambia los nombres de las etiquetas

df.rename(columns={"Qty": "quantity"}) cambia el encabezado de una columna y deja sus celdas sin cambios. df.rename(columns=str.lower) convierte todos los encabezados a minúsculas. Una secuencia como df.columns.str.strip().str.lower().str.replace(" ", "_", regex=False) convierte «Total KG » en total_kg; asígnala a df.columns.

Usa replace o map para los valores dentro de una columna. Usa rename para las etiquetas con las que seleccionas esos valores.

Algunos análisis necesitan mediciones exactas, mientras que otros necesitan grupos o intervalos numéricos comparables. Mantén claro el significado original: la agrupación en intervalos crea categorías, el escalado cambia la escala numérica y la limitación sustituye valores extremos.

Agrupa valores en intervalos

pd.cut(ages, [18, 30, 45, 65]) usa los intervalos (18, 30], (30, 45] y (45, 65]. El paréntesis excluye el extremo izquierdo; el corchete de cierre incluye el extremo derecho. Las edades 19, 25 y 30 entran en el primer intervalo, 41 en el segundo y 64 en el tercero. La edad 18 pasa a ser un valor faltante porque está en el límite izquierdo excluido.

include_lowest=True incluye ese valor mínimo en el primer intervalo. right=False crea, en cambio, intervalos cerrados por la izquierda como [18, 30), por lo que 30 entra en el segundo intervalo. Los valores fuera de todos los intervalos siguen siendo faltantes. Comprueba los límites exactos, además de los valores habituales entre ellos.

Debe haber una etiqueta por intervalo, una menos que el número de límites. Con labels=["18-30", "31-45", "46-65"] e include_lowest=True, las seis edades anteriores dan recuentos de 4, 1 y 1. Estas etiquetas describen edades enteras; los límites de los intervalos siguen determinando la asignación.

Elige límites o tamaños de grupo

Para 2, 4, 6, 8, 10, 12, 14, 16, qcut da dos valores por grupo de cuartil. Los grupos con igual número de valores no tienen por qué abarcar intervalos numéricos de igual amplitud.

Escala sin crear grupos

El escalado mínimo-máximo usa (x - x.min()) / (x.max() - x.min()). Para 10, 20, 40, el rango es 30: los resultados son 0, aproximadamente 0,333 y 1. Se necesitan tanto el mínimo como el máximo; dividir solo por el máximo es una operación distinta. Una columna constante tiene rango cero, por lo que esta expresión no puede darle una dispersión escalada útil.

La estandarización usa (x - x.mean()) / x.std(). Para 10, 20, 30, la media es 20 y la desviación estándar muestral predeterminada de pandas es 10. Restar 20 y dividir por 10 da las puntuaciones z -1, 0 y 1. Una puntuación z describe la distancia a la media en unidades de desviación estándar, no una etiqueta de intervalo.

Limita y codifica

pd.Series([5, 12, 250, 8]).clip(upper=100) da 5, 12, 100, 8. A diferencia de un filtro, clip conserva la fila y sustituye el número extremo. Inspecciona los valores grandes con describe() o un filtro antes de limitarlos: una medición grande real sigue siendo un dato.

pd.get_dummies(s) crea una columna indicadora booleana por categoría. Con rojo, verde, rojo, azul, cada fila es True solo en la columna de su color. Usa dtype=int para obtener ceros y unos. Los valores faltantes dan indicadores todos falsos salvo que dummy_na=True añada una columna para valores faltantes. Para la regresión por mínimos cuadrados ordinarios con intercepto, drop_first=True elimina una columna de categoría redundante; otros modelos pueden conservar todas las categorías. Con una categoría por fila, el conjunto completo de indicadores suma la constante 1 del intercepto, lo que crea una dependencia lineal.

Para celdas que contienen varias etiquetas, s.str.get_dummies(sep="|") divide un valor como «Action|Comedy» en indicadores separados. Los intervalos agrupados también se pueden pasar a get_dummies, lo que da una columna por cada intervalo.

Una persona ve la misma ciudad en « Lisbon», «lisbon» y «LISBON ». pandas ve tres cadenas distintas. Limpiar una columna de texto proporciona un conjunto coherente de valores que comparar en recuentos, comprobaciones de duplicados y combinaciones posteriores.

Aplica métodos de cadenas a una Series

"Lima ".strip() de Python actúa sobre una cadena. Para una columna, usa el accesor .str: s.str.strip() elimina los espacios exteriores de cada valor presente. s.lower() genera un AttributeError porque la propia Series no tiene un método lower. Usa s.str.lower().

pandas 3 normalmente infiere el texto como tipo de datos str, que sustituye al antiguo valor predeterminado object. El tipo str contiene texto y valores faltantes, con NaN para el texto faltante. Los métodos de cadenas funcionan con ambos tipos. Asigna texto a una columna str; convierte primero un número a texto si debe estar allí como texto.

Combina operaciones de limpieza compatibles y asigna el resultado:

df["city"] = df["city"].str.strip().str.lower()

Las tres variantes de Lisboa se convierten en «lisbon». strip() elimina los espacios en blanco exteriores, no los espacios dentro de un nombre. upper() convierte todas las letras a mayúsculas, mientras que title() escribe cada palabra con mayúscula inicial y convierte «new york» en «New York». Elige una forma coherente para las claves y los recuentos.

Divide cadenas estructuradas

Para «Silva, Ana» y «Tanaka, Yui», s.str.split(", ") devuelve listas como ["Silva", "Ana"]. Añade expand=True para producir columnas separadas. Obtén una parte de cada lista con .str[0] o .str.get(1).

Si solo el primer separador debe dividir un valor, usa n=1. Dividir «a,b,c» por comas con n=1 da «a» y «b,c». Sin límite, da tres partes. Haz coincidir el separador exactamente, incluido cualquier espacio que forme parte del formato.

Busca y filtra

s.str.contains("lis", case=False) busca texto en cualquier posición e ignora la diferencia entre mayúsculas y minúsculas. s.str.startswith("ID") comprueba el principio; s.str.endswith(".csv") comprueba el final. Los resultados booleanos pueden seleccionar filas:

mask = df["city"].str.contains("san", case=False, na=False)
selected = df[mask]

Para el tipo str de pandas 3, el texto faltante da False en estas búsquedas. Escribir na=False también deja claro el tratamiento previsto cuando se usan cadenas que admiten valores faltantes. contains interpreta por defecto un patrón de expresión regular; añade regex=False para texto literal que contenga caracteres especiales.

Sustituye partes y crea cadenas nuevas

s.str.replace("kg", "", regex=False) elimina «kg» dondequiera que aparezca. s.replace("kg", "") solo cambia las celdas que son exactamente «kg». Esta distinción importa para valores como «12 kg».

str.replace trata literalmente su texto de búsqueda por defecto. Para «3.5 kg», .str.replace(".", "", regex=False) elimina el punto y da «35 kg». Con regex=True, el punto es un patrón para casi cualquier carácter y elimina todos los caracteres en este ejemplo de una sola línea. Nunca uses ese cambio para interpretar una medición decimal.

s.str.len() cuenta caracteres; un valor faltante produce NaN y puede hacer que el resultado sea una columna de tipo flotante. s.str[:3] extrae los tres primeros caracteres. Para combinar columnas, df["first"] + " " + df["last"] une Ana y Silva como «Ana Silva»; str.cat es otro método de unión. Cada operación devuelve un resultado, así que guárdalo en la columna que quieras usar.

Una expresión regular, o regex, describe un patrón en el texto. Puede reconocer una cantidad incluso cuando varían el número de dígitos o los espacios. Empieza con un patrón pequeño cuyas partes puedas explicar.

Interpreta las partes del patrón

Escribe los patrones de Python como cadenas sin procesar, como r"\d+", para que Python conserve sus barras invertidas. Por defecto, un punto coincide con cualquier carácter excepto un salto de línea. Escápalo como r"\." para encontrar un punto real. Para una búsqueda de texto literal, regex=False evita por completo la interpretación como patrón.

Elige cuánto texto debe coincidir

contains encuentra un patrón en cualquier posición, match comienza al principio y fullmatch exige que todo el valor coincida. Para «123a», s.str.contains(r"\d+") y s.str.match(r"\d+") encuentran una coincidencia, pero s.str.fullmatch(r"\d+") no. Usa la comprobación de toda la cadena al verificar un código completo. case=False o flags=re.IGNORECASE después de import re permite buscar coincidencias sin distinguir mayúsculas y minúsculas cuando se admite esa opción.

Captura una medición

Considera «Rice 5 kg», «Flour 2kg», «Salt» y «Beans 12 kg, 3 kg». El patrón r"(\d+)\s*kg" significa uno o más dígitos capturados como grupo, seguidos de cero o más espacios y después «kg».

quantity = s.str.extract(r"(\d+)\s*kg", expand=False)
quantity = pd.to_numeric(quantity)

Las cadenas extraídas son «5», «2», un valor faltante y «12». La conversión da los valores numéricos 5,0, 2,0, NaN y 12,0. extract toma la primera coincidencia de cada fila, por lo que la segunda cantidad de la descripción de las judías no se incluye. Sin expand=False, un solo grupo devuelve un DataFrame de una columna.

Los grupos con nombre etiquetan la salida. s.str.extract(r"(?P<year>\d{4})-(?P<month>\d{2})") encuentra «2024-03» dentro de «Report 2024-03 final» y devuelve las columnas de texto year y month. El patrón reconoce la disposición de los dígitos; la conversión numérica es un paso aparte.

Encuentra todas las coincidencias o limpia mediante un patrón

findall(r"\d+") da una lista por fila, incluidas ["12", "3"] para el texto de las judías y [] para «Salt». count(r"\d+") cuenta las coincidencias. extractall da una fila por coincidencia con un nivel adicional del índice llamado match.

Con regex=True, s.str.replace(r"\s+", " ", regex=True) reduce las secuencias de espacios en blanco a un solo espacio. r"\D" significa un carácter que no es un dígito, por lo que eliminarlo convierte «+351 912-345-678» en «351912345678». Las formas mayúsculas \S y \W niegan de forma similar las clases de caracteres de espacio en blanco y de palabra.

La repetición es voraz por defecto. En "<b>x</b>", r"<.*>" abarca desde el primer símbolo de apertura hasta el último símbolo de cierre. Eliminar esa coincidencia elimina todo. El patrón no voraz r"<.*?>" coincide con cada etiqueta por separado y deja «x». Comprueba las salidas de ejemplo antes de usar un patrón en toda una columna.

Una columna con pocos valores repetidos muchas veces puede usar el tipo de datos category. Este almacena las etiquetas distintas una sola vez y representa cada fila con un pequeño código entero. El valor visible sigue siendo la etiqueta.

Comprende las categorías y los códigos

Para las tallas M, S, L, M, M, s.astype("category") infiere las categorías L, M, S en orden alfabético. Los códigos son 1, 2, 0, 1, 1. Usa s.cat.categories para inspeccionar las etiquetas y s.cat.codes para inspeccionar los identificadores. Un código 0 significa la primera categoría almacenada; no es una cantidad medida.

Las etiquetas repetidas pueden ahorrar mucha memoria. Hasta 126 categorías, los códigos usan un byte cada uno; a partir de 127 categorías usan dos bytes. En una configuración de pandas 3.1 con PyArrow, tres nombres de países repetidos en 3 000 000 de filas usaron unos 3 MB como datos categóricos, unos 42 MB como str y unos 165 MB como object. El sistema de almacenamiento de texto afecta a estas cifras. Una columna con valores casi todos únicos no se beneficia de almacenar una lista de categorías y un código por fila.

Define un orden significativo

El orden alfabético de las tallas coloca L antes de M y M antes de S. Define explícitamente el orden real de las tallas:

size_type = pd.CategoricalDtype(["S", "M", "L"], ordered=True)
sizes = s.astype(size_type)

Ahora la ordenación sigue S, M, L, las comparaciones como sizes > "S" tienen sentido y sizes.max() es «L» cuando aparece L. Para etiquetas sin ordenar, como países, funcionan las comprobaciones de igualdad, pero las comparaciones de mayor que generan un TypeError. as_ordered() usa la secuencia de categorías existente; inspecciónala antes de declarar que esa secuencia tiene significado.

Cambia las etiquetas permitidas

No puedes asignar «XL» a una variable categórica que solo permite S, M y L. Primero asigna el resultado ampliado, sizes = sizes.cat.add_categories("XL"), y después asigna el nuevo valor.

Convertir texto a una lista fija de categorías puede convertir los valores no incluidos en valores faltantes. pandas 3.1 advierte de que esta conversión con pérdida de información se convertirá en un error. Comprueba los valores de origen con value_counts() antes de convertir, especialmente después de limpiar las variantes de escritura.

Los métodos .cat tienen distintos fines:

• rename_categories({"S": "small"}) cambia una etiqueta y conserva sus elementos.
• remove_categories("L") elimina una etiqueta permitida y convierte los valores L existentes en valores faltantes.
• set_categories([...]) sustituye toda la lista de categorías.
• reorder_categories([...], ordered=True) cambia el orden sin cambiar las etiquetas permitidas.
• remove_unused_categories() elimina las etiquetas que no tienen elementos actualmente.

value_counts() muestra todas las categorías permitidas, incluidas las que tienen cero observaciones. Con un tipo S/M/L que contiene solo S y M, L sigue apareciendo con un recuento de 0. Esto revela un grupo vacío para el que los datos de texto ordinarios no tienen una etiqueta almacenada.

Mantén la utilidad de las categorías en pasos posteriores

cut produce intervalos categóricos y get_dummies convierte la pertenencia a categorías en columnas indicadoras. Entregar códigos de países sin ordenar a un modelo como números impondría un orden y unas distancias artificiales. Los indicadores evitan esa interpretación.

Concatenar columnas categóricas con distintas listas de categorías normalmente hace que se pierda el tipo categórico. Alinea primero sus listas de categorías o usa pd.concat(..., union_categories=True) en pandas 3.1 cuando quieras combinar las listas. Inspecciona tanto el tipo resultante como el orden de las categorías.

Una combinación relaciona filas mediante valores de clave y coloca su información una junto a otra. La clave debe describir lo mismo en ambas tablas, como el identificador de cliente de un pedido y el identificador de cliente de una tabla de consulta.

Indica la clave y elige el tipo de combinación

Usa orders.merge(customers, on="customer_id"). Sin on, pandas usa todos los nombres de columna compartidos por ambas tablas. Una columna compartida sin relación, como date, podría impedir entonces coincidencias válidas de clientes.

Supón que los pedidos tienen los identificadores de cliente 10, 20, 20, 30, 50. La tabla de clientes tiene una fila para cada uno de 10, 20, 30, 40.

La combinación interna es la predeterminada. En una combinación por la izquierda, faltan los datos del cliente 50. Una combinación por la derecha incluye al cliente 40 sin pedido, además de los dos pedidos de 20. Una combinación externa completa incluye ambas claves sin correspondencia. Una combinación cruzada no necesita clave porque empareja deliberadamente todas las filas. pandas 3 también ofrece left_anti y right_anti para las filas que no tienen una clave coincidente en el otro lado.

Comprueba cuántas coincidencias puede tener una fila

Dos filas izquierdas para la clave 20 y tres filas derechas para la clave 20 producen seis pares. La combinación no elige una sola fila derecha. En el ejemplo, añadir una segunda fila de consulta del cliente 20 aumenta el resultado interno de cuatro filas a seis.

Expresa la relación prevista con validate:

merged = orders.merge(
    customers, on="customer_id", how="left",
    validate="many_to_one"
)

Esto permite muchos pedidos por cliente, pero exige que los identificadores de cliente de la derecha sean únicos. Una clave derecha repetida genera un MergeError. one_to_one exige unicidad en ambos lados; one_to_many la exige en el lado izquierdo. many_to_many permite repeticiones en ambos lados y no comprueba la unicidad.

Investiga las filas sin correspondencia

Una combinación externa completa con indicator=True añade _merge. Aquí sus recuentos son cuatro both, uno left_only y uno right_only. Son filas, no claves distintas: los pedidos repetidos pueden producir varias filas both para un cliente.

Para contar las claves distintas sin correspondencia del lado de los pedidos, usa m.loc[m["_merge"] == "left_only", "customer_id"].nunique(). Inspeccionar las filas puede revelar entradas ausentes en la tabla de consulta o texto inconsistente.

Controla los nombres y formatos de las claves

Si las claves tienen nombres distintos, usa left_on="customer_id", right_on="id". Ambas columnas clave siguen disponibles. Se pueden relacionar varias claves conjuntamente con on=["city", "year"]; ambas deben coincidir.

Los nombres compartidos que no son clave reciben _x y _y. Elige sufijos significativos como suffixes=("_order", "_ship") para que los orígenes queden claros.

Las claves necesitan tipos de datos compatibles y valores iguales. El número 1 puede coincidir con el número 1,0, pero las columnas clave enteras y de texto pueden generar un error de combinación. Convierte sus formatos de forma deliberada. «ana» y «Ana » son textos distintos; estandariza las mayúsculas y minúsculas y los espacios exteriores antes de combinar cuando identifiquen a la misma persona.

Las claves faltantes también necesitan inspección: pandas hace coincidir las claves faltantes de un lado con las del otro. Si ambos lados contienen varias filas de este tipo, esas coincidencias también pueden multiplicarse.

Un índice puede contener la clave que quieres relacionar. pandas usa esas etiquetas al combinar tablas, completar valores faltantes o sumar dos Series. La posición de la fila por sí sola no determina las coincidencias.

Combina por etiquetas de índice

left.join(right) hace coincidir los dos índices y usa por defecto una combinación por la izquierda. En cambio, merge usa por defecto una combinación interna. También puedes escribir left.merge(right, left_index=True, right_index=True) cuando ambas claves están en el índice.

Supón que stations tiene las etiquetas de índice A, B, C y las altitudes 120, 850, 15 m. Una tabla de mediciones tiene las etiquetas de índice de estación A, B, B, D. readings.join(stations) conserva cuatro filas y añade las altitudes 120, 850, 850 y NaN. Las dos mediciones de B reciben la altitud de B. Con how="inner", solo se conservan las tres mediciones de A y B.

Si las mediciones guardan los identificadores de estación en una columna ordinaria, usa readings.join(stations, on="station"). La columna izquierda coincide con el índice derecho. La forma equivalente con merge es readings.merge(stations, left_on="station", right_index=True, how="left").

Haz explícita la ubicación de la clave

set_index("station") mueve la columna de estación al índice. reset_index() la restablece como columna ordinaria. Esto permite elegir una estructura que facilite la inspección de la correspondencia. left.join([t1, t2]) puede combinar a la vez varias tablas que comparten etiquetas de índice.

Si ambas tablas combinadas contienen una columna que no es clave, como source, join genera un ValueError salvo que distingas los nombres. En pandas 3.1, escribe suffixes=("_left", "_right"); esto sustituye a los argumentos anteriores lsuffix y rsuffix. Los sufijos conservan ambas versiones sin decidir cuál es la fuente autorizada.

Completa valores faltantes desde una fuente de respaldo

a.combine_first(b) conserva los valores conocidos de a, rellena sus valores faltantes con los de b que tienen etiquetas coincidentes e incluye las etiquetas que solo se encuentran en b.

El resultado conserva 1 y 3 porque la primera fuente ya los conoce. Usa 20 para rellenar el valor faltante y añade la etiqueta d con 40. Invertir la llamada cambia qué fuente tiene prioridad. Esto es útil cuando una fuente principal de datos debe prevalecer sobre una fuente de respaldo, incluso cuando el orden de sus filas difiere.

Reconoce la alineación en las operaciones aritméticas

Sea x con a = 5 y b = 7; sea y con b = 1 y c = 2. x + y da b = 8, con resultados faltantes en a y c porque a cada uno le falta un operando. No suma el primer valor de x al primer valor de y.

x.add(y, fill_value=0) aporta cero para el lado faltante y produce a = 5, b = 8, c = 2. Usa esa regla cuando una contribución ausente deba contar como cero. La alineación por etiquetas es la misma idea organizadora detrás de estas operaciones, pero sus reglas para los valores son distintas: join añade columnas, combine_first rellena valores faltantes y la aritmética calcula con valores coincidentes.

Los archivos mensuales suelen contener más filas del mismo tipo de observación. La concatenación reúne esas partes en una sola tabla. Alinea las etiquetas del otro eje; no busca valores coincidentes de claves de cliente o pedido.

Apila filas y alinea columnas

pd.concat([jan, feb]) apila filas porque la opción predeterminada es axis=0. Supón que enero tiene tres viajes con las columnas trip y km, mientras que febrero tiene dos viajes con trip, km y note. El resultado tiene cinco filas y tres columnas. Las celdas faltantes de note para enero se convierten en NaN.

join="outer" es la opción predeterminada: conserva la unión de los nombres de columna. join="inner" conserva solo los nombres compartidos, por lo que el resultado tiene cinco filas y las dos columnas trip y km. Sigue incluyendo las cinco observaciones; la opción join controla el otro eje.

El orden de las columnas en las partes no determina la correspondencia. La determinan los nombres exactos. Si una parte usa km y la otra usa Km, el resultado contiene dos columnas parcialmente vacías. Cambia los encabezados antes de concatenar.

Decide qué deben significar las etiquetas de fila

Los índices originales se conservan por defecto. Con los índices iniciales 0, 1, 2 y 0, 1, el resultado repite las etiquetas 0 y 1. result.loc[0] selecciona dos filas. Usa ignore_index=True cuando esos números no tengan significado y quieras etiquetas nuevas de 0 a 4.

Cuando importa la identidad del origen, usa un nivel externo del índice:

result = pd.concat(
    [jan, feb], keys=["jan", "feb"], names=["month", "row"]
)

Ahora result.loc["feb"] selecciona las dos filas de febrero. keys conserva el origen dentro de un MultiIndex. En pandas 3, combinar keys con ignore_index=True genera un ValueError; elige etiquetas de origen o un índice simple nuevo para esa operación.

Coloca columnas una junto a otra

pd.concat([x, y], axis=1) alinea las filas por etiqueta de índice. Para x con a = 1, b = 2 e y con b = 3, c = 4, el resultado tiene las filas a, b, c. Falta la columna x en c y falta y en a. Con join="inner", solo queda b.

Comprueba el almacenamiento y reúne las partes de forma eficiente

Una columna que mezcla valores numéricos y texto puede convertirse al tipo object. Si los datos ordinarios int64 de NumPy adquieren un valor faltante, se convierten en float64; el tipo "Int64" de pandas que admite valores faltantes puede conservar enteros con <NA>. Ajusta los tipos de datos antes de combinar cuando la columna tenga un tipo definido.

DataFrame.append se eliminó en pandas 2.0. Para muchos archivos, reúne los DataFrames en una lista y llama a pd.concat una sola vez después del bucle. Reconstruir un resultado creciente en cada iteración copia repetidamente los datos acumulados y se vuelve lento.

Comprueba que la longitud de una concatenación por filas sea igual a la suma de las longitudes de entrada. Después inspecciona los nombres de columna, los recuentos de valores faltantes y los tipos de datos.

Un MultiIndex da a cada fila varias etiquetas. Una fila de ventas podría identificarse tanto por la ciudad como por el año, escritos como una tupla como ("Osaka", 2024). Cada etiqueta tiene un nivel, y el orden de esos niveles importa para la selección.

Crea y nombra el índice

df.set_index(["city", "year"]) mueve esas columnas al índice. pd.MultiIndex.from_product([["Lima", "Osaka"], [2024, 2025]], names=["city", "year"]) crea todas las combinaciones de las etiquetas proporcionadas. La concatenación con keys también añade un nivel.

Para los ejemplos, sales tiene estos pares de índice y valores:

Después de establecer los dos niveles del índice, df.index.names es ["city", "year"]. rename_axis(["town", "yr"]) cambia los nombres de los niveles sin cambiar sus valores.

Selecciona una etiqueta externa o una tupla completa

df.loc["Osaka"] selecciona ambas filas de Osaka. El nivel de ciudad seleccionado desaparece y deja 2024 y 2025 como índice. df.loc[("Lima", 2025), "sales"] selecciona una celda y devuelve 95.

Una sola etiqueta pasada a loc busca en el nivel más externo. Por tanto, df.loc[2024] busca una ciudad llamada 2024 y genera un KeyError en esta tabla. Para seleccionar un año en todas las ciudades, usa df.xs(2024, level="year"). Devuelve 120 para Osaka y 80 para Lima, con la ciudad como índice restante.

Para una selección más general, df.loc[pd.IndexSlice[:, 2025], :] conserva todas las ciudades en el año 2025. Los dos puntos en la primera posición significan todas las etiquetas de ese nivel; los dos puntos finales seleccionan todas las columnas.

Ordena antes de seleccionar intervalos

La selección por etiqueta exacta no necesita un índice ordenado globalmente, pero seleccionar un intervalo de etiquetas requiere una ordenación adecuada. Usa df.sort_index() antes de df.loc["Lima":"Osaka"]. Un MultiIndex sin ordenar puede generar un UnsortedIndexError para esa selección.

sort_index() ordena todos los niveles en su orden actual, de modo que primero van las ciudades y, dentro de cada ciudad, los años. sort_index(level="year") ordena por el nivel nombrado. swaplevel("city", "year") coloca el año en la posición externa; después usa sort_index() para agrupar y ordenar la nueva disposición. Intercambiar solo las posiciones de los niveles no ordena las filas.

Devuelve las etiquetas a las columnas

reset_index() restablece ambos niveles como columnas. reset_index(level="year") restablece solo el año y deja la ciudad como índice. Estas operaciones permiten preparar una tabla para combinarla o guardarla sin perder sus valores identificadores.

Las columnas también pueden tener varios niveles. Una reestructuración con valores de ventas y personal puede producir las etiquetas de columna ("sales", 2024) y ("staff", 2025). df["sales"] selecciona todas las columnas bajo la etiqueta de nivel superior de ventas.

Para obtener un total por ciudad, df.groupby(level="city")["sales"].sum() da Lima 175 y Osaka 255. Usa la agrupación para este resumen; el antiguo argumento sum(level="city") se eliminó en pandas 2.0.

stack y unstack cambian la ubicación de las etiquetas. Los valores conservan su combinación identificadora, pero la tabla puede mostrar combinaciones que no tenían ninguna observación.

Apila etiquetas de columna en el índice

Supón que un DataFrame ancho tiene las ciudades Osaka y Lima como índice y los años 2024 y 2025 como columnas. Osaka tiene los valores 120 y 135; Lima tiene 80 y 95. Nombra los ejes city y year para mantener visible su significado.

long = wide.stack() mueve las etiquetas de año a un nuevo nivel más interno del índice. Con estas columnas de un solo nivel, el resultado es una Series que contiene cuatro valores:

• ("Osaka", 2024) da 120.
• ("Osaka", 2025) da 135.
• ("Lima", 2024) da 80.
• ("Lima", 2025) da 95.

Las etiquetas de ciudad se repiten porque ahora cada ciudad tiene una fila por año. El apilamiento no ha sumado los valores ni creado mediciones adicionales.

Desapila un nivel del índice en columnas

long.unstack() mueve el nivel más interno del índice, el año, a las columnas y recupera la disposición ancha. long.unstack("city") mueve la ciudad en su lugar y produce años como filas y ciudades como columnas. Una posición numérica de nivel como unstack(0) puede seleccionar el mismo nivel, pero un nombre hace que la intención sea más fácil de entender.

Si la entrada tiene columnas jerárquicas, apilar un nivel puede dejar otro nivel como columnas. Para columnas como ("sales", 2024) y ("staff", 2024), stack("year") devuelve un DataFrame con columnas de ventas y personal. Apilar todos los niveles de columnas devuelve una Series.

Mantén visibles las combinaciones sin observaciones

Supón ahora que la Series larga no tiene una entrada para Lima en 2025. Al desapilar se crea una tabla rectangular de ciudad por año, por lo que se introduce NaN en esa posición. Los valores enteros ordinarios se convierten en flotantes cuando esta celda faltante requiere un marcador de valor faltante de tipo flotante.

unstack(fill_value=0) puede rellenar con cero una combinación que pasa a estar ausente. Úsalo solo si la ausencia significa cero, como la ausencia de ventas registradas en un conjunto completo de datos de ventas. Una observación faltante de un sensor es desconocida y debe seguir siendo un valor faltante.

stack() de pandas 3 conserva las celdas con valores faltantes. Por tanto, apilar la tabla incompleta de 2 por 2 devuelve cuatro entradas, incluida NaN. Añade .dropna() si solo quieres los tres valores conocidos. Eliminar valores faltantes cambia las combinaciones que siguen representadas, así que comprueba la longitud del resultado.

Resuelve primero las combinaciones duplicadas

Desapilar necesita un solo valor para cada combinación completa del índice. Dos entradas con la etiqueta ("Lima", 2025) compiten por la misma celda de salida y generan ValueError: Index contains duplicate entries, cannot reshape.

Usa long.index.duplicated() para inspeccionar las etiquetas completas repetidas, o comprueba las columnas clave correspondientes antes de establecer el índice. Decide si las filas son copias accidentales u observaciones separadas que deben combinarse. Eliminarlas o agregarlas es una decisión sobre los datos; unstack no elige una regla por ti.

En formato largo, las columnas identificadoras acompañan a una columna de valores. En formato ancho, las mediciones se distribuyen en columnas, por ejemplo, una columna por año. Elige la estructura que facilite la siguiente tarea: las tablas largas son adecuadas para filtrar y agrupar, mientras que las tablas anchas facilitan las comparaciones lado a lado.

Convierte pares únicos en celdas

Una tabla larga con las columnas city, year y sales se convierte en ancha con df.pivot(index="city", columns="year", values="sales"). Las etiquetas de ciudad forman las filas, los años forman las columnas y las ventas rellenan las celdas. Es equivalente a df.set_index(["city", "year"])["sales"].unstack().

Las ventas de Osaka en 2024 y 2025, de 120 y 135, se convierten en dos celdas de una fila. Los valores de Lima, 80 y 95, forman la segunda fila. Intercambiar los argumentos index y columns transpone esta disposición. Omitir values convierte todas las columnas de datos restantes y puede crear columnas jerárquicas, como un nivel de ventas y otro de personal por encima de los años.

Decide si las repeticiones son errores u observaciones

pivot reorganiza valores y no puede combinarlos. Dos filas de Lima para 2025 necesitarían dos valores en una celda de salida, por lo que generan un ValueError. Cuenta los pares repetidos con df.duplicated(subset=["city", "year"]).sum().

Si deben combinarse observaciones separadas, usa pivot_table con una agregación elegida. Para los valores 95 y 105 de Lima en 2025, su media predeterminada da 100,0. Con aggfunc="sum", la celda es 200. Si cada par debía aparecer una sola vez, conserva pivot para que revele un error de datos en lugar de resumirlo sin avisar.

Convierte columnas de mediciones en filas

Supón que un CSV proporciona las columnas city, 2023, 2024 y 2025. Los valores de Osaka son 110, 120, 135; los de Lima son 70, 80, 95. Convierte las columnas de años a formato largo:

long = wide.melt(
    id_vars="city", var_name="year", value_name="sales"
)

id_vars permanece en su lugar y se repite. Cada etiqueta de columna de medición se convierte en un valor de año; cada celda se convierte en un valor de ventas. Dos filas y tres columnas de medición producen seis filas largas, incluida una como Osaka, «2023», 110. Las celdas de medición faltantes también se convierten en filas salvo que las elimines después.

Como estas etiquetas de columna procedían de texto CSV, los años resultantes son texto. Usa long["year"] = long["year"].astype(int) antes de hacer operaciones aritméticas con ellos. Las etiquetas de columna enteras de entrada ya darían valores de año enteros.

Controla qué se convierte y recupera la forma

value_vars=["2024", "2025"] limita la conversión a esas columnas. Olvidar id_vars puede convertir los nombres de ciudades a formato largo en la misma columna de valores que las mediciones. Distingue siempre los identificadores de las columnas que contienen valores.

Sin nombres explícitos, la columna de valores se llama value. La columna de variables hereda wide.columns.name o se llama variable si ese nombre está vacío. Los valores explícitos de var_name y value_name facilitan el uso del resultado.

Convierte las seis filas de nuevo a formato ancho con index="city", columns="year", values="sales" para recuperar las tres columnas de años. Después de la conversión, la ciudad es el índice y el eje de columnas se llama año. reset_index() restablece la ciudad como columna y rename_axis(columns=None) elimina el nombre del eje de columnas. Verifica tanto la forma como las etiquetas antes de combinar o guardar la tabla.