Iloc vs Loc in Pandas: een gids met voorbeelden

Een van die lastige dingen waar we allemaal achter proberen te komen als we Pandas leren, is het verschil tussen .loc en .iloc.

Laten we een einde maken aan die verwarring en het verschil tussen deze twee methoden verduidelijken. Ik geef genoeg voorbeelden, en hopelijk is het onderscheid aan het einde van deze blog een stuk duidelijker.

Wat zijn .loc en .iloc in Pandas?

Zowel .loc als .iloc zijn essentiële attributen van Pandas DataFrames en beide worden gebruikt om specifieke subsets van data te selecteren. Hun doel is toegang te krijgen tot en het manipuleren mogelijk te maken van een specifiek deel van het DataFrame in plaats van het hele DataFrame. 

Zoals we in de tabel zien, lijkt de syntax sterk op elkaar. Het verschil zit in hoe we de argumenten row_indexer en column_indexer gebruiken. Dat komt doordat de twee methoden verschillende manieren van indexeren bieden: .loc indexeert op basis van labelnamen, terwijl .iloc de numerieke positie-index van rijen en kolommen als argumenten neemt.

Laten we elk van de twee methoden in detail bekijken, beginnend met .loc.

.loc gebruiken: selecteren op labels

Om de concepten te illustreren, bekijken we een hypothetische klantendatabase die wordt weergegeven door dit DataFrame genaamd df, waarbij de Customer ID de rij-index voorstelt:

Er zijn vier primaire manieren om rijen te selecteren met .loc. Dit zijn:

• Eén enkele rij selecteren
• Meerdere rijen selecteren
• Een reeks rijen selecteren
• Conditionele rijselectie

Een enkele rij selecteren met .loc

Om een enkele rij te selecteren, gebruiken we het label van de rij die we willen ophalen als row_indexer. De syntax ziet er dus zo uit: df.loc['row_label']. Laten we dit gebruiken om alle informatie van onze klant Ali Khan te tonen:

df.loc['C345']

Meerdere rijen selecteren met .loc

Als we meerdere rijen willen selecteren die niet per se op elkaar volgen, moeten we een lijst met hun rijlabels doorgeven als het argument row_indexer. Dit betekent dat we niet één maar twee paar vierkante haken gebruiken: één voor de reguliere .loc-syntax en één voor de labellijst.

De regel df.loc[['row_label_1', 'row_label_2']] geeft de twee rijen van het DataFrame df terug die in de lijst zijn opgegeven. Stel dat we niet alleen de informatie over Ali Khan wilden weten, maar ook over David Lee:

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

Een reeks rijen selecteren met .loc

We kunnen een bereik aan rijen selecteren door het eerste en laatste rijlabel door te geven met een dubbele punt ertussen: df.loc['row_label_start':'row_label_end']. We zouden de eerste vier rijen van ons DataFrame als volgt kunnen tonen:

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

Twee dingen om hier in gedachten te houden:

1. De output bevat de rij die is opgegeven in row_label_end. Dit is anders bij .iloc, waar we later op ingaan.
2. We gebruiken slechts één paar vierkante haken, ook al willen we meerdere rijen ophalen. We gebruiken geen lijst om de verschillende rijen te specificeren, dus twee vierkante haken gebruiken levert een SyntaxError op.

Conditionele selectie van rijen met .loc

We kunnen ook rijen teruggeven op basis van een conditionele expressie. We kunnen alle rijen filteren op de vraag of ze wel of niet aan een bepaalde voorwaarde voldoen en alleen die tonen die dat doen.

De bijbehorende syntax is df.loc[conditional_expression], waarbij de conditional_expression een uitspraak is over de toegestane waarden in een specifieke kolom.

Voor kolommen met niet-numerieke data (zoals Name of Country) kan de uitspraak alleen de gelijk- of ongelijk-operator gebruiken, omdat er geen volgorde tussen de waarden is. We zouden bijvoorbeeld alle rijen kunnen teruggeven van klanten die niet uit Azië komen:

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

Eén enkele kolom selecteren met .loc

Om kolommen te selecteren, moeten we het argument column_indexer opgeven, dat na het argument row_indexer komt. Als we alleen de column_indexer willen opgeven, moeten we op de een of andere manier aangeven dat we alle rijen willen teruggeven en alleen op de kolommen willen filteren. Laten we kijken hoe we dat doen!

