Iloc vs Loc in Pandas: Ein Leitfaden mit Beispielen

Eines der ärgerlichen Dinge, die wir alle versuchen herauszufinden, wenn wir Pandas lernen, ist der Unterschied zwischen .loc und .iloc.

Lassen Sie uns dieses Durcheinander beenden und den Unterschied zwischen diesen beiden Methoden klären. Ich werde viele Beispiele geben, und ich hoffe, dass der Unterschied am Ende dieses Blogs viel klarer sein wird.

Was sind .loc und .iloc in Pandas?

Sowohl .loc als auch .iloc sind wesentliche Attribute von Pandas DataFrames und beide werden verwendet, um spezifische Teilmengen von Daten auszuwählen. Ihr Zweck ist es, auf einen bestimmten Teil des DataFrames zuzugreifen und dessen Manipulation zu ermöglichen, anstatt den gesamten DataFrame.

Wie wir aus der Tabelle erkennen können, sieht die Syntax sehr ähnlich aus. Der Unterschied liegt darin, wie wir die Argumente row_indexer und column_indexer verwenden. Dies liegt daran, dass die beiden Methoden unterschiedliche Ansätze zur Indizierung der Daten bieten: während .loc basierend auf Bezeichnungsnamen indiziert, nimmt .iloc den numerischen Positionsindex von Zeilen und Spalten als Argumente.

Schauen wir uns jede der beiden Methoden im Detail an, beginnend mit .loc.

Verwendung von .loc: Auswahl nach Labels

Um die Konzepte zu veranschaulichen, betrachten wir eine hypothetische Kundendatenbank, die durch dieses DataFrame namens df dargestellt wird, wobei die Kunden-ID den Zeilenindex i repräsentiert:

Es gibt vier Hauptmethoden, um Zeilen mit .loc auszuwählen. Dazu gehören:

• Eine einzelne Zeile auswählen
• Auswahl mehrerer Zeilen
• Auswahl eines Zeilenabschnitts
• Bedingte Zeilenauswahl

Eine einzelne Zeile mit .loc auswählen

Um eine einzelne Zeile auszuwählen, verwenden wir die Bezeichnung der Zeile, die wir abrufen möchten, als row_indexer. Dementsprechend sieht die Syntax so aus: df.loc['row_label']. Lassen Sie uns dies verwenden, um alle Informationen zu unserem Kunden Ali Khan anzuzeigen:

df.loc['C345']

Mehrere Zeilen mit .loc auswählen

Wenn wir mehrere Zeilen auswählen möchten, die nicht unbedingt aufeinanderfolgend sind, müssen wir eine Liste ihrer Zeilenbezeichner als das row_indexer-Argument übergeben. Das bedeutet, dass wir nicht nur ein, sondern zwei Paare von eckigen Klammern verwenden müssen: eine für die reguläre .loc-Syntax und eine für die Bezeichnerliste.

Die Zeile df.loc[['row_label_1', 'row_label_2']] gibt die beiden Zeilen des df-DataFrames zurück, die in der Liste angegeben sind. Angenommen, wir wollten nicht nur die Informationen über Ali Khan, sondern auch über David Lee wissen:

df.loc[['C345', 'C567']]

Selecting a slice of rows using .loc

Wir können einen Bereich von Zeilen auswählen, indem wir die ersten und letzten Zeilenbezeichnungen mit einem Doppelpunkt dazwischen übergeben: df.loc['row_label_start':'row_label_end']. Wir könnten die ersten vier Zeilen unseres DataFrames so anzeigen:

df.loc['C123' : 'C456']

Hier sind zwei Dinge zu beachten:

1. Die Ausgabe enthält die in row_label_end angegebene Zeile. Dies unterscheidet sich von .iloc, worauf wir später eingehen werden.
2. Wir verwenden nur ein Paar eckiger Klammern, obwohl wir mehrere Zeilen abrufen möchten. Wir verwenden keine Liste, um die verschiedenen Zeilen anzugeben, daher würde die Verwendung von zwei eckigen Klammern einen SyntaxError zurückgeben.

