Iloc vs. Loc in Pandas: Ein Leitfaden mit Beispielen

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

Machen wir dieser Verwirrung ein Ende und klären wir den Unterschied zwischen diesen beiden Methoden. Ich werde viele Beispiele anführen und hoffe, dass die Unterscheidung am Ende dieses Blogs klarer wird.

Was sind .loc und .iloc in Pandas?

Sowohl .loc als auch .iloc sind wesentliche Attribute von Pandas DataFrames und werden für die Auswahl bestimmter Teilmengen von Daten verwendet. Sie dienen dazu, auf einen bestimmten Teil des DataFrame zuzugreifen und ihn zu bearbeiten, anstatt den gesamten DataFrame. 

Wie wir in der Tabelle sehen können, sieht die Syntax sehr ähnlich aus. Der Unterschied liegt darin, wie wir die Argumente row_indexer und column_indexer verwenden. Das liegt daran, dass die beiden Methoden unterschiedliche Ansätze für die Indizierung der Daten bieten: Während .loc die Indizierung auf Basis der Bezeichnungen vornimmt, nimmt .iloc den numerischen Positionsindex der Zeilen und Spalten als Argument.

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

Using .loc: Auswahl nach Labels

Zur Veranschaulichung der Konzepte betrachten wir eine hypothetische Kundendatenbank, die durch diesen DataFrame mit dem Namen df dargestellt wird, wobei Customer ID den Zeilenindex darstellt:

Es gibt vier primäre Möglichkeiten, Zeilen mit .loc auszuwählen. Dazu gehören:

• Auswählen einer einzelnen Zeile
• Auswählen mehrerer Zeilen
• Auswählen eines Teils der Zeilen
• Bedingte Zeilenauswahl

Auswählen einer einzelnen Zeile mit .loc

Um eine einzelne Zeile auszuwählen, verwenden wir die Bezeichnung der Zeile, die wir abrufen wollen, als row_indexer. Dementsprechend sieht die Syntax wie folgt aus: df.loc['row_label']. Verwenden wir dies, um alle Informationen über unseren Kunden Ali Khan anzuzeigen:

df.loc['C345']

Auswählen mehrerer Zeilen mit .loc

Wenn wir mehrere Zeilen auswählen wollen, die nicht unbedingt in der richtigen Reihenfolge aufeinander folgen, müssen wir eine Liste ihrer Zeilenbezeichnungen als row_indexer Argument übergeben. Das bedeutet, dass wir nicht nur ein, sondern zwei Paare von eckigen Klammern verwenden müssen: eines für die reguläre .loc Syntax und eines für die Bezeichnungsliste.

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

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

Auswählen eines Bereichs von Zeilen mit .loc

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

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

Hier gibt es zwei Dinge zu beachten:

1. Die Ausgabe enthält die in row_label_end angegebene Zeile. Das ist bei .iloc anders, worauf wir später noch eingehen werden.
2. Wir verwenden nur ein Paar eckige Klammern, obwohl wir mehrere Zeilen abrufen wollen. Wir verwenden keine Liste, um die verschiedenen Zeilen zu spezifizieren, also würde die Verwendung von zwei eckigen Klammern ein SyntaxError ergeben.

Bedingte Auswahl von Zeilen mit .loc

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

Die entsprechende Syntax lautet df.loc[conditional_expression], wobei conditional_expression eine Aussage über die zulässigen Werte in einer bestimmten Spalte ist.

Für Spalten mit nicht-numerischen Daten (wie Name oder Country) kann die Anweisung nur den Gleich- oder Ungleichheitsoperator verwenden, da es keine Reihenfolge zwischen den Werten gibt. Wir könnten zum Beispiel alle Zeilen von Kunden zurückgeben, die nicht aus Asien kommen:

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

Auswählen einer einzelnen Spalte mit .loc

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

Eine einzelne Spalte kannst du auswählen, indem du die column_indexermit dem Label der jeweiligen Spalte angibst. Um alle Zeilen abzurufen, müssen wir die row_indexer mit einem einfachen Doppelpunkt angeben. Wir kommen zu einer Syntax, die wie folgt aussieht: df.loc[:, 'column_name'].

Lass uns die Name der einzelnen Kunden anzeigen:

df.loc[:, 'Name']

Auswählen mehrerer Spalten mit .loc

Ähnlich wie bei der Auswahl mehrerer Zeilen müssen wir eine Liste von Spaltenbezeichnungen übergeben, wenn wir mehrere Spalten eines DataFrame zurückgeben wollen, die nicht unbedingt in der Reihenfolge aufeinander folgen: df.loc[:, [col_label_1, 'col_label_2']].

