Index der Zeilen ermitteln, deren Spalte mit einem bestimmten Wert in Pandas übereinstimmt

1. Indizes von Zeilen, die Integers/Floats enthalten, in Pandas ermitteln
2. Abrufen von Zeilenindizes mit Zeichenketten in Pandas

Dieser Artikel demonstriert, wie man in Pandas den Index von Zeilen ermittelt, deren Spalte mit einem bestimmten Wert übereinstimmt.

Die Notwendigkeit, die Indizes der Zeilen zu finden, ist im Feature Engineering wichtig. Diese Fähigkeiten können nützlich sein, um die Ausreißer oder abnormalen Werte in einem Dataframe zu entfernen. Die Indizes, auch bekannt als die Zeilenbeschriftungen, können in Pandas mit verschiedenen Funktionen gefunden werden. In den folgenden Beispielen werden wir mit dem Dataframe arbeiten, der mit folgendem Snippet erstellt wurde.

import pandas as pd
import numpy as np

np.random.seed(0)

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

print(df)

Ausgabe:

     A   B   C   D
0   13  16   1   4
1    4   8  10  19
2    5   7  13   2
3    7   8  15  18
4    6  14   9  10
5   17   6  16  16
6    1  19   4  18
7   15   8   1   2
8   10   1  11   4
9   12  19   3   1
10   1   5   6   7
11   9  18  16   5
12  10  11   2   2
13   8  10   4   7
14  12  15  19   1
15  15   4  13  11
16  12   5   7   5
17  16   4  13   5
18   9  15  16   4
19  16  14  17  18

Indizes von Zeilen, die Integers/Floats enthalten, in Pandas ermitteln

Die Funktion pandas.DataFrame.loc kann auf Zeilen und Spalten über ihre Bezeichnungen/Namen zugreifen. Sie gibt einfach die Zeilen zurück, die der als Label übergebenen booleschen Bedingung entsprechen. Beachten Sie die eckigen Klammern neben df.loc in dem Ausschnitt.

import pandas as pd
import numpy as np

np.random.seed(0)

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

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

Die Zeilen, die der booleschen Bedingung entsprechen, werden als Ausgabe im Format eines Dataframes zurückgegeben.

Ausgabe:

    A   B  C   D
6   1  19  4  18
9  12  19  3   1

Mehrere Bedingungen können verkettet und gemeinsam auf die Funktion angewendet werden, wie unten gezeigt. Dies hilft bei der Isolierung der Zeilen basierend auf bestimmten Bedingungen.

import pandas as pd
import numpy as np

np.random.seed(0)

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

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

Ausgabe:

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

Index der Zeilen mit pandas.DataFrame.index() ermitteln

Wenn Sie nur die übereinstimmenden Indizes des Dataframes finden möchten, der die als Argument übergebene boolesche Bedingung erfüllt, ist pandas.DataFrame.index() der einfachste Weg, dies zu erreichen.

import pandas as pd
import numpy as np

np.random.seed(0)

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

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

Im obigen Schnipsel werden die Zeilen der Spalte A, die die boolesche Bedingung == 1 erfüllen, als Ausgabe zurückgegeben, wie unten gezeigt.

Ausgabe:

[6, 9]

Der Grund, warum wir tolist() hinter die index()-Methode setzen, ist die Konvertierung des Index in die Liste; andernfalls ist das Ergebnis vom Datentyp Int64Index.

Int64Index([6, 9], dtype='int64'

Das Abrufen nur der Indizes kann auch auf der Basis mehrerer Bedingungen erfolgen. Das Snippet kann wie folgt geschrieben werden:

import pandas as pd
import numpy as np

np.random.seed(0)

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

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

Output:

[6, 9, 14]

Abrufen von Zeilenindizes mit Zeichenketten in Pandas

Die String-Werte können auf Basis von zwei Methoden abgeglichen werden. Beide Methoden, die im vorherigen Abschnitt gezeigt wurden, funktionieren, nur die Bedingung ändert sich.

In den folgenden Beispielen werden wir den folgenden Ausschnitt verwenden.

import pandas as pd

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

print(df)

Ausgabe:

      Name               Type
0     blue            Raptors
1    delta            Raptors
2     echo            Raptors
3  charlie            Raptors
4    alpha  Tyrannosaurus rex

Index der Zeilen mit der exakten Zeichenkettenübereinstimmung ermitteln

Die im vorherigen Abschnitt verwendete Gleichheitsbedingung kann verwendet werden, um die exakte Zeichenkettenübereinstimmung im Dataframe zu finden. Wir werden nach den beiden Zeichenketten suchen.

import pandas as pd

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

print(df.index[(df["Name"] == "blue")].tolist())
print("\n")
print(df.loc[df["Name"] == "blue"])
print("\n")
print(df.loc[(df["Name"] == "charlie") & (df["Type"] == "Raptors")])

Ausgabe:

[0]

   Name     Type
0  blue  Raptors

      Name     Type
3  charlie  Raptors

Wie oben gesehen, können sowohl der Index als auch die Zeilen, die mit der Bedingung übereinstimmen, empfangen werden.

Index der Zeilen mit der teilweisen Zeichenkettenübereinstimmung erhalten

Die Zeichenkettenwerte können teilweise abgeglichen werden, indem der Dataframe mit der Funktion str.contains verkettet wird. Im folgenden Beispiel wird nach der Zeichenkette ha in charlie und alpha gesucht.

import pandas as pd

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

print(df.index[df["Name"].str.contains("ha")].tolist())
print("\n")
print(df.loc[df["Name"].str.contains("ha")])
print("\n")
print(df.loc[(df["Name"].str.contains("ha")) & (df["Type"].str.contains("Rex"))])

Ausgabe:

[3, 4]

      Name               Type
3  charlie            Raptors
4    alpha  Tyrannosaurus rex


    Name               Type
4  alpha  Tyrannosaurus rex

Diese Funktion kann sehr nützlich sein, um einen teilweisen Zeichenkettenübereinstimmung über mehrere Spalten des Dataframes durchzuführen.