Series y DataFrames de pandas: primeros pasos

Una Series mantiene una secuencia de valores junto con sus etiquetas. Esas etiquetas dan significado a los valores: una medición de lluvia corresponde a un día y una población corresponde a una ciudad. Importa pandas y NumPy con sus nombres cortos habituales.

import pandas as pd
import numpy as np
rain = pd.Series([4.5, 3.0, 6.2],
                 index=["Mon", "Tue", "Wed"], name="rain_mm")

Lee valores y etiquetas

Los valores son 4,5; 3,0 y 6,2; el índice es Mon, Tue y Wed. Sin index=, pandas proporciona las etiquetas 0, 1 y 2. Un diccionario proporciona ambos a la vez: pd.Series({"Lima": 10, "Oslo": 5, "Pune": 7}) toma sus etiquetas de las claves, en el orden del diccionario.

Los atributos describen la Series sin paréntesis: rain.index contiene las etiquetas, rain.dtype es float64, rain.name es "rain_mm" y rain.size es 3. Usa rain.to_numpy() cuando necesites un arreglo de NumPy. El atributo más antiguo .values devuelve distintos tipos de arreglo según el tipo de datos; los datos de texto pueden dar un arreglo de pandas.

Un tipo de datos indica a pandas qué clase de valores almacena. Los tipos habituales son int64 para enteros, float64 para decimales, bool para True/False, str para texto y datetime64 para fechas y horas. pandas 3 infiere el texto como str; los ejemplos antiguos suelen mostrar object.

Trabaja con toda la Series

Para s = pd.Series([10, 20, 30], index=["a", "b", "c"]), s * 2 produce los valores 20, 40 y 60. s > 15 produce False, True y True. Ambos conservan las etiquetas. Estas operaciones son vectorizadas: una expresión actúa sobre toda la Series sin un bucle de Python.

Busca una etiqueta con s["b"], que da 20. Busca una posición con s.iloc[0], que da 10. La expresión "b" in s comprueba el índice; 20 in s es False. Incluso un entero entre corchetes es una etiqueta: con el índice [2, 0, 1], s[0] significa la etiqueta 0, no la primera entrada. Con etiquetas de texto, s[0] genera KeyError en pandas 3.

Empareja etiquetas en operaciones aritméticas

a = pd.Series([1, 2, 3], index=["x", "y", "z"])
b = pd.Series([10, 20, 30], index=["y", "z", "w"])
a + b

La etiqueta compartida y combina 2 y 10 para dar 12,0; z combina 3 y 20 para dar 23,0. Las etiquetas w y x aparecen en una sola entrada, por lo que reciben NaN. El resultado incluye las cuatro etiquetas. Sumar según la posición visual de las filas daría incorrectamente 11, 22 y 33.

Usa a.add(b, fill_value=0) cuando un valor ausente deba contar como cero. Sus resultados son w 30,0, x 1,0, y 12,0 y z 23,0. Entre los métodos relacionados están sub, mul y div.

Reconoce los valores faltantes

Un valor faltante de coma flotante o str usa NaN; una fecha u hora faltante usa NaT; un entero faltante en un tipo que admite valores faltantes usa <NA>. pd.Series([1, None, 3]) pasa a ser float64 y muestra 1,0, NaN y 3,0, porque el tipo habitual int64 no puede contener NaN.

Un DataFrame es una tabla bidimensional. Cada fila registra una observación, como un pedido; cada columna contiene una variable, como una cantidad. Las columnas pueden tener distintos tipos de datos, pero comparten el mismo índice de filas.

Crea una tabla a partir de datos de Python

df = pd.DataFrame({
    "product": ["Notebook", "Desk lamp", "Pen set", "Mug"],
    "quantity": [3, 1, 2, 4],
    "unit_price": [2.50, 18.00, 4.75, 6.00]
})

Cada clave del diccionario se convierte en un nombre de columna; cada lista proporciona los valores de esa columna. Las listas deben tener la misma longitud para que cada fila tenga un lugar en cada columna. Aquí las etiquetas del índice van de 0 a 3. Las listas de distinta longitud generan un ValueError.

Una lista de diccionarios, en cambio, proporciona un diccionario por fila. pd.DataFrame([{"a": 1, "b": 2}, {"a": 3, "c": 4}]) crea las columnas a, b y c. La b que falta en la segunda fila y la c que falta en la primera se convierten en NaN, por lo que esas columnas usan float64. Un arreglo bidimensional de NumPy también puede proporcionar valores, con columns=[...] para nombrar las columnas.

Interpreta las dimensiones de la tabla

df.shape es (4, 3): cuatro filas y tres columnas, en ese orden. len(df) es 4, mientras que df.size es 12 porque cuenta las celdas. df.index contiene las etiquetas de fila, df.columns contiene las etiquetas de columna y df.dtypes da un tipo de datos por columna. Estos son atributos: df.shape() intenta llamar a una tupla y genera TypeError. df.T intercambia filas y columnas.

Conserva una Series o conserva una tabla

La lista interior solicita una colección de columnas. Sin ella, df["product", "unit_price"] proporciona una sola clave de tipo tupla, que no coincide con ninguno de los nombres de columna habituales y genera KeyError.

Los corchetes también funcionan cuando los nombres contienen espacios o coinciden con métodos. La notación con punto, como df.quantity, solo funciona para nombres adecuados. Una columna llamada size necesita df["size"], porque df.size significa el número de celdas de la tabla. Crea también las columnas con corchetes: df["total"] = 5 añade una columna, mientras que df.total = 5 no lo hace.

Elige un eje

Para numbers = pd.DataFrame({"a": [1, 2], "b": [3, 4]}), numbers.sum() suma a lo largo de las filas y da a 3 y b 7. Este es axis=0, también llamado "index". numbers.sum(axis=1) suma a lo largo de cada fila y da 4 y 6; este eje también se llama "columns". Identifica primero el resultado que necesitas: un total por columna o un total por fila.

Al extraer una fila se crea una Series cuyas etiquetas son los nombres de las columnas. Esa Series necesita un tipo de datos capaz de contener todas las celdas de la fila. Una fila que mezcla enteros y números de coma flotante pasa a ser float64; una fila que mezcla texto y números pasa a ser object. Las columnas originales conservan sus tipos por separado.

Las etiquetas de fila pueden tener significado, como un número de pedido, o simplemente etiquetar las filas actuales. Elegir un índice útil facilita la interpretación de las búsquedas y los resultados posteriores. Cambiar las etiquetas devuelve una tabla nueva, así que conserva el resultado con una asignación.