Angenommen, wir wollen alle Kunden Age zu unserer letzten Ausgabe hinzufügen, dann würde das so funktionieren:

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

Auswählen eines Bereichs von Spalten mit .loc

Wenn du einen Doppelpunkt zwischen den Beschriftungen von zwei Spalten verwendest, werden alle Spalten im Ordnungsbereich zwischen den beiden angegebenen Spalten ausgewählt. Sie schließt die Endspalte mit ein, d.h. die Spalte mit dem Namen col_end wird auch in der Standardsyntax ausgewählt, die wie folgt lautet: df.loc[:, 'col_start':'col_end'].

Wenn wir uns für die Name, Country und Region unserer Kunden interessieren würden, könnte unsere Codezeile lauten:

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

Kombinierte Zeilen- und Spaltenauswahl mit .loc

Es ist auch möglich, sowohl die row_indexer als auch die column_indexer anzugeben. Damit kann eine einzelne Information, d. h. eine Zelle aus dem DataFrame, abgerufen werden. Hierfür geben wir eine Zeile und eine Spalte mit der Syntax df.loc['row_label', 'column_name'] an.

Sinnvoller ist es, einen Sub-DataFrame zurückzugeben, der sich auf genau die Zeilen und Spalten konzentriert, an denen wir interessiert sind. Es ist möglich, beide Indexer als Liste mit eckigen Klammern oder als Slice mit Doppelpunkt anzugeben und sie sogar mit einem bedingten Ausdruck für die Zeilenauswahl zu kombinieren.

Hier ist ein Beispiel für die Rückgabe von Name, Country und Region von jedem Kunden mit einem Age von über 30:

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

Mit .iloc: Auswahl nach Integer-Position

.iloc wählt nach der Position statt nach der Bezeichnung aus. Dies ist die Standardsyntax für die Verwendung von .iloc: df.iloc[row_indexer, column_indexer]. Es gibt zwei besondere Dinge, auf die du achten solltest:

• Die Zählung beginnt bei 0: Die erste Zeile und Spalte haben den Index 0, die zweite den Index 1, usw.
• Ausschließlichkeit des Bereichsendwerts: Wenn du einen Slice verwendest, wird die hinter dem Doppelpunkt angegebene Zeile oder Spalte nicht in die Auswahl einbezogen.

Auswählen einer einzelnen Zeile mit .iloc

Eine einzelne Zeile kann ausgewählt werden, indem die Ganzzahl, die die Zeilenindexnummer darstellt, als row_indexer verwendet wird. Wir brauchen keine Anführungszeichen, da wir eine ganze Zahl eingeben und nicht wie bei .loc eine Zeichenfolge. Um die erste Zeile eines DataFrame namens df zurückzugeben, gibst du df.iloc[0] ein.

In unserem DataFrame-Beispiel gibt genau diese Codezeile die Informationen von John Doe zurück:

df.iloc[0]

Auswählen mehrerer Zeilen mit .iloc

Die Auswahl mehrerer Zeilen funktioniert in .iloc genauso wie in .loc- wir geben die Zeilenindex-Ganzzahlen in eine Liste mit eckigen Klammern ein. Die Syntax sieht wie folgt aus: df.iloc[[0, 3, 4]].

Die entsprechende Ausgabe in unserer Tabelle für Kunden ist unten zu sehen:

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

Auswählen eines Teils der Zeilen mit .iloc

Um eine Reihe von Zeilen auszuwählen, verwenden wir einen Doppelpunkt zwischen zwei angegebenen Zeilenindex-Ganzzahlen. Jetzt müssen wir auf die bereits erwähnte Exklusivität achten. 

Wir können die Linie df.iloc[1:4] als Beispiel nehmen, um dieses Konzept zu veranschaulichen. Die Indexnummer 1 bedeutet die zweite Reihe, also beginnt unser Slice dort. Die Indexzahl 4 steht für die fünfte Zeile - aber da .iloc für die Slice-Auswahl nicht inklusiv ist, wird unsere Ausgabe alle Zeilen bis zur letzten vor dieser Zeile enthalten. Daher wird die zweite, dritte und vierte Zeile zurückgegeben. 

Lass uns beweisen, dass die Linie so funktioniert, wie sie sollte:

df.iloc[1:4]

Auswählen einer einzelnen Spalte mit .iloc

Die Logik der Spaltenauswahl mit .iloc folgt dem, was wir bisher gelernt haben. Schauen wir uns an, wie das für einzelne Spalten, mehrere Spalten und Spaltenscheiben funktioniert.

