Obter Índice de Linhas cuja Coluna Corresponde a Valor Específico em Pandas

Para obter as linhas que atendem a uma condição, crie uma máscara booleana e passe-a para DataFrame.loc. Para obter apenas os rótulos dessas linhas, aplique a mesma máscara a DataFrame.index; chame tolist() se precisar de uma lista Python comum. Os rótulos do índice identificam as linhas e não precisam ser posições inteiras consecutivas. Reutilizar a mesma máscara mantém alinhadas a seleção das linhas e a seleção dos rótulos, mesmo quando o DataFrame tem rótulos personalizados. Use DataFrame.loc quando precisar dos registros correspondentes para continuar o trabalho e a expressão do índice quando quiser apenas os rótulos.

Obter linhas que atendem a condições numéricas em Pandas

Este exemplo seleciona as linhas em que a coluna B é igual a 19 e, em seguida, combina essa condição com uma condição OR na coluna C. DataFrame.loc retorna as linhas correspondentes, enquanto DataFrame.index retorna seus rótulos. Os parênteses em torno de cada comparação deixam explícita a condição booleana combinada. Em um DataFrame real, substitua os nomes das colunas e os valores de exemplo pelos dados que você tem; mantenha cada comparação entre parênteses ao combinar máscaras com | ou &, para que o Python aplique a operação pretendida a cada Série booleana.

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]

A primeira máscara seleciona as linhas cujo valor de B é 19; seus rótulos são [6, 9]. A segunda máscara usa OR (|), portanto uma linha é selecionada quando B ou C é igual a 19; seus rótulos são [6, 9, 14]. Use & entre condições entre parênteses quando ambas precisarem ser verdadeiras. Esses valores são rótulos do índice, não posições das linhas, então continuam significativos mesmo que o DataFrame tenha sido filtrado ou carregado com um índice personalizado. DataFrame.index é um atributo, não um método, e tolist() converte os rótulos selecionados em uma lista Python sem depender de uma classe específica de índice do pandas. Se os rótulos originais não forem únicos, o resultado poderá conter rótulos repetidos, pois cada linha correspondente contribui com seu rótulo de índice.

Obter índices das linhas correspondentes a valores de texto em Pandas

Filtros de texto seguem o mesmo padrão: compare uma coluna com um valor completo para verificar igualdade exata ou use str.contains para localizar uma substring. A igualdade exata é útil quando todo o conteúdo da célula precisa corresponder; a busca por substring é útil quando o valor pode incluir outros textos. O exemplo abaixo obtém tanto as linhas correspondentes quanto seus rótulos. A condição de substring usa rex em minúsculas, que aparece com a mesma capitalização em Tyrannosaurus rex.

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

A igualdade exata encontra blue e retorna seu rótulo. A substring ha corresponde a charlie e alpha; ao combiná-la com a condição rex na coluna Type, a linha alpha é selecionada e seu rótulo é [4]. Por padrão, str.contains diferencia maiúsculas de minúsculas; portanto, use a mesma capitalização dos dados ou defina a opção case explicitamente. Combine condições com & quando ambas precisarem corresponder e com | quando qualquer uma delas puder corresponder; coloque cada comparação entre parênteses. Assim como nos filtros numéricos, passe a máscara para DataFrame.loc para obter as linhas e para DataFrame.index para obter os rótulos. Você pode adaptar a expressão de correspondência exata a outra coluna alterando o nome da coluna e o valor comparado; a expressão de substring mantém a mesma estrutura, mas usa outro texto de busca.