Mueve un identificador al índice

orders = pd.DataFrame({
    "order_id": [1001, 1002, 1003],
    "product": ["Notebook", "Desk lamp", "Pen set"],
    "unit_price": [2.50, 18.00, 4.75]
})
orders_by_id = orders.set_index("order_id")

La tabla original tiene un RangeIndex predeterminado: 0, 1 y 2. La tabla nueva tiene las etiquetas 1001, 1002 y 1003. order_id ha salido de las columnas y ha pasado al índice. orders_by_id.loc[1002] identifica ahora la fila de Desk lamp por su identificador.

Llamar a orders.set_index("order_id") sin guardar su resultado deja orders sin cambios. La reasignación, como orders = orders.set_index("order_id"), conserva la nueva estructura. En pandas 3.1, inplace= está obsoleto para estos métodos que cambian etiquetas y para la ordenación; usa una asignación.

Devuelve las etiquetas a una columna

orders_by_id.reset_index() restablece order_id como columna normal y proporciona un RangeIndex nuevo. Un índice sin nombre se convierte en una columna llamada index. Esto conserva la identidad anterior de las filas.

reset_index(drop=True) descarta las etiquetas anteriores. Para un índice [10, 20, 30], reset_index() sin más conserva esos números en una columna index; reset_index(drop=True) los pierde y usa 0, 1 y 2. Después de filtrar u ordenar, decide si las etiquetas anteriores son útiles antes de descartarlas. Volver a numerar el índice no cambia los valores de los datos ni deshace una ordenación.

Cambia o elimina etiquetas

renamed = orders.rename(columns={"unit_price": "price"})
short = orders.drop(columns=["product"])
remaining = orders.drop(index=[0, 1])

rename establece una correspondencia entre etiquetas antiguas y nuevas y conserva los nombres que no se enumeran. Por defecto, un nombre antiguo mal escrito se ignora, así que inspecciona .columns si parece que un cambio de nombre no ha hecho nada. Para sustituir todos los nombres de columna, asigna una lista completa a orders.columns; su longitud debe coincidir con el número de columnas.

drop(columns=...) elimina columnas; drop(index=...) elimina filas por etiqueta. Una etiqueta ausente genera KeyError. Después de ordenar, la etiqueta 0 puede dejar de ser la primera fila: eliminarla sigue quitando la fila con etiqueta 0.

Selecciona una lista para elegir el orden de las columnas: orders = orders[["order_id", "unit_price", "product"]]. Las columnas ausentes de esa lista se eliminan del resultado.

Comprueba que un identificador identifica realmente una fila

Las etiquetas del índice pueden repetirse. Comprueba orders_by_id.index.is_unique antes de tratarlas como identificadores únicos. Si la etiqueta 1002 aparece dos veces, .loc[1002] devuelve ambas filas como DataFrame. Con etiquetas únicas, la misma búsqueda por una sola etiqueta devuelve una Series.

Un índice significativo también mejora los resúmenes. En una tabla meteorológica indexada por día, weather["temp_c"].idxmax() informa de un día como "Thu"; con un índice predeterminado informa de un número de fila.

Un CSV almacena una tabla como texto: los registros ocupan líneas y un delimitador separa los campos. La primera línea suele contener los nombres de las columnas. Cargar el archivo correctamente implica identificar tanto su estructura como el significado de sus valores.

Carga la tabla de pedidos

orders = pd.read_csv("orders.csv")

Una ruta relativa se resuelve a partir del directorio de trabajo actual de Python. Una ubicación incorrecta genera FileNotFoundError. También se puede pasar una ruta absoluta o una URL a read_csv.

Los ejemplos usan este archivo. La última fila tiene un campo de cantidad vacío.

order_id,date,product,category,quantity,unit_price
1001,2026-03-02,Notebook,Stationery,3,2.50
1002,2026-03-02,Desk lamp,Home,1,18.00
1003,2026-03-03,Pen set,Stationery,2,4.75
1004,2026-03-04,Mug,Home,4,6.00
1005,2026-03-04,Backpack,Bags,1,35.00
1006,2026-03-05,Notebook,Stationery,,2.50

Con las opciones predeterminadas, el resultado tiene forma (6, 6) y etiquetas de índice de 0 a 5. pandas infiere los tipos: order_id es int64, unit_price es float64 y quantity también pasa a ser float64 porque su campo vacío se convierte en NaN. Las demás columnas, incluida date, son str. Una cadena que parece una fecha sigue siendo texto hasta que se interpreta como tal.

Ajusta las opciones a la estructura del archivo

Para un archivo cuyas líneas son a;b, 1,5;2 y 3,0;4, usa pd.read_csv("file.csv", sep=";", decimal=","). La columna a contiene entonces 1,5 y 3,0. Usar la coma como separador predeterminado produce una columna llamada a;b, una señal de que debes comprobar el delimitador.

index_col="order_id" convierte esa columna en el índice de filas durante la carga. thousands="," lee un campo como "1,200" como 1200; en un archivo separado por comas, el campo debe delimitarse con comillas CSV para que su coma interna no sea otro delimitador.

Conserva el significado al inferir tipos

Los códigos como "001" son identificadores, no cantidades. dtype={"id": str} conserva sus ceros iniciales. Si pandas los convierte primero en 1, convertir ese número de nuevo a texto no permite recuperar cuántos ceros contenía el archivo.

Los campos vacíos y los marcadores habituales como NA, N/A, NULL, NaN y None son valores faltantes por defecto. Añade un marcador especial de un archivo con na_values=["-"]. Estas son reglas de carga, así que comprueba las convenciones del archivo cuando un código parezca un marcador de valor faltante.

Usa parse_dates=["date"] para leer las fechas del ejemplo como fechas y horas. En pandas 3 estas fechas usan resolución de microsegundos, datetime64[us]. UTF-8 es la codificación de texto predeterminada. Un UnicodeDecodeError indica que debes comprobar la codificación del archivo y proporcionar la opción correspondiente, como encoding="latin-1".

Una lectura correcta significa que pandas pudo interpretar el archivo. No demuestra que las columnas, los tipos y los valores faltantes coincidan con lo que la tabla debe representar. Inspecciona el DataFrame nuevo antes de hacer cálculos con él.

Comprueba las filas visibles y las dimensiones

orders.head(3)
orders.tail()
orders.shape
orders.columns.tolist()

head() muestra cinco filas por defecto; head(3) muestra tres. tail() comprueba el final, donde una exportación puede contener registros distintos. sample(3, random_state=0) da una muestra aleatoria reproducible de tres filas. En un cuaderno interactivo, la expresión final de una celda se muestra automáticamente; en otros entornos, usa print.