Een enkele kolom selecteren kan door de column_indexer op te geven met het label van de betreffende kolom. Om alle rijen op te halen, moeten we de row_indexer specificeren met een simpele dubbele punt. We komen uit op een syntax die er zo uitziet: df.loc[:, 'column_name'].

Laten we de Name van elke klant tonen:

df.loc[:, 'Name']

Meerdere kolommen selecteren met .loc

Net als bij het selecteren van meerdere rijen, moeten we een lijst met kolomlabels doorgeven als we meerdere kolommen van een DataFrame willen teruggeven die niet per se op elkaar volgen: df.loc[:, [col_label_1, 'col_label_2']].

Als we aan onze laatste output de Age van alle klanten wilden toevoegen, zou dat zo werken:

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

Een kolommenreeks selecteren met .loc

Door een dubbele punt te gebruiken tussen de labels van twee kolommen selecteer je alle kolommen in het volgordebereik tussen de twee opgegeven kolommen. Dit is inclusief de eindkolom, wat betekent dat de kolom met de naam col_end ook wordt geselecteerd in de standaardsyntax, die als volgt is: df.loc[:, 'col_start':'col_end'].

Als we geïnteresseerd waren in de Name, Country en Region van onze klanten, zou onze codelijn kunnen zijn:

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

Gecombineerde rij- en kolomselectie met .loc

Het is ook mogelijk om zowel de row_indexer als de column_indexer op te geven. Dit kan worden gebruikt om één enkel stuk informatie op te halen, oftewel één cel uit het DataFrame. Hiervoor specificeren we één rij en één kolom met de syntax df.loc['row_label', 'column_name'] .

Het nuttigere geval is om een sub-DataFrame terug te geven dat precies focust op de set rijen en kolommen waarin we geïnteresseerd zijn. Het is mogelijk om beide indexers als lijsten op te geven met vierkante haken, of als een slice met de dubbele punt, en zelfs te combineren met een conditionele expressie voor de rijselectie.

Hier is een voorbeeld waarbij we de Name, Country en Region teruggeven van elke klant met een Age boven de 30:

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

.iloc gebruiken: selecteren op integerpositie

.iloc selecteert op positie in plaats van op label. Dit is de standaardsyntax voor het gebruik van .iloc: df.iloc[row_indexer, column_indexer]. Er zijn twee speciale dingen om op te letten:

• Tellen begint bij 0: de eerste rij en kolom hebben index 0, de tweede index 1, enzovoort.
• Exclusiviteit van de eindwaarde van een bereik: bij een slice wordt de rij of kolom die na de dubbele punt is gespecificeerd niet in de selectie opgenomen.

Eén enkele rij selecteren met .iloc

Een enkele rij kan worden geselecteerd door het geheel getal te gebruiken dat het rijindexnummer vertegenwoordigt als de row_indexer. We hebben geen aanhalingstekens nodig omdat we een geheel getal invoeren en geen labelstring zoals bij .loc. Om de eerste rij van een DataFrame genaamd df terug te geven, voer je df.iloc[0] in.

In ons voorbeeld-DataFrame geeft precies deze codelijn de informatie van John Doe terug:

df.iloc[0]

Meerdere rijen selecteren met .iloc

Meerdere rijen selecteren werkt in .iloc zoals in .loc—we voeren de rijindexgetallen in een lijst met vierkante haken in. De syntax ziet er zo uit: df.iloc[[0, 3, 4]].

De bijbehorende output in onze klantentabel zie je hieronder:

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

Een reeks rijen selecteren met .iloc

Voor het selecteren van een slice van rijen gebruiken we een dubbele punt tussen twee opgegeven rijindexgetallen. Nu moeten we letten op de eerder genoemde exclusiviteit. 

We kunnen de regel df.iloc[1:4] als voorbeeld nemen om dit concept te illustreren. Indexnummer 1 betekent de tweede rij, dus onze slice begint daar. Het indexgetal 4 staat voor de vijfde rij – maar omdat .iloc niet inclusief is bij slice-selectie, bevat onze output alle rijen tot en met de rij ervoor. Daarom geeft het de tweede, derde en vierde rij terug. 

Laten we bewijzen dat de regel werkt zoals het hoort:

df.iloc[1:4]

Eén enkele kolom selecteren met .iloc

De logica van het selecteren van kolommen met .iloc volgt wat we tot nu toe hebben geleerd. Laten we bekijken hoe het werkt voor enkele kolommen, meerdere kolommen en kolomslices.