Konditionale Auswahl von Zeilen mit .loc

Wir können auch Zeilen basierend auf einem bedingten Ausdruck zurückgeben. Wir können alle Zeilen filtern, ob sie eine bestimmte Bedingung erfüllen oder nicht, und nur diejenigen anzeigen, die dies tun.

Die entsprechende Syntax lautet df.loc[bedingter_ausdruck], wobei der bedingter_ausdruck eine Aussage über die erlaubten Werte in einer bestimmten Spalte ist.

Für Spalten mit nicht-numerischen Daten (wie Name oder Land) kann die Anweisung nur den Gleichheits- oder Ungleichheitsoperator verwenden, da zwischen den Werten keine Reihenfolge besteht. Wir könnten beispielsweise alle Zeilen von Kunden zurückgeben, die nicht aus Asien stammen:

df.loc[df['Region'] != 'Asia']

Eine einzelne Spalte mit .loc auswählen

Um Spalten auszuwählen, müssen wir das Argument column_indexer angeben, das nach dem Argument row_indexer kommt. Wenn wir nur das column_indexer angeben möchten, müssen wir irgendwie kennzeichnen, dass wir alle Zeilen zurückgeben und nur nach den Spalten filtern wollen. Lassen Sie uns sehen, wie wir das tun können!

Eine einzelne Spalte kann ausgewählt werden, indem das column_indexer mit dem Label der jeweiligen Spalte angegeben wird. Um alle Zeilen abzurufen, müssen wir das row_indexer mit einem einfachen Doppelpunkt angeben. Wir gelangen zu einer Syntax, die so aussieht: df.loc[:, 'column_name'].

Zeigen wir den Namen jedes Kunden an:

df.loc[:, 'Name']

Selecting multiple columns using .loc

Similar to selecting multiple rows, we need to pass a list of column labels if we want to return multiple columns of a DataFrame that do not necessarily follow each other in order: df.loc[:, [col_label_1, 'col_label_2']].

Assuming we wanted to add all customers’ Age to our last output, it would work like this:

df.loc[:, ['Name', 'Age']]

Eine Auswahl von Spalten mit .loc

Die Verwendung eines Doppelpunktes zwischen den Bezeichnungen von zwei Spalten wählt alle Spalten im Bereich zwischen den beiden angegebenen Spalten aus. Es schließt die Endspalte ein, was bedeutet, dass die Spalte mit dem Namen col_end auch in der Standard-Syntax ausgewählt wird, die wie folgt aussieht: df.loc[:, 'col_start':'col_end'].

Wenn wir an den Name, Land und Region unserer Kunden interessiert wären, könnte unsere Codezeile wie folgt aussehen:

df.loc[:, 'Name':'Region']

Kombinierte Zeilen- und Spaltenauswahl mit .loc

Es ist auch möglich, sowohl den row_indexer als auch den column_indexer anzugeben. Dies könnte verwendet werden, um ein einzelnes Stück Information abzurufen, was bedeutet, eine Zelle aus dem DataFrame. Um dies zu tun, geben wir eine Zeile und eine Spalte mit der Syntax df.loc['row_label', 'column_name'] an.

Der nützlichere Fall ist, ein Sub-DataFrame zurückzugeben, das sich genau auf die Menge von Zeilen und Spalten konzentriert, an denen wir interessiert sind. Es ist möglich, beide Indexer als Listen mit eckigen Klammern oder als Slice mit einem Doppelpunkt anzugeben und sogar mit einem bedingten Ausdruck für die Zeilenauswahl zu kombinieren.

Hier ist ein Beispiel für die Rückgabe des Name, Land und Region jedes Kunden mit einem Alter von über 30:

df.loc[df['Age'] > 30, 'Name':'Region']

Verwendung von .iloc: Auswahl nach Integer-Position