El archivo de pedidos debe contener seis filas y seis columnas. Una vista previa debe mostrar columnas con nombre y el primer pedido como datos. Si el primer registro aparece entre los nombres de las columnas, probablemente el archivo no tenga encabezado y necesite header=None. Si todo ocupa una sola columna ancha, comprueba sep.

Los nombres de columnas deben coincidir exactamente, incluidas las mayúsculas, las minúsculas y los espacios. orders["Product"] falla cuando el nombre es product. Inspeccionar la lista facilita la detección de espacios finales. orders.columns = orders.columns.str.strip() elimina los espacios en los extremos de los nombres del encabezado.

Interpreta la estructura con info

orders.info() muestra el rango del índice, el nombre de cada columna, el recuento de valores presentes, el tipo de datos y el uso de memoria. En el ejemplo de seis filas, quantity tiene cinco valores no nulos; las demás columnas tienen seis cada una. Los tipos son dos columnas de coma flotante, una columna entera y tres columnas str. orders.dtypes proporciona una lista compacta de tipos.

Una columna de aspecto numérico con tipo str merece una inspección: un elemento como "unknown", una unidad como "12 kg" o un separador de millares no tratado pueden impedir la inferencia numérica. Las fechas también permanecen como texto salvo que se interpreten. Decide el tipo necesario según el significado de la columna, no solo por su apariencia en una vista previa.

Cuenta valores faltantes y repetidos

orders.isna().sum()
orders.isna().any(axis=1).sum()
orders.nunique()

isna() crea una tabla booleana: True marca una celda faltante. La suma a lo largo de cada columna cuenta esas celdas. Quantity tiene un valor faltante y todas las demás columnas tienen cero. Para contar las filas afectadas, .any(axis=1) comprueba primero si cada fila tiene algún valor faltante y luego .sum() cuenta esas filas. En cambio, sumar todos los recuentos de columnas podría contar una fila varias veces.

nunique() cuenta los valores presentes distintos: los pedidos tienen seis identificadores, cuatro fechas, cinco productos, tres categorías, cuatro cantidades y cinco precios. Compara el recuento de identificadores con el número de filas para comprobar su unicidad, junto con su recuento de valores faltantes. orders.duplicated(subset="product") marca la segunda fila de Notebook, con etiqueta 5, como repetida. Un producto repetido es válido aquí; un identificador de pedido repetido requeriría investigación.

Consulta una vista general numérica rápida

orders.describe() informa del recuento, la media, la desviación estándar, el mínimo, los cuartiles y el máximo de las columnas numéricas. El recuento de quantity es cinco, por lo que su media resume cinco cantidades registradas. Comprueba también los rangos y unidades plausibles, además de los tipos: una columna puede ser numérica y contener aun así un error de entrada. Al revisar una carga nueva, considera conjuntamente el número observado de filas y columnas, los tipos, los recuentos de valores faltantes y la comprobación de identificadores.

El tipo de datos de una columna determina qué operaciones tienen sentido. Una columna de texto que contiene "12" sigue almacenando texto; no se puede calcular su media como si fuera una columna numérica. Convierte los datos de forma deliberada y asigna el resultado de nuevo a la tabla.

Elige entre conversión estricta y coerción

astype convierte una Series a un tipo indicado, como int, float, str o "Int64". Falla cuando un valor no puede representarse en el tipo solicitado.

raw = pd.Series(["12", "7", "n/a", "3.5"])
numeric = pd.to_numeric(raw, errors="coerce")

raw.astype(float) genera ValueError al llegar a "n/a". Con errors="coerce", los valores de salida son 12,0; 7,0; NaN y 3,5. El elemento que falla pasa a ser un valor faltante en lugar de detener la conversión. Compara raw.isna().sum() con numeric.isna().sum(): se pasó de cero valores faltantes a uno, lo que identifica un valor que necesita revisión.

La coerción es una política de conversión, no una prueba de que cada nuevo valor faltante sea inofensivo. Usa los recuentos anteriores y posteriores para detectar pérdidas. Guarda la conversión en una variable o columna nueva cuando el texto original sea útil para rastrear un valor que falló.

Conserva los números enteros con valores faltantes

La columna quantity de los pedidos contiene números enteros y un NaN, por lo que es float64. El uso habitual de astype(int) falla porque NaN no tiene una representación entera ordinaria.

orders["quantity"] = orders["quantity"].astype("Int64")

La I mayúscula importa: el tipo Int64 que admite valores faltantes conserva el valor ausente como <NA> y almacena los valores conocidos como números enteros. Esta elección es adecuada para recuentos con entradas faltantes. No convierte una cantidad realmente fraccionaria en un recuento entero válido.

Los separadores de millares en el texto también requieren tratamiento. pd.Series(["1,200", "950"]).str.replace(",", "").astype(int) produce 1200 y 950. Cuando el archivo usa esa convención, thousands="," puede gestionarla durante la lectura.

Convierte texto de fechas

orders["date"] = pd.to_datetime(orders["date"])
orders["date"].dt.day_name()

La conversión permite usar .dt.year, .dt.month, .dt.day y .dt.day_name(). Para las seis fechas de los pedidos, los nombres de los días son Monday, Monday, Tuesday, Wednesday, Wednesday y Thursday. Ejecutar pd.to_datetime(orders["date"]) por sí solo produce una Series convertida, pero deja la columna original como texto. La asignación es lo que conserva el resultado.

Almacena categorías repetidas

orders["category"].astype("category") almacena las etiquetas repetidas mediante un conjunto de categorías permitidas. En tablas grandes esto suele ahorrar memoria. Asigna el resultado para conservarlo, igual que con otras conversiones.

El tipo de datos categórico cambia algunas operaciones. Sus categorías no están ordenadas por defecto, por lo que min() y max() generan TypeError. El método value_counts() de una columna categórica también enumera las categorías conocidas ausentes de una selección filtrada con recuento cero. Elegir el tipo categórico es útil para etiquetas repetidas, pero supone un cambio tanto de comportamiento como de almacenamiento.

Las etiquetas permiten solicitar una fila o columna por su significado. Con loc, un número de pedido identifica una fila incluso si la tabla se ha ordenado. La selección tiene una parte de filas seguida de una parte de columnas: df.loc[rows, columns].

Parte de un índice significativo