Net als bij .loc is het belangrijk om de row_indexer te specificeren voordat we naar de column_indexer gaan. Om de waarden van de derde kolom van df voor elke rij op te halen, voeren we df.iloc[:, 2] in.

Omdat Region de derde kolom in ons DataFrame is, wordt die als gevolg van die codelijn opgehaald:

df.iloc[:, 2]

Meerdere kolommen selecteren met .iloc

Om meerdere kolommen te selecteren die niet per se opeenvolgend zijn, kunnen we opnieuw een lijst met gehele getallen invoeren als de column_indexer. De regel df.iloc[:, [0, 3]] geeft zowel de eerste als de vierde kolom terug. 

In ons geval worden de Name en de Age van elke klant getoond:

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

Een kolomslice selecteren met .iloc

Voor slice-selectie met .iloc volgt de logica van de column_indexer die van de row_indexer. De kolom die wordt weergegeven door het getal na de dubbele punt is niet in de output opgenomen. Om de tweede en derde kolom op te halen, moet de codelijn er zo uitzien: df.iloc[:, 1:3].

De onderstaande regel geeft alle geografische informatie terug die we over onze klanten hebben:

df.iloc[:, 1:3]

Gecombineerde rij- en kolomselectie met .iloc

We kunnen combineren wat we over .iloc hebben geleerd om rij- en kolomselectie te combineren. Opnieuw is het mogelijk om ofwel één cel of een sub-DataFrame terug te geven. Om de enkele cel op het snijpunt van rij 3 en kolom 4 terug te geven, voeren we df.iloc[2, 3] in.

Net als bij .loc kunnen we beide indexers als lijsten specificeren met de vierkante haken, of als een slice met de dubbele punt. Als we rijen willen selecteren met conditionele expressies, is dat technisch gezien ook mogelijk met .iloc, maar niet aan te raden. De labelnamen en .loc gebruiken is meestal veel intuïtiever en minder foutgevoelig.

Dit laatste voorbeeld toont Country, Region en Age voor de eerste, tweede en vijfde rij in ons DataFrame:

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

.iloc vs .loc: wanneer gebruik je welke

In het algemeen is er één simpele vuistregel waarbij de methodekeuze afhangt van je kennis van het DataFrame:

• Gebruik .loc wanneer je de labels (namen) van de rijen/kolommen kent.
• Gebruik .iloc wanneer je de integerposities van de rijen/kolommen kent.

Sommige scenario’s zijn van nature geschikter voor .loc of .iloc. Zo is itereren over rijen of kolommen eenvoudiger en intuïtiever met gehele getallen dan met labels. Zoals we al noemden, is het filteren van rijen op basis van voorwaarden op kolomwaarden minder foutgevoelig met de kolomlabelnamen.

KeyError, NameError en IndexError met .loc en .iloc

Laten we mogelijke problemen bekijken. Een veelvoorkomende valkuil bij het gebruik van .loc is een KeyError. Deze fout treedt op wanneer we proberen een rij- of kolomlabel te benaderen dat niet in ons DataFrame voorkomt. Om dit te voorkomen, moeten we er altijd voor zorgen dat de labels die we gebruiken kloppen en overeenkomen met de bestaande labels in je DataFrame, en dubbelchecken op typefouten.

Daarnaast is het belangrijk om altijd aanhalingstekens te gebruiken voor de labels die je met .loc opgeeft. Als je die vergeet, krijg je een NameError.

Een IndexError kan optreden bij het gebruik van .iloc als we een integerpositie opgeven die buiten het geldige bereik van de indexen van ons DataFrame ligt. Dit gebeurt wanneer de index die je probeert te benaderen niet bestaat, omdat die ofwel voorbij het aantal rijen of kolommen in je DataFrame ligt of omdat het een negatieve waarde is. Om deze fout te voorkomen, controleer de afmetingen van je DataFrame en gebruik passende indexwaarden binnen het geldige bereik.

Conclusie

Ik hoop dat deze blog nuttig was en dat het verschil tussen .loc en .iloc nu duidelijk is. Wil je meer leren, dan zijn dit goede vervolgstappen:

• SettingWithCopyWarning in Pandas: zo los je deze waarschuwing op
• Cursus: Data Manipulation with pandas
• Cursus: Writing Efficient Code with pandas
• Cheat sheet: Data wrangling met pandas
• Cheat sheet: Data reshapen met pandas