Cómo obtener los índices de las filas que coinciden con un valor en Pandas

Para recuperar las filas que cumplen una condición, crea una máscara booleana y pásala a DataFrame.loc. Para obtener solo sus etiquetas, aplica la misma máscara a DataFrame.index; llama a tolist() si necesitas una lista normal de Python. Las etiquetas del índice identifican filas y no tienen por qué ser posiciones enteras consecutivas. Reutilizar una misma máscara mantiene alineadas la selección de filas y la de etiquetas, incluso cuando un DataFrame tiene etiquetas personalizadas. Elige DataFrame.loc si necesitas los registros coincidentes para seguir trabajando con ellos, y usa la expresión del índice cuando el resultado que buscas sean las propias etiquetas.

Obtener filas que cumplen condiciones numéricas en Pandas

Este ejemplo selecciona las filas en las que la columna B vale 19 y luego combina esa condición con una condición OR sobre la columna C. DataFrame.loc devuelve las filas coincidentes, mientras que DataFrame.index devuelve sus etiquetas. Los paréntesis alrededor de cada comparación hacen explícita la condición booleana combinada. En un DataFrame real, sustituye los nombres de columna y los valores de ejemplo por los de tus datos; al combinar máscaras con | o &, escribe cada comparación entre paréntesis para que Python aplique la operación prevista a cada serie booleana. Los nombres de columnas y los valores de muestra de los bloques se conservan en inglés.

import numpy as np
import pandas as pd

np.random.seed(0)
df = pd.DataFrame(np.random.randint(1, 20, size=(20, 4)), columns=list("ABCD"))

matches_b = df["B"] == 19
print(df.loc[matches_b])
print(df.index[matches_b].tolist())

matches_b_or_c = (df["B"] == 19) | (df["C"] == 19)
print(df.loc[matches_b_or_c])
print(df.index[matches_b_or_c].tolist())

    A   B  C   D
6   1  19  4  18
9  12  19  3   1
[6, 9]
     A   B   C   D
6    1  19   4  18
9   12  19   3   1
14  12  15  19   1
[6, 9, 14]

La primera máscara selecciona las filas cuyo valor de B es 19; sus etiquetas son [6, 9]. La segunda máscara usa OR (|), por lo que se selecciona una fila cuando B o C vale 19; sus etiquetas son [6, 9, 14]. Usa & entre condiciones entre paréntesis cuando ambas deban cumplirse. Estas son etiquetas del índice, no posiciones de fila, así que pueden seguir siendo significativas aunque el DataFrame se haya filtrado o cargado con un índice personalizado. DataFrame.index es un atributo, no un método, y tolist() convierte las etiquetas seleccionadas en una lista de Python sin depender de una clase de índice concreta de pandas. Si las etiquetas originales no son únicas, el resultado puede contener etiquetas repetidas, ya que cada fila coincidente aporta su etiqueta de índice.

Obtener índices de filas que coinciden con cadenas en Pandas

Los filtros de cadenas siguen el mismo patrón: compara una columna con un valor completo para comprobar la igualdad exacta o usa str.contains para buscar una subcadena. La igualdad exacta sirve cuando debe coincidir todo el contenido de la celda; la búsqueda de subcadenas, cuando el valor puede incluir texto adicional. El ejemplo siguiente recupera tanto las filas coincidentes como sus etiquetas. La condición de subcadena usa rex en minúsculas, que aparece con la misma capitalización en Tyrannosaurus rex. Las cadenas de muestra de los bloques, incluidos los nombres de ejemplo, permanecen en inglés.

import pandas as pd

df = pd.DataFrame(
    {
        "Name": ["blue", "delta", "echo", "charlie", "alpha"],
        "Type": ["Raptors", "Raptors", "Raptors", "Raptors", "Tyrannosaurus rex"],
    }
)

exact_name = df["Name"] == "blue"
print(df.index[exact_name].tolist())
print(df.loc[exact_name])

name_contains_ha = df["Name"].str.contains("ha")
print(df.index[name_contains_ha].tolist())
print(df.loc[name_contains_ha])

name_contains_ha_and_type_contains_rex = name_contains_ha & df["Type"].str.contains("rex")
print(df.loc[name_contains_ha_and_type_contains_rex])

[0]
   Name     Type
0  blue  Raptors
[3, 4]
      Name               Type
3  charlie            Raptors
4    alpha  Tyrannosaurus rex
    Name               Type
4  alpha  Tyrannosaurus rex

La igualdad exacta encuentra blue y devuelve su etiqueta. La subcadena ha coincide con charlie y alpha; al combinarla con la condición rex sobre Type, se selecciona la fila alpha, cuya etiqueta es [4]. De forma predeterminada, str.contains distingue entre mayúsculas y minúsculas, así que usa la misma capitalización que los datos o establece deliberadamente la opción case. Combina condiciones con & cuando deban coincidir ambas y con | cuando baste con que coincida una; pon cada comparación entre paréntesis. Igual que con los filtros numéricos, pasa la máscara a DataFrame.loc para obtener filas y a DataFrame.index para obtener etiquetas. Puedes adaptar la expresión de coincidencia exacta a otra columna cambiando el nombre de la columna y el valor de comparación; el formato de la búsqueda de subcadenas se mantiene y solo cambia el texto buscado.