Genau wie bei .loc ist es wichtig, die row_indexer anzugeben, bevor wir mit column_indexer fortfahren 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]

Auswählen mehrerer Spalten mit .iloc

Um mehrere Spalten auszuwählen, die nicht unbedingt aufeinander folgen, können wir wieder eine Liste mit ganzen Zahlen 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 die Name sowie die Age der einzelnen Kunden:

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

Auswählen eines Spaltenabschnitts mit .iloc

Für die Scheibenauswahl mit .iloc folgt die Logik von column_indexer der von row_indexer. Die Spalte, die durch die Ganzzahl nach dem Doppelpunkt repräsentiert wird, wird in der Ausgabe nicht berücksichtigt. Um die zweite und dritte Spalte abzurufen, sollte die Codezeile wie folgt aussehen: df.iloc[:, 1:3].

In der folgenden Zeile findest du alle geografischen Informationen, die wir über unsere Kunden haben:

df.iloc[:, 1:3]

Kombinierte Zeilen- und Spaltenauswahl mit .iloc

Wir können das, was wir über .iloc gelernt haben, nutzen, um Zeilen- und Spaltenauswahl zu kombinieren. Auch hier ist es möglich, entweder eine einzelne Zelle oder einen Sub-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 Indexer als Liste mit eckigen Klammern oder als Slice mit Doppelpunkt angeben. Wenn wir Zeilen mit Hilfe von bedingten Ausdrücken auswählen wollen, ist das technisch auch mit .iloc möglich, wird aber nicht empfohlen. Die Verwendung der Labelnamen und .loc ist normalerweise viel intuitiver und weniger fehleranfällig.

Dieses letzte Beispiel zeigt Country, Region und Age für die erste, zweite und fünfte Zeile in unserem DataFrame an:

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

.iloc vs .loc: Wann man was verwendet

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

• Verwende .loc wenn du weißt, dass die Beschriftungen (Namen) der Zeilen/Spalten kennst.
• Verwende .iloc , wenn du die ganzzahligen Positionen der Zeilen/Spalten kennst .

Einige Szenarien begünstigen entweder .loc oder .iloc von Natur aus. So ist es zum Beispiel einfacher und intuitiver, über Zeilen oder Spalten zu iterieren, wenn du ganze Zahlen verwendest und nicht Labels. Wie wir bereits erwähnt haben, ist das Filtern von Zeilen auf der Grundlage von Bedingungen für Spaltenwerte weniger fehleranfällig, wenn du die Namen der Spaltenbezeichnungen verwendest.

KeyError, NameError und Indexfehler mit .loc und .iloc

Werfen wir einen Blick auf mögliche Probleme. Ein häufiger Fallstrick bei der Verwendung von .loc ist die KeyError. Dieser Fehler tritt auf, wenn wir versuchen, auf eine Zeilen- oder Spaltenbeschriftung zuzugreifen, die in unserem DataFrame nicht vorhanden ist. Um dies zu vermeiden, müssen wir immer sicherstellen, dass die von uns verwendeten Beschriftungen korrekt sind und mit den vorhandenen Beschriftungen in deinem DataFrame übereinstimmen, und sie auf Tippfehler überprüfen.

Außerdem ist es wichtig, die mit .loc angegebenen Bezeichnungen immer in Anführungszeichen zu setzen. Wer sie vergisst, bekommt eine NameError zurück.

Bei der Verwendung von .iloc kann IndexError auftreten, wenn wir eine Ganzzahlposition angeben, die außerhalb des gültigen Bereichs der Indizes unseres DataFrames liegt. Das passiert, wenn der Index, auf den du zuzugreifen versuchst, nicht existiert, entweder weil er die Anzahl der Zeilen oder Spalten in deinem DataFrame übersteigt oder weil er ein negativer Wert ist. Um diesen Fehler zu vermeiden, überprüfe die Abmessungen deines DataFrame und verwende geeignete Indexwerte innerhalb des gültigen Bereichs.

Fazit

Ich hoffe, dieser Blog war hilfreich und der Unterschied zwischen .loc und .iloc ist inzwischen klar. Wenn du mehr wissen willst, findest du hier einige gute Tipps für die nächsten Schritte:

• SettingWithCopyWarning in Pandas: Wie man diese Warnung behebt
• Kurs: Datenbearbeitung mit Pandas
• Kurs: Effizienter Code mit Pandas schreiben
• Spickzettel: Data Wrangling mit Pandas
• Spickzettel: Daten mit Pandas umgestalten