Iloc vs Loc in Pandas: Een Gids Met Voorbeelden

Een van die vervelende dingen waar we allemaal proberen achter te komen wanneer we Pandas leren, is het onderscheid tussen .loc en .iloc.

Laten we een einde maken aan deze verwarring en het verschil tussen deze twee methoden verduidelijken. Ik geef veel voorbeelden, en ik hoop dat het onderscheid aan het einde van deze blog veel duidelijker zal zijn.

Wat zijn .loc en .iloc in Pandas?

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

Zoals we kunnen zien in de tabel, lijkt de syntaxis erg op elkaar. Het verschil ligt in hoe we de row_indexer en column_indexer argumenten gebruiken. Dit komt omdat de twee methoden verschillende benaderingen bieden voor het indexeren van de gegevens: terwijl .loc indexeert op basis van labelnamen, neemt .iloc de numerieke positie-index van rijen en kolommen als argumenten.

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

Gebruik maken van .loc: Selectie op Labels

Om de concepten te illustreren, laten we een hypothetische klantendatabase overwegen die wordt weergegeven door deze DataFrame genaamd df, waarbij de Klant ID de rij-index i vertegenwoordigt:indext:

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

• Een enkele rij selecteren
• Het selecteren van meerdere rijen
• Het selecteren van een reeks rijen
• Conditionele rijselectie

Het selecteren van een enkele rij met behulp van .loc

Om een enkele rij te selecteren, gebruiken we het label van de rij die we willen ophalen als rij_indexer. Dienovereenkomstig ziet de syntaxis er als volgt uit: df.loc['rij_label']. Laten we dit gebruiken om alle informatie over onze klant Ali Khan weer te geven:

df.loc['C345']

Meerdere rijen selecteren met .loc

Als we meerdere rijen willen selecteren die niet noodzakelijkerwijs op volgorde volgen, moeten we een lijst van hun rijlabels doorgeven als het row_indexer argument. Dit betekent dat we niet één maar twee paren haakjes moeten gebruiken: één voor de reguliere .loc syntaxis en één voor de labellijst.

De regel df.loc[['row_label_1', 'row_label_2']] zal de twee rijen van de df DataFrame retourneren die in de lijst zijn gespecificeerd. Laten we zeggen dat we niet alleen de informatie over Ali Khan willen weten, maar ook over David Lee:

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

Selecteren van een reeks rijen met .loc

We kunnen een reeks rijen selecteren door de eerste en laatste rijlabels door te geven met een dubbele punt ertussen: df.loc['rijlabel_start':'rijlabel_einde']. We kunnen de eerste vier rijen van onze DataFrame als volgt weergeven:

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

Hier zijn twee dingen om in gedachten te houden:

1. De uitvoer bevat de rij die is gespecificeerd in row_label_end. Dit is anders in .iloc, waar we later op terug zullen komen.
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 het gebruik van twee paar vierkante haken zou een SyntaxError opleveren.

Conditionele selectie van rijen met .loc

We kunnen ook rijen retourneren op basis van een conditionele expressie. We kunnen alle rijen filteren op basis van of ze al dan niet aan een bepaalde voorwaarde voldoen en alleen degenen weergeven die dat wel doen.

De bijbehorende syntaxis is df.loc[conditionele_uitdrukking], waarbij de conditionele_uitdrukking een verklaring is over de toegestane waarden in een specifieke kolom.

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

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

Een enkele kolom selecteren met .loc

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

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

Laten we de Naam van elke klant weergeven:

df.loc[:, 'Name']

Meerdere kolommen selecteren met .loc

Vergelijkbaar met het selecteren van meerdere rijen, moeten we een lijst van kolomlabels doorgeven als we meerdere kolommen van een DataFrame willen retourneren die niet noodzakelijkerwijs op volgorde volgen: df.loc[:, [col_label_1, 'col_label_2']].

Aangenomen dat we alle klanten Leeftijd aan onze laatste uitvoer wilden toevoegen, zou het als volgt werken:

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

Een deel van de kolommen selecteren met .loc

Door een dubbele punt tussen de labels van twee kolommen te gebruiken, worden alle kolommen geselecteerd in het bereik tussen de twee gespecificeerde kolommen. Dit is inclusief de eindkolom, wat betekent dat de kolom met de naam col_end ook zal worden geselecteerd in de standaard syntaxis, die als volgt is: df.loc[:, 'col_start':'col_end'].

Als we geïnteresseerd zijn in de Naam, Land en Regio van onze klanten, zou onze code regel 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 een enkel stuk informatie op te halen, wat betekent dat we één cel uit de DataFrame halen. Om dit te doen, geven we één rij en één kolom op met de syntaxis df.loc['row_label', 'column_name'] .

De nuttigere situatie is om een sub-DataFrame terug te geven die zich precies richt op de set van rijen en kolommen waarin we geïnteresseerd zijn. Het is mogelijk om beide indexers op te geven als lijsten met behulp van vierkante haken, of als een slice met behulp van de dubbele punt, en zelfs te combineren met een voorwaardelijke expressie voor de rijselectie.

Hier is een voorbeeld van het teruggeven van de Naam, Land en Regio van elke klant met een Leeftijd van meer dan 30:

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

Gebruik makend van .iloc: Selectie op basis van gehele positie