El archivo de pedidos tiene seis filas con identificadores del 1001 al 1006. Crea orders_by_id = orders.set_index("order_id"). Sus columnas, en orden, son date, product, category, quantity y unit_price. Las etiquetas de fila son números de pedido, no posiciones de 0 a 5.

orders_by_id.loc[1003]
orders_by_id.loc[1004, "product"]

La primera expresión devuelve el pedido 1003 como una Series: fecha "2026-03-03", producto "Pen set", categoría "Stationery", cantidad 2,0 y precio 4,75. La Series se llama 1003. La segunda devuelve una celda, "Mug".

Una etiqueta ausente genera KeyError. orders_by_id.loc[0] falla: tener una primera fila en la posición 0 no crea una etiqueta 0.

Selecciona colecciones de etiquetas

orders_by_id.loc[[1001, 1005], ["product", "unit_price"]]

Las listas seleccionan etiquetas en el orden solicitado. Esto da dos filas y dos columnas: Notebook a 2,5 y después Backpack a 35,0. Una lista conserva un resultado con forma de tabla incluso cuando contiene una sola etiqueta: .loc[[1003]] es un DataFrame de una fila.

Dos puntos por sí solos significan todas las etiquetas de ese eje. Omitir el selector de columnas también solicita todas las columnas.

Incluye ambos extremos de un segmento por etiquetas

orders_by_id.loc[1002:1004, "product":"quantity"]

En este índice ordenado, las filas son 1002, 1003 y 1004. El segmento de columnas incluye product, category y quantity. Tanto la etiqueta final de fila como la de columna están incluidas, por lo que la forma es (3, 3). Aplicar aquí la regla habitual de Python que excluye el extremo final omitiría una fila y una columna deseadas.

Las etiquetas sobreviven a la ordenación

Un índice predeterminado puede ocultar la distinción entre etiqueta y posición. Supón que al ordenar puntuaciones se obtienen las etiquetas de fila 3, 0, 2, 1, 4. .loc[0] sigue seleccionando la etiqueta 0, ahora en la segunda fila mostrada. .iloc[0] selecciona la primera fila mostrada, con etiqueta 3. La ordenación mueve cada fila con su etiqueta; no vuelve a numerar el índice sin avisar.

Combina una condición con la selección de columnas

El selector de filas puede ser una Series booleana:

orders.loc[orders["unit_price"] > 5, ["product", "unit_price"]]

Esto conserva Desk lamp a 18,0, Mug a 6,0 y Backpack a 35,0, y devuelve solo las dos columnas solicitadas. La máscara decide qué filas cumplen la condición; la lista de columnas decide qué mostrar. La misma forma de dos ejes puede identificar celdas para actualizarlas colocando la selección en el lado izquierdo de una asignación.

Usa iloc cuando una solicitud se refiera a dónde se encuentra una fila o columna: las primeras tres filas, la última columna o una celda concreta mostrada. Sus selectores son posiciones enteras, independientes de las etiquetas del índice.

Cuenta desde cero

orders.iloc[0] selecciona la primera fila y orders.iloc[-1] la última. Una posición negativa cuenta hacia atrás desde el final. Dos posiciones seleccionan una celda: orders.iloc[2, 2] es "Pen set" en la tabla de pedidos original, donde product está en la posición de columna 2.

La tabla indexada orders_by_id tiene las columnas date, product, category, quantity y unit_price. Mover order_id al índice cambió las posiciones de sus columnas, por lo que product está ahora en la posición 1. El código basado en posiciones depende de esta estructura.

Detente antes del extremo final del segmento

orders_by_id.iloc[1:3, 0:2]

Las posiciones de fila seleccionadas son 1 y 2, que contienen los pedidos 1002 y 1003. Las posiciones de columna son 0 y 1, date y product. La posición 3 y la columna 2 se excluyen, lo que da la forma (2, 2). Un inicio vacío significa el principio; un final vacío significa el final.

Las listas solicitan posiciones concretas, incluida una mezcla de posiciones positivas y negativas. orders.iloc[[0, -1], [2, 5]] selecciona product y unit_price del primer y el último pedido. Ambos son Notebook a 2,5.

Predice la forma del resultado

Un escalar selecciona un elemento a lo largo de un eje y elimina esa dimensión. Un segmento o una lista conserva ese eje, incluso si selecciona un solo elemento. Esto importa cuando la siguiente operación espera una tabla en lugar de una Series.

Gestiona el final de una tabla

La tabla de pedidos de seis filas tiene posiciones de fila no negativas válidas de 0 a 5. orders.iloc[10] genera IndexError. Un segmento puede extenderse más allá de la tabla: orders.iloc[4:100] simplemente devuelve las dos últimas filas. Una posición individual inexistente es una solicitud de elemento no válida, mientras que un segmento describe un intervalo que se recorta a las filas disponibles.

Elige etiquetas o posiciones de forma deliberada

Para una sola celda, at usa etiquetas e iat usa posiciones. orders.at[2, "product"] y orders.iat[2, 2] dan "Pen set" antes de cambiar el orden de las filas.

Elige loc cuando conozcas un identificador o el significado de una columna. Elige iloc cuando importe la propia ubicación. Para combinar las primeras filas con un nombre de columna, orders.columns.get_loc("quantity") devuelve su posición, 4, lo que permite usar orders.iloc[0:3, 4].

Los corchetes por sí solos pueden cambiar de función: orders["product"] selecciona una columna, pero orders[2:4] selecciona un segmento de filas en las posiciones 2 y 3. Usar loc e iloc explícitamente hace que esa elección sea más fácil de leer.

El filtrado selecciona observaciones que responden a una pregunta, como qué pedidos pertenecen a Home y cuestan más de 10 por artículo. Primero crea una máscara booleana, una Series con un True o False por fila. Después úsala para seleccionar las filas coincidentes.

Crea y aplica una máscara

is_stationery = orders["category"] == "Stationery"
stationery = orders[is_stationery]

La máscara es True, False, True, False, False y True. La selección conserva las etiquetas 0, 2 y 5, correspondientes a los pedidos 1001, 1003 y 1006. El filtrado conserva esas etiquetas; no vuelve a numerarlas. reset_index(drop=True) proporciona etiquetas consecutivas si se necesitan.

Los operadores de comparación incluyen ==, !=, <, <=, > y >=. Las comparaciones de texto son exactas: "home" es distinto de "Home", y los espacios también pueden impedir una coincidencia.

Combina condiciones fila por fila

is_home = orders["category"] == "Home"
is_expensive = orders["unit_price"] > 10
orders[is_home & is_expensive]

Solo Desk lamp cumple la condición: su categoría es Home y su precio es 18,0. Mug es de Home, pero cuesta 6,0. Backpack cuesta 35,0, pero pertenece a Bags.

Al escribir comparaciones directamente, coloca cada una entre paréntesis:

orders[(orders["category"] == "Home") &
       (orders["unit_price"] > 10)]

Usa & para «y», | para «o» y ~ para «no». Los paréntesis mantienen unida cada comparación antes de que pandas combine las máscaras. Sin ellos, las reglas de precedencia de Python pueden intentar combinar una cadena y una Series con & y generar TypeError.

Los operadores and, or y not de Python esperan un solo valor de verdad, no una columna de valores de verdad. Usarlos con máscaras genera el ValueError de valor de verdad ambiguo. Un simple if orders["quantity"] > 1: tiene el mismo problema. Usa .any() para preguntar si alguna fila coincide, o .all() para preguntar si todas coinciden.

Cuenta coincidencias y proporciones

is_stationery.sum() es 3 porque True cuenta como 1 y False como 0. is_stationery.mean() es 0,5, la fracción de los seis pedidos que cumplen la condición. Multiplica por 100 para expresarla como 50 %.

Trata explícitamente los valores faltantes

Con la columna quantity original de tipo float64, las comparaciones que incluyen NaN dan False salvo !=, que da True. quantity >= 1 conserva cinco filas; quantity < 1 no conserva ninguna. La cantidad vacía no está en ninguna de las dos selecciones. Sin embargo, quantity != 3 incluye esa fila vacía, por lo que «distinto de» no significa «conocido y diferente».

Después de convertir al tipo Int64 que admite valores faltantes, la comparación con <NA> produce <NA>, y el filtrado excluye esas filas. Usa isna() o notna() cuando la pregunta se refiera a valores faltantes.

Para seleccionar columnas además de filas, usa orders.loc[is_home, "product"]. Devuelve Desk lamp y Mug. Una máscara con nombre puede reutilizarse para inspeccionar, contar y actualizar el mismo conjunto de filas.

Algunos filtros tienen formas habituales: pertenencia a una lista, un intervalo numérico, un valor faltante o un fragmento de texto. Los métodos auxiliares expresan estas pruebas directamente y siguen produciendo máscaras que pueden combinarse con otras condiciones.

Comprueba pertenencia e intervalos

orders[orders["category"].isin(["Home", "Bags"])]
orders[orders["unit_price"].between(4.75, 18)]

isin encuentra coincidencias con cualquiera de los valores enumerados. La primera selección contiene los pedidos 1002, 1004 y 1005. ~orders["category"].isin(["Home"]) invierte la pertenencia y conserva las filas de Stationery y Bags. Una expresión in de Python no crea esta máscara de pertenencia fila por fila.

between incluye ambos extremos por defecto. La segunda selección incluye Desk lamp a 18,0, Pen set a 4,75 y Mug a 6,0. Usa inclusive="neither" para excluir ambos extremos, "left" para incluir solo el extremo inferior o "right" para incluir solo el superior. Elige la regla de los extremos según la pregunta planteada.

Encuentra entradas faltantes y presentes

orders[orders["quantity"].isna()] conserva el pedido 1006. notna() hace lo contrario y conserva las cantidades registradas. No compruebes la igualdad con np.nan: NaN es distinto incluso de sí mismo, por lo que quantity == np.nan no encuentra la fila faltante.

Busca dentro del texto

orders[orders["product"].str.contains("note", case=False, na=False)]

str.contains comprueba si cada valor de texto contiene una coincidencia. Ignorar mayúsculas y minúsculas permite encontrar ambas filas de Notebook. na=False hace que el texto faltante cuente como ausencia de coincidencia. Por defecto, la búsqueda trata el patrón como una expresión regular; para un fragmento literal de texto con puntuación, regex=False evita interpretar esa puntuación como un patrón. str.startswith y str.endswith comprueban el principio y el final.

Escribe un filtro como consulta

orders.query("quantity >= 2 and unit_price < 5")

Esto conserva los pedidos 1001 y 1003. Dentro de una cadena de query, los nombres de columna representan columnas y se permiten and, or y not. La cadena es una expresión de consulta de pandas; no tiene la misma sintaxis que combinar Series directamente en Python normal.

Una variable de Python necesita @:

limit = 5
orders.query("unit_price > @limit")

El resultado contiene Desk lamp, Mug y Backpack. Un nombre de columna que contiene un espacio necesita acentos graves dentro de la consulta, como en orders.query("`unit price` > 5").

La misma pregunta puede escribirse como una máscara, una llamada a un método auxiliar o una consulta. Prefiere la forma que muestre claramente la regla. Para un intervalo, between reúne los límites y la regla de inclusión. Para un conjunto de etiquetas permitidas, isin evita repetir pruebas de igualdad. Cuando un filtro se comporte de forma inesperada, inspecciona la máscara y los valores exactos de la columna antes de cambiar la condición.

Una actualización debe dirigirse a la tabla que quieres cambiar. En pandas 3, una selección se comporta como un objeto separado bajo el mecanismo de copia al escribir, por lo que cambiar un objeto seleccionado no cambia su tabla de origen.

Coloca todo el destino en una asignación con loc

sale = orders.copy()
is_home = sale["category"] == "Home"
sale.loc[is_home, "unit_price"] *= 0.9

La máscara selecciona dos filas de Home. El selector de columna apunta a sus precios. La multiplicación por 0,9 conserva el 90 % de cada precio y reduce 18,00 a 16,20 y 6,00 a 5,40. Las demás filas no cambian. La forma desarrollada lee la misma selección en el lado derecho y asigna los valores multiplicados en el izquierdo.

Aquí sale es una tabla separada que se usa para cambiar precios, mientras que orders queda disponible para comparar. Para actualizar la tabla original, coloca orders.loc[...] en el lado izquierdo de la asignación.

Evita la asignación encadenada

orders[orders["category"] == "Home"]["unit_price"] = 0

Esto usa dos pasos de indexación. El primero produce un objeto seleccionado; el segundo asigna valores a ese objeto. En pandas 3 nunca actualiza orders, y una advertencia ChainedAssignmentError señala el problema. El mismo problema afecta a orders["unit_price"][1] = 0.

Usa orders.loc[orders["category"] == "Home", "unit_price"] = 0 cuando el cambio deseado sea en la tabla original. La tabla, las filas coincidentes y la columna se especifican en una sola asignación.

Comprende las tablas seleccionadas