.iloc wählt nach Position anstelle von Bezeichnung aus. Dies ist die Standard-Syntax für die Verwendung von .iloc: df.iloc[Zeilensucher, Spaltensucher]. Es gibt zwei Besonderheiten, auf die man achten sollte:

• Zählen beginnt bei 0: Die erste Zeile und Spalte haben den Index 0, die zweite den Index 1, usw.
• Exklusivität des Bereichsendwerts: Bei Verwendung eines Bereichs wird die hinter dem Doppelpunkt angegebene Zeile oder Spalte nicht in die Auswahl einbezogen.

Auswahl einer einzelnen Zeile mit .iloc

Eine einzelne Zeile kann ausgewählt werden, indem die den Zeilenindex darstellende Ganzzahl als Zeilensucher verwendet wird. Anführungszeichen sind nicht erforderlich, da wir eine Ganzzahl eingeben und nicht einen Bezeichnungsstring wie bei .loc. Um die erste Zeile eines DataFrame namens df zurückzugeben, geben Sie df.iloc[0] ein.

In unserem Beispiel-DataFrame liefert diese Codezeile die Informationen von John Doe:

df.iloc[0]

Selecting multiple rows using .iloc

Selecting multiple rows works in .iloc as it does in .loc—we enter the row index integers in a list with squared brackets. The syntax looks like this: df.iloc[[0, 3, 4]].

The respective output in our customer table can be seen below:

df.iloc[[0, 3, 4]]

Die Auswahl einer Zeilengruppe mit .iloc

Um eine Zeilengruppe auszuwählen, verwenden wir einen Doppelpunkt zwischen zwei angegebenen Zeilenindex-Integern. Wir müssen nun auf die zuvor erwähnte Ausschlussregel achten. 

Wir können die Zeile df.iloc[1:4] als Beispiel nehmen, um dieses Konzept zu veranschaulichen. Der Index 1 bedeutet die zweite Zeile, also beginnt unser Ausschnitt dort. Der Index-Integer 4 repräsentiert die fünfte Zeile – aber da .iloc nicht inklusiv für die Auswahl von Zeilengruppen ist, wird unser Ergebnis alle Zeilen bis zur letzten vor dieser einschließen. Daher werden die zweite, dritte und vierte Zeile zurückgegeben. 

Lassen Sie uns beweisen, dass die Zeile so funktioniert, wie sie sollte:

df.iloc[1:4]

Das Auswählen einer einzelnen Spalte mit .iloc

Die Logik zur Auswahl von Spalten mit .iloc folgt dem, was wir bisher gelernt haben. Lassen Sie uns sehen, wie es für einzelne Spalten, mehrere Spalten und Spaltenschnitte funktioniert.

Wie bei .loc ist es wichtig, den row_indexer anzugeben, bevor wir zum column_indexer übergehen können. Um die Werte der dritten Spalte von df für jede Zeile abzurufen, geben wir df.iloc[:, 2] ein.

Da Region die dritte Spalte in unserem DataFrame ist, wird sie als Folge dieser Codezeile abgerufen:

df.iloc[:, 2]

Mehrere Spalten mit .iloc auswählen

Um mehrere Spalten auszuwählen, die nicht unbedingt aufeinanderfolgend sind, können wir erneut eine Liste mit Ganzzahlen als column_indexer eingeben. Die Zeile df.iloc[:, [0, 3]] gibt sowohl die erste als auch die vierte Spalte zurück.

In unserem Fall sind die angezeigten Informationen der Name sowie das Alter jedes Kunden:

df.iloc[:, [0, 3]]

Eine Auswahl von Spalten mit .iloc treffen

Bei der Auswahl von Slices mit .iloc folgt die Logik des column_indexer der des row_indexer. Die Spalte, die durch die Zahl nach dem Doppelpunkt repräsentiert wird, ist nicht im Output enthalten. Um die zweite und dritte Spalte abzurufen, sollte der Code so aussehen: df.iloc[:, 1:3].