.iloc selecteert op basis van positie in plaats van label. Dit is de standaard syntaxis 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 de index 0, de tweede index 1, enzovoort.
• Exclusiviteit van het eindwaarde van het bereik: Wanneer je een slice gebruikt, wordt de rij of kolom die achter de dubbele punt is opgegeven niet in de selectie opgenomen.

Een enkele rij selecteren met .iloc

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

In ons voorbeeld DataFrame geeft deze code regel de informatie van John Doe terug:

df.iloc[0]

Selecteren van meerdere rijen met .iloc

Hetzelfde als bij .loc, kunnen we bij .iloc meerdere rijen selecteren door de rij-indexen in een lijst met vierkante haken in te voeren. De syntax ziet er zo uit: df.iloc[[0, 3, 4]].

Hieronder is de bijbehorende uitvoer in onze klantentabel te zien:

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

Selecteren van een reeks rijen met .iloc

Voor het selecteren van een reeks rijen gebruiken we een dubbele punt tussen twee gespecificeerde rij-indexgetallen. 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 reeks begint daar. Het indexgetal 4 vertegenwoordigt de vijfde rij – maar omdat .iloc niet inclusief is voor de selectie van een reeks, zal onze uitvoer alle rijen bevatten tot aan de laatste vóór deze. Daarom zal het de tweede, derde en vierde rij teruggeven. 

Laten we bewijzen dat de regel werkt zoals het hoort:

df.iloc[1:4]

Een enkele kolom selecteren met .iloc

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

Net als bij .loc is het belangrijk om de row_indexer aan te geven voordat we verder kunnen gaan met de column_indexer. 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 is in onze DataFrame, zal het als gevolg van die code-regel worden opgehaald:

df.iloc[:, 2]

Meerdere kolommen selecteren met .iloc

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

In ons geval zijn de weergegeven informatie de Naam en de Leeftijd van elke klant:

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

Een deel van kolommen selecteren met .iloc

Voor het selecteren van een slice met .iloc volgt de logica van de column_indexer die van de row_indexer. De kolom die wordt weergegeven door het gehele getal na de dubbele punt is niet inbegrepen in de output. Om de tweede en derde kolommen op te halen, moet de code er als volgt uitzien: df.iloc[:, 1:3].

Deze regel hieronder retourneert alle geografische informatie die we hebben over onze klanten:

df.iloc[:, 1:3]

Gecombineerde rij- en kolomselectie met .iloc

We kunnen samenvoegen wat we hebben geleerd over .iloc om rij- en kolomselectie te combineren. Het is opnieuw mogelijk om een enkele cel of een sub-DataFrame terug te geven. Om de enkele cel op de kruising van rij 3 en kolom 4 te retourneren, voeren we df.iloc[2, 3] in.

Net als bij .loc kunnen we beide indexers als lijsten specificeren met behulp van de vierkante haakjes, of als een slice met behulp van de dubbele punt. Als we rijen willen selecteren met behulp van voorwaardelijke expressies, is dat technisch ook mogelijk met .iloc, maar niet aanbevolen. Het gebruik van de labelnamen en .loc is meestal veel intuïtiever en minder foutgevoelig.

Dit laatste voorbeeld toont Land, Regio en Leeftijd voor de eerste, tweede en vijfde rij in onze DataFrame:

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

.iloc vs .loc: Wanneer te gebruiken welke

Over het algemeen is er één eenvoudige vuistregel waarbij de keuze van de methode afhangt van uw kennis van de DataFrame:

• Gebruik .loc wanneer u de labels (namen) van de rijen/kolommen kent.
• Gebruik .iloc wanneer je de gehele posities van de rijen/k kolommen kent.

Sommige scenario’s geven de voorkeur aan .loc of .iloc vanwege hun aard. Bijvoorbeeld, het itereren over rijen of kolommen is gemakkelijker en intuïtiever met gehele getallen dan met labels. Zoals we al eerder hebben genoemd, is het filteren van rijen op basis van voorwaarden op kolomwaarden minder foutgevoelig met de kolomlabelnamen.

KeyError, NameError en Indexfout bij .loc en .iloc

Laten we mogelijke problemen bekijken. Een veelvoorkomende valkuil bij het gebruik van .loc is het tegenkomen van een KeyError. Deze fout treedt op wanneer we proberen toegang te krijgen tot een rij- of kolomlabel dat niet bestaat binnen onze DataFrame. Om dit te voorkomen, moeten we er altijd voor zorgen dat de labels die we gebruiken accuraat zijn en overeenkomen met de bestaande labels in je DataFrame en om te controleren op typfouten.

Bovendien is het belangrijk om altijd aanhalingstekens te gebruiken voor de labels die worden gespecificeerd met .loc. Vergeten van aanhalingstekens zal een NameError opleveren.

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

Conclusie

Ik hoop dat deze blog nuttig is geweest en dat het onderscheid tussen .loc en .iloc nu duidelijk is. Om meer te leren, zijn hier enkele goede vervolgstappen:

• SettingWithCopyWarning in Pandas: Hoe dit waarschuwing te verhelpen
• Cursus: Gegevensmanipulatie met pandas
• Cursus: Efficiënte Code Schrijven met pandas
• Spiekbriefje: Gegevensverwerking met pandas
• Spiekbriefje: Gegevens herschikken met pandas