Después de home = orders[orders["category"] == "Home"], cambiar home["unit_price"] solo cambia home. Los cambios posteriores en orders tampoco cambian home. Los objetos pueden compartir almacenamiento internamente hasta que sea necesario escribir, pero sus valores visibles se comportan de forma independiente.

Los ejemplos antiguos de pandas pueden mostrar SettingWithCopyWarning y usar .copy() después de la selección para evitar actualizaciones inciertas. pandas 3 eliminó esa advertencia y hace que la independencia de las selecciones sea consistente. Un .copy() explícito sigue siendo útil para expresar la intención, pero una selección ya se comporta de forma independiente ante las actualizaciones.

Empareja los valores del lado derecho con el destino

Un escalar rellena todas las celdas seleccionadas. Una lista necesita exactamente un valor por fila seleccionada y las rellena en el orden de selección. Una Series se alinea por etiqueta de índice:

new_prices = pd.Series([16.2, 5.4], index=[1, 3])
sale.loc[is_home, "unit_price"] = new_prices

Las filas de Home tienen las etiquetas 1 y 3, por lo que reciben 16,2 y 5,4. Si una etiqueta seleccionada faltara en la Series, su valor asignado sería NaN; las filas fuera de la selección permanecerían sin cambios. Que las longitudes sean iguales no garantiza por sí solo que los valores de la Series se emparejen con las filas.

Inspecciona sale.loc[is_home, "unit_price"] después del cambio y compáralo con orders.loc[is_home, "unit_price"]. El valor de .sum() de la máscara es 2, que es el número esperado de filas afectadas por este descuento.

Las columnas nuevas convierten los datos registrados en cantidades que puedes analizar. Un cálculo entre columnas funciona fila por fila, mientras que el índice mantiene cada resultado asociado a su observación.

Calcula los ingresos

orders["revenue"] = orders["quantity"] * orders["unit_price"]

Los seis ingresos son 7,5; 18,0; 9,5; 24,0; 35,0 y NaN. Para la primera fila, tres artículos a 2,50 cada uno dan 7,50. La última fila tiene una cantidad desconocida, por lo que sus ingresos también son desconocidos. Asignar a un nombre nuevo añade una columna a la derecha; asignar a un nombre existente sobrescribe esa columna.

La aritmética entre columnas es vectorizada. Expresa una regla para toda la columna y evita un bucle de Python sobre las filas. En tablas grandes es mucho más rápida que for o iterrows, y la expresión muestra claramente la relación entre las entradas.

Usa los valores registrados en un total

orders["revenue"].sum() omite NaN y da 94,0, el total de los cinco ingresos conocidos. .mean() da 18,8 porque el denominador es el número de ingresos registrados, cinco. Dividir 94,0 entre las seis filas trataría el ingreso faltante como si aportara un cero conocido, sin indicarlo.

Para calcular las participaciones porcentuales:

orders["share_pct"] = (
    orders["revenue"] / orders["revenue"].sum() * 100
).round(1)

Las participaciones son 8,0; 19,1; 10,1; 25,5; 37,2 y NaN. Son participaciones del total conocido. La entrada faltante sigue siendo faltante en las operaciones aritméticas.

Devuelve una tabla con assign

assign devuelve un DataFrame nuevo con columnas añadidas o sustituidas, y deja su entrada sin cambios. Funciona de forma natural dentro de una cadena:

with_tax = orders.assign(
    tax=lambda d: (d["revenue"] * 0.2).round(2)
)

La expresión lambda lee la tabla en ese punto de la cadena. Da valores de impuesto de 1,5; 3,6; 1,9; 4,8; 7,0 y NaN. En pandas 3, pd.col("revenue") * 0.2 es otra forma de referirse a una columna en assign.

Los cálculos decimales pueden mostrar pequeños errores binarios de coma flotante: 9,5 multiplicado por 0,2 puede almacenarse como 1.9000000000000001. .round(2) da un valor útil para la presentación. Evita las pruebas de igualdad exacta sobre decimales calculados cuando sean posibles pequeños errores de representación.

Comprende cómo empareja filas la asignación

orders["home_price"] = orders.loc[
    orders["category"] == "Home", "unit_price"
]

La Series asignada tiene las etiquetas 1 y 3. Esas filas reciben 18,0 y 6,0; todas las demás reciben NaN. La asignación de una Series empareja etiquetas, incluso cuando su longitud difiere de la de la tabla. Una lista normal no tiene etiquetas y debe contener exactamente un valor por fila. Un escalar, como orders["currency"] = "EUR", rellena todas las filas.

Deriva valores de texto o fechas

Los accesores .str y .dt también proporcionan operaciones vectorizadas sobre columnas. orders["product"].str.upper() produce nombres en mayúsculas y .str.len() da las longitudes 8, 9, 7, 3, 8 y 8. Asigna estos resultados a una columna nueva cuando sean útiles tanto los valores originales como los derivados.

Transformar una columna puede significar aplicar una regla numérica, asignar una etiqueta o traducir etiquetas existentes. Elige un método cuyo comportamiento coincida con la regla, especialmente para los valores que la regla no menciona.

Convierte una condición en etiquetas

orders["price_band"] = np.where(
    orders["unit_price"] >= 5, "high", "low"
)

np.where elige su segundo argumento cuando la condición es True y el tercero cuando es False. Para los precios 2,50; 18,00; 4,75; 6,00; 35,00 y 2,50, las etiquetas son low, high, low, high, high y low. El operador >= incluye un precio exactamente igual a 5.

Traduce todos los valores o cambia unos pocos

codes = {"Stationery": "ST", "Home": "HM", "Bags": "BG"}
orders["category_code"] = orders["category"].map(codes)

map con un diccionario da ST, HM, ST, HM, BG y ST. Un valor ausente del diccionario se convierte en NaN. Con solo {"Stationery": "ST"}, tanto Home como Bags pasan a ser valores faltantes. Usa una correspondencia completa cuando cada categoría necesite un código traducido.

replace cambia los valores enumerados y deja los no enumerados sin cambios. orders["category"].replace({"Bags": "Luggage"}) conserva Stationery y Home mientras cambia el nombre de Bags.

Aplica una función personalizada

Una Series puede pasar cada valor a una función mediante map o apply. orders["product"].apply(len) devuelve la longitud de cada nombre de producto. Pasa len en sí; len() la llamaría de inmediato sin un valor.

Una expresión lambda puede expresar una pequeña regla para valores: orders["unit_price"].apply(lambda p: "budget" if p < 5 else "standard"). Esto devuelve budget, standard, budget, standard, standard y budget.