Diese Zeile unten gibt alle geografischen Informationen zurück, die wir über unsere Kunden haben:

df.iloc[:, 1:3]

Kombinierte Zeilen- und Spaltenauswahl mit .iloc

Wir können das Gelernte über .iloc verwenden, um die Zeilen- und Spaltenauswahl zu kombinieren. Es ist wieder möglich, entweder eine einzelne Zelle oder ein Teil-DataFrame zurückzugeben. Um die einzelne Zelle am Schnittpunkt von Zeile 3 und Spalte 4 zurückzugeben, geben wir df.iloc[2, 3] ein.

Genau wie bei .loc können wir beide Indizierungen als Listen mit eckigen Klammern oder als Bereich mit dem Doppelpunkt angeben. Wenn wir Zeilen mit bedingten Ausdrücken auswählen möchten, ist das technisch gesehen auch mit .iloc möglich, wird jedoch nicht empfohlen. Die Verwendung von Bezeichnungen und .loc ist normalerweise intuitiver und weniger fehleranfällig.

Dieses letzte Beispiel zeigt Land, Region und Alter für die erste, zweite und fünfte Zeile in unserem DataFrame:

df.iloc[[0,1,4], 1:4]

.iloc vs .loc: Wann welches verwenden

Im Allgemeinen gibt es eine einfache Faustregel, bei der die Wahl der Methode von Ihrem Wissen über das DataFrame abhängt:

• Verwenden Sie .loc, wenn Sie die Bezeichnungen (Namen) der Zeilen/Spalten kennen.
• Verwenden Sie .iloc, wenn Sie die ganzzahligen Positionen der Zeilen/Spalten kennen.

In einigen Szenarien ist entweder .loc oder .iloc besser geeignet. Zum Beispiel ist die Iteration über Zeilen oder Spalten mit Ganzzahlen intuitiver. Wie bereits erwähnt, ist das Filtern von Zeilen basierend auf Bedingungen in Spaltenwerten weniger fehleranfällig, wenn die Spaltennamen verwendet werden.

KeyError, NameError und Index Error mit .loc und .iloc

Lassen Sie uns mögliche Probleme betrachten. Eine häufige Falle beim Verwenden von .loc ist das Auftreten eines KeyError. Dieser Fehler tritt auf, wenn wir versuchen, auf ein Zeilen- oder Spaltenlabel zuzugreifen, das in unserem DataFrame nicht existiert. Um dies zu vermeiden, müssen wir immer sicherstellen, dass die verwendeten Labels korrekt sind und mit den vorhandenen Labels in Ihrem DataFrame übereinstimmen und auf Tippfehler überprüfen.

Zusätzlich ist es wichtig, immer Anführungszeichen für die mit .loc angegebenen Labels zu verwenden. Das Vergessen dieser wird einen NameError zurückgeben.

Ein IndexError kann auftreten, wenn wir bei der Verwendung von .iloc eine Integer-Position angeben, die außerhalb des gültigen Bereichs der Indizes unseres DataFrames liegt. Dies geschieht, wenn der Index, auf den zugegriffen werden soll, nicht existiert, entweder weil er über die Anzahl der Zeilen oder Spalten in Ihrem DataFrame hinausgeht oder weil er einen negativen Wert hat. Um diesen Fehler zu vermeiden, überprüfen Sie die Dimensionen Ihres DataFrames und verwenden Sie geeignete Indexwerte innerhalb des gültigen Bereichs.

Conclusion

Ich hoffe, dass dieser Blog hilfreich war und der Unterschied zwischen .loc und .iloc jetzt klar ist. Um mehr zu erfahren, hier sind einige gute nächste Schritte:

• SettingWithCopyWarning in Pandas: Wie man diese Warnung behebt
• Kurs: Datenmanipulation mit pandas
• Kurs: Effizientes Programmieren mit pandas
• Spickzettel: Datenbereinigung mit pandas
• Spickzettel: Daten umformen mit pandas