Para una lógica que necesita varias celdas de una fila, apply de DataFrame acepta axis=1:

orders.apply(
    lambda r: r["quantity"] * r["unit_price"], axis=1
)

La función lee la cantidad y el precio de cada fila. Para esta operación aritmética, la multiplicación directa de columnas es más clara y mucho más rápida en una tabla grande. Usa expresiones vectorizadas o np.where cuando puedan expresar el cálculo; reserva las funciones por filas para la lógica que las necesite.

Usa transformaciones numéricas incorporadas

round(n) redondea a n cifras decimales, abs() da valores absolutos y clip(lower=..., upper=...) restringe los valores a unos límites. orders["unit_price"].clip(upper=20) cambia 35,0 a 20,0 y deja los otros cinco precios sin cambios. No elimina la fila cara.

Estas transformaciones devuelven valores nuevos. Asígnalos a una columna nueva para conservar la entrada y poder comprobarla, o sobrescribe la original cuando esa sea la intención. Inspecciona unas filas transformadas o ejecuta value_counts() para comprobar que las nuevas etiquetas y sus recuentos se ajustan a la regla.

La ordenación cambia el orden en que aparecen las observaciones. Mantiene juntos los valores de cada fila y desplaza con ella su etiqueta. Decide qué tiene prioridad y cómo deben ordenarse los valores empatados antes de seleccionar los mayores o menores.

Ordena una columna

scores = pd.DataFrame({
    "name": ["Ana", "Ben", "Chen", "Dara", "Eli"],
    "points": [88, 92, 88, 75, 92]
})
ordered = scores.sort_values("points")

Por defecto, el menor aparece primero. El 75 de Dara es el primero, seguido de los dos 88 y después de los dos 92. Las etiquetas de fila se desplazan con los registros. Entre los empates, el algoritmo de ordenación predeterminado no garantiza el orden original; las etiquetas mostradas pueden ser 3, 0, 2, 1, 4, pero no debe suponerse que las filas empatadas conserven ese orden.

Usa ascending=False para colocar el mayor primero. sort_values devuelve una tabla y deja scores sin cambios salvo que se asigne el resultado.

Elige cómo resolver los empates

scores.sort_values(
    ["points", "name"], ascending=[False, True]
)

La primera clave tiene prioridad. Las puntuaciones disminuyen y los nombres aumentan dentro de las puntuaciones iguales. El orden es Ben, Eli, Ana, Chen y Dara. Ordenar primero los nombres respondería a una pregunta distinta porque convertiría los nombres en la clave principal.

Cuando los empates en una sola columna deban conservar el orden de entrada, usa scores.sort_values("points", kind="stable"). La estabilidad mantiene las filas empatadas en su secuencia existente. En cambio, una clave secundaria da a los empates su propia regla de ordenación explícita.

Ubica los valores faltantes y ordena el texto

Los valores faltantes van al final por defecto tanto en la ordenación ascendente como en la descendente. pd.Series([3.0, np.nan, 1.0]).sort_values() da 1,0; 3,0 y después NaN. na_position="first" mueve la entrada faltante al principio; invertir solo la dirección de ordenación no lo hace.

La ordenación de texto sigue los códigos de caracteres. "Zebra" se ordena antes que "apple" porque las letras mayúsculas y minúsculas ocupan intervalos distintos. Los nombres escritos de forma consistente, como Bags, Home y Stationery, se ordenan alfabéticamente como se espera.

Ordena etiquetas o vuelve a numerarlas

sort_index() ordena las etiquetas de fila, no los valores de los datos. Después de ordenar por puntuación, puede restablecer el orden de las etiquetas predeterminadas originales. sort_index(ascending=False) invierte el orden de las etiquetas. En cambio, reset_index(drop=True) mantiene el orden actual de las filas y sustituye sus etiquetas por 0, 1, 2 y así sucesivamente.

Selecciona las filas con valores mayores o menores

scores.nlargest(2, "points") devuelve Ben y Eli, ambos con 92. nsmallest toma los valores bajos. Si el corte se produce dentro de un empate, decide si quieres conservar todas las filas empatadas. scores.nlargest(1, "points", keep="all") devuelve ambos valores 92, aunque n sea 1. En ese caso, el número solicitado es un límite de corte, no una garantía del número final de filas.

Un rango registra el lugar que corresponde a un valor en el orden de clasificación sin mover su fila. Es útil cuando cada observación necesita un número de puesto junto a sus datos originales. Los empates necesitan una regla porque varios valores pueden ocupar la misma parte de ese orden.

Elige la dirección

scores["points"].rank() asigna rangos de menor a mayor. Usa ascending=False para una tabla de resultados en la que las puntuaciones altas deban recibir los mejores rangos. El método para resolver empates decide entonces qué número de puesto recibe cada grupo empatado.

Las puntuaciones del ejemplo en el orden de las filas son Ana 88, Ben 92, Chen 88, Dara 75 y Eli 92. En orden descendente, los valores 92 ocupan los puestos 1 y 2, los valores 88 los puestos 3 y 4, y 75 el puesto 5. El valor predeterminado method="average" asigna a cada valor empatado la media de sus puestos ocupados. Los valores devueltos, en el orden original de las filas, son 3,5; 1,5; 3,5; 5,0 y 1,5.

Elige un método para resolver empates

Con min, dos ganadores en el rango 1 hacen que la siguiente puntuación empiece en el rango 3. Con dense, la siguiente puntuación distinta empieza en el rango 2. first resuelve un empate incluso cuando las propias puntuaciones no dan motivo para preferir a una persona; sigue el orden de entrada.

Los resultados de los rangos son números de coma flotante, lo que permite valores como 1,5. Cuando el método elegido produce rangos enteros y no falta ninguno, .astype(int) los convierte para mostrarlos. Un tipo entero ordinario no puede contener un rango faltante.

Expresa los rangos como fracciones

Para el método predeterminado de la media y valores presentes, rank(pct=True) divide cada rango entre el número de valores clasificados. Clasificar las cinco puntuaciones del ejemplo de forma ascendente da 2,5; 4,5; 2,5; 1,0 y 4,5. Dividir entre cinco da 0,5; 0,9; 0,5; 0,2 y 0,9.

Los valores más altos empatados reciben 0,9, no 1, porque su rango medio es 4,5. Un rango percentil describe el rango relativo a los valores clasificados; no es un porcentaje de la propia puntuación.

Gestiona los rangos faltantes y guarda los resultados

Los valores faltantes conservan rangos NaN por defecto. Con los ingresos 7,5; 18,0; 9,5; 24,0; 35,0 y NaN, los rangos descendentes son 5, 3, 4, 2, 1 y NaN. na_option="bottom" coloca la entrada faltante después de los valores registrados y le da el rango 6.

scores["place"] = scores["points"].rank(
    method="min", ascending=False
)

Las filas siguen siendo Ana, Ben, Chen, Dara y Eli. La nueva columna place registra 3, 1, 3, 5 y 1. Ordena por separado si la presentación debe mostrar primero a los ganadores.

Un estadístico descriptivo condensa muchas observaciones en una cantidad útil. Elige un estadístico que se ajuste a la pregunta y consulta su recuento de valores presentes para saber cuántos datos lo respaldan.

Calcula medidas de tendencia central y dispersión

weather = pd.DataFrame({
    "temp_c": [14.0, 17.5, 16.0, 21.0, 19.5, 12.5, 15.0],
    "rain_mm": [0.0, 2.4, 0.0, 0.0, 5.1, 12.3, 0.8]
}, index=["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"])

Para weather["temp_c"], sum() es 115,5, mean() es 16,5 y median() es 16,0. El mínimo es 12,5 y el máximo 21,0, lo que da un rango de 8,5 °C. idxmax() devuelve la etiqueta "Thu", mientras que idxmin() devuelve "Sat": identifican observaciones en lugar de devolver los propios valores extremos.

std() y var() miden la dispersión. pandas usa el denominador muestral por defecto, ddof=1, y divide las desviaciones al cuadrado entre uno menos que el recuento. Aquí la desviación estándar es aproximadamente 3,028 °C y la varianza aproximadamente 9,167 grados Celsius cuadrados. std(ddof=0) usa el propio recuento y da aproximadamente 2,803 °C. np.std de NumPy usa ddof=0 por defecto, así que iguala la configuración antes de comparar resultados.

Interpreta los cuartiles y describe

quantile(0.25) da el cuartil inferior, 14,5; quantile(0.5) da la mediana, 16,0; quantile(0.75) da el cuartil superior, 18,5. La interpolación predeterminada puede devolver un valor entre mediciones registradas.

weather.describe() combina el recuento, la media, la desviación estándar, el mínimo, los tres cuartiles y el máximo para las columnas numéricas. La lluvia tiene una media de aproximadamente 2,94 mm y una mediana de 0,8 mm. La medición de 12,3 mm eleva la media; la mediana describe mejor un día típico en esta semana con asimetría a la derecha.

Ten en cuenta los valores faltantes y los tipos

Para pd.Series([1, np.nan, 3]), .mean() es 2,0 porque los valores faltantes se omiten por defecto. .count() es 2, mientras que .size es 3. Con skipna=False, la media es NaN. No uses el número total de filas como denominador de la media predeterminada cuando falten algunas entradas.

Los resúmenes de texto son distintos. orders["category"].describe() da count 6, unique 3, top Stationery y freq 3. Calcular la media de la tabla de pedidos que mezcla texto genera TypeError; usa orders.mean(numeric_only=True) o selecciona columnas numéricas con select_dtypes("number").

Resume a lo largo de un eje

Por defecto, los estadísticos de DataFrame reducen a lo largo de las filas hasta obtener un resultado por columna. En cambio, axis=1 da un resultado por fila; selecciona cantidades cuyas unidades puedan combinarse con sentido.

orders[["quantity", "unit_price"]].agg(["mean", "max"])

agg calcula conjuntamente varios estadísticos nombrados. Quantity tiene una media de 2,2 y un máximo de 4,0; unit_price tiene una media de aproximadamente 11,46 y un máximo de 35,0. weather["rain_mm"].cumsum() da las sumas acumuladas 0,0; 2,4; 2,4; 2,4; 7,5; 19,8 y 20,6 mm, conservando un resultado por día.

Los recuentos describen con qué frecuencia aparecen los valores; las correlaciones describen cómo varían conjuntamente dos variables numéricas. Ambos resúmenes necesitan interpretación: qué se cuenta, qué falta y qué relación mide el estadístico.

Cuenta categorías o enumera valores distintos

orders["category"].value_counts() da Stationery 3, Home 2 y Bags 1, ordenados por frecuencia. La Series devuelta se llama count. Las entradas faltantes se excluyen por defecto; dropna=False las incluye como un recuento separado.

orders["category"].value_counts(normalize=True)

La Series normalizada se llama proportion: Stationery es 0,5, Home aproximadamente 0,333 y Bags aproximadamente 0,167. Multiplicar por 100 expresa porcentajes. Con la regla predeterminada para valores faltantes, estas proporciones describen los valores presentes.

unique() conserva el orden de primera aparición: Stationery, Home, Bags. mode() devuelve una Series porque varios valores pueden empatar en la frecuencia más alta. No solicita un único ganador elegido arbitrariamente.

Las condiciones pueden contarse directamente. (weather["rain_mm"] > 0).sum() cuenta cuatro días lluviosos. Su .mean() es aproximadamente 0,571, por lo que llovió aproximadamente el 57 % de los siete días.

Mide una relación lineal

weather["temp_c"].corr(weather["rain_mm"]) da una correlación de Pearson de aproximadamente −0,397. Su signo negativo indica que los días más cálidos tendieron a tener menos lluvia en estas observaciones. Su magnitud describe qué tan bien se ajusta un patrón lineal, en una escala de −1 a 1 que pasa por 0.

Un valor de 1 significa una relación lineal creciente perfecta; −1 significa una decreciente perfecta. Un valor cercano a cero indica poca asociación lineal. Una relación curva puede seguir siendo fuerte incluso cuando la correlación de Pearson está cerca de cero. La correlación también se refiere a la asociación, no demuestra que cambiar una variable cause el cambio de la otra.

Interpreta una matriz de correlaciones

weather.corr() muestra todos los pares numéricos juntos. La matriz es simétrica: la temperatura con la lluvia tiene la misma correlación que la lluvia con la temperatura. Una columna numérica con variación tiene correlación 1 consigo misma; una columna constante no tiene una correlación definida y da NaN.

Para relaciones que crecen o decrecen de forma consistente sin seguir una línea recta, method="spearman" calcula la correlación a partir de los rangos. El método cambia qué tipo de patrón se resume, así que indícalo al comunicar un resultado.

El cálculo meteorológico usa solo siete mediciones. Describe esta pequeña semana observada; las afirmaciones firmes sobre un patrón climático más amplio necesitan más evidencia. Un informe útil incluye las variables, el signo y el tamaño del coeficiente, el método y el número de observaciones.