5 tips om idiomatische Pandas-code te schrijven

Natuurlijk is deze tutorial zeker niet uitputtend; Het Pandas-pakket is erg rijk en er zijn ongetwijfeld nog andere manieren waarop je je Pandas-code idiomatischer kunt maken.

Laten we niet langer wachten en aan de slag gaan!

# If you're working with a notebook, don't forget to use Matplotlib magic! 
%matplotlib inline

# Import pandas under the alias pd import pandas as pd # Import seaborn under the alias sns import seaborn as sns # Set the Seaborn theme if desired sns.set_style('darkgrid')

# Import Times Higher Education World University Rankings data
times_df = pd.read_csv('data/timesData.csv', thousands=",")

# Import Academic Ranking of World Universities data
shanghai_df = pd.read_csv('data/shanghaiData.csv')

Onze tips voor idiomatische Pandas-code

1. Indexeren

Meer idiomatische Pandas-code schrijven betekent om te beginnen dat je de kracht van indexeren benut. Indexeren betekent dat je subsets uit je DataFrame selecteert.

Als je net begint met Pandas, heb je misschien even tijd nodig om te wennen aan hoe indexen werken. Als je al met (Python-)lijsten hebt gewerkt, ben je waarschijnlijk bekend met het gebruik van blokhaken [] in combinatie met een dubbelepunt : om elementen te selecteren. Deze methode werkt ook op DataFrames.

Bovendien zijn er nog twee andere, meer idiomatische manieren om een subset van een DataFrame te selecteren: iloc en loc:

• loc is label-gebaseerd. Dit betekent dat als je loc[2] schrijft, je zoekt naar de waarden in je DataFrame met een index die gelabeld is als 2.
• iloc is positie-gebaseerd. Dit betekent dat als je iloc[2] schrijft, je zoekt naar de waarden die op positie 2 staan.

Probeer dit uit in het DataCamp Light-blok hieronder door times_df.loc[2] en times_df.iloc[2] in de IPython-console te typen om het verschil te zien. Los daarna de oefening hieronder op met behulp van loc, iloc en de traditionele blokhaken!

Natuurlijk kan je verkenning veel verder gaan dan alleen rijen en kolommen subsetten of selecteren. Het wordt pas echt interessant wanneer je loc en iloc bijvoorbeeld combineert met booleaanse arrays.

Je ziet dat dit wat verder gaat dan selecteren op basis van kolommen of indexeren; Het lijkt meer op het bevragen van je data!

loc en iloc zijn geweldig om je data te indexeren, maar wees voorzichtig als je twee sets blokhaken achter elkaar gebruikt! Pandas kan dan een kopie van een view teruggeven en in zulke gevallen weet je niet meer precies waarmee je werkt! Denk dus twee keer na als je twee sets blokhaken combineert met loc of iloc.

Let op dat Pandas om je data te bevragen ook de functie query() biedt, waarmee je je data snel kunt inspecteren (beschikbaar sinds versie 0.13). Je kunt bijvoorbeeld een query samenstellen om te zien welke universiteiten een total_score net onder de 50 hebben:

Natuurlijk zijn er nog veel meer mogelijkheden om je data te bevragen! Waarom bedenk je niet een paar queries en test je die in de IPython-console van het bovenstaande DataCamp Light-blok?

Heb je even geen inspiratie, probeer dan queries die de universiteiten met een eerste nationale rang en universiteiten met een eerste wereldrang teruggeven. Daarnaast kun je de alumnicijfers van de universiteiten opvragen.

Weet je niet goed hoe je de queries moet samenstellen? Bekijk dan enkele voorbeelden hieronder:

shanghai_df.query("national_rank == 1 and world_rank == 1")
shanghai_df.query("alumni < 20")

2. Method chaining

Method chaining is iets typisch voor Pandas, maar als je net begint met dit Python-pakket voor datamanipulatie, is het misschien niet meteen duidelijk hoe dit precies werkt. In de kern roep je methodes na elkaar aan op een object.

In deze sectie ga je dieper in op method chaining door datapijplijnen te maken met pipe().

Zoals je al gemerkt hebt, verschillen de datasets behoorlijk. Enkele verschillen:

• De Times-dataset heeft 14 kolommen, terwijl die van Shanghai er 11 heeft
• De Times-dataset heeft 2603 rijen, terwijl die van Shanghai er 4897 heeft
• Een belangrijke ontbrekende kolom in de Shanghai-dataset is het land van de universiteit. Deze informatie kun je later indien nodig uit de Times-dataset halen.

Om beide DataFrames te kunnen gebruiken, moeten we dus alleen de gemeenschappelijke kolommen selecteren. Hopelijk hebben deze kolommen vergelijkbare inhoud.

De gemeenschappelijke kolommen zijn dus:

• total_score: score die gebruikt wordt om de rang te bepalen. Zoals vermeld op de Kaggle-beschrijvingspagina, bevat dit bereik-rangen (dus tussen twee waarden) en gelijke rangen (er staat een =-teken voor)
• university_name: naam van de universiteit
• world_rank: rang van de universiteit
• year: jaar waarop de ranking betrekking heeft

Om beide datasets te concateneren, moeten we eerst wat opschonen. Pas nu de volledige pipeline toe om de data op te schonen:

Zoals je waarschijnlijk hebt gemerkt, gebruik ik de methode .pipe vaak in deze tutorial. Als je uit de R-wereld komt, ben je er waarschijnlijk (enigszins) mee vertrouwd.

Het is een handige nieuwe Pandas-methode (sinds versie 0.16.2) die je in staat stelt bewerkingen te chainen en zo de noodzaak voor tussentijdse DataFrames wegneemt. Je code wordt leesbaarder.

Feitelijk zou je zonder deze operator, in plaats van df.pipe(f).pipe(g).pipe(h) te schrijven: h(g(f(df))) schrijven. Dit wordt lastiger te volgen naarmate het aantal geneste functies toeneemt.

Wil je hier meer over leren, lees dan zeker deze blogpost.

Nu beide DataFrames opgeschoond zijn, kunnen we ze concurreren tot één DataFrame. Vergeet ook niet de ontbrekende data op te schonen:

Aangezien je ongeveer 38% ontbrekende data hebt in de kolom total_score, kun je die kolom beter droppen met de methode .drop.

3. Geheugenoptimalisatie

Een derde manier om je Pandas-code meer “idiomatisch” te maken —wat hier neerkomt op “performant”— is door het geheugengebruik te optimaliseren. Zeker wanneer je datapijplijnen maakt met method chaining, zul je merken dat geheugen een grote rol kan spelen in hoe snel je pipelines draaien. Hier zie je daar meer over.

Dit is waarschijnlijk overkill voor deze kleine dataset, maar het is vaak een goede gewoonte om sommige kolommen naar specifieke types te casten om het geheugengebruik te optimaliseren. Laten we eerst uitzoeken hoeveel geheugen is toegewezen voor ranking_df met behulp van de methode .info.

Het resultaat van de eerste regel code vertelt ons dat de data 144 KB inneemt. Maar als je de argumenten van de methode .info bekijkt, zie je dat er een optioneel argument is, namelijk memory_usage, dat standaard op None staat. Wat gebeurt er als je memory_usage op deep zet?

De nieuwe geheugenvoetafdruk is 6 keer —5,6 om precies te zijn— groter dan je eerste antwoord.

Wat is hier gebeurd?

Het verschil in geheugenschatting komt doordat Pandas zonder de “deep”-vlag het geheugengebruik voor het dtype object niet inschat. Dit (Python-)type data neemt meer ruimte in dan andere geoptimaliseerde numpy-dtypes. Daarom is het aan te bevelen om object-types te casten naar passender types (bijvoorbeeld category bij categorische data).

Dat gaan we doen!

def memory_change(input_df, column, dtype):
    df = input_df.copy()
    old = round(df[column].memory_usage(deep=True) / 1024, 2) # In KB
    new = round(df[column].astype(dtype).memory_usage(deep=True) / 1024, 2)# In KB
    change = round(100 * (old - new) / (old), 2)
    report = ("The inital memory footprint for {column} is: {old}KB.\n" 
              "The casted {column} now takes: {new}KB.\n"
              "A change of {change} %.").format(**locals())
    return report

print(memory_change(ranking_df,'world_rank', 'int16'))
print(memory_change(ranking_df,'university_name', 'category'))
print(memory_change(ranking_df,'name', 'category'))

Nu je weet dat je door bijvoorbeeld world_rank te veranderen naar int16 je geheugen efficiënter gebruikt, is het tijd om deze wijzigingen ook echt toe te passen. Je kunt hiervoor de functie astype() gebruiken. Eindig met een dubbele check van je huidige geheugengebruik:

Dat is al een stuk beter. Je kunt nog verder optimaliseren door de kolom year te casten naar int32.

4. GroupBy

Nu we een goed gevormde dataset hebben (dus in een tidy-staat) met een geoptimaliseerde geheugenvoetafdruk, kan de data-analyse beginnen.

Er zijn nu enkele vragen die je misschien wilt beantwoorden:

• Wat zijn de top 5 universiteiten volgens elk rankingsysteem door de jaren heen?
• Hoe verschillen deze rankings per jaar?

Laten we de eerste vraag aanpakken met behulp van de meer idiomatische Pandas-tips die je in de vorige secties hebt gezien!

Voordat je begint: ‘Massachusetts Institute of Technology (MIT)’ en ‘Massachusetts Institute of Technology’ zijn twee verschillende records van dezelfde universiteit. Pas daarom de eerste naam aan naar de tweede.

Merk op dat in dit soort gevallen de functie loc, die je eerder in deze tutorial hebt gezien, bijzonder handig is!

Om de 5 (algemener n) topuniversiteiten over de jaren te vinden, voor elk rankingsysteem, kun je dit in pseudo-code doen:

• Voor elk jaar (in de kolom year) en voor elk rankingsysteem (in de kolom name):
• Selecteer de subset van de data voor dit jaar en dit rankingsysteem
• Selecteer de top 5 universiteiten en sla ze op in een lijst
• Sla het resultaat op in een dictionary met (year, name) als key en de lijst met universiteiten (in aflopende volgorde) als value

Laten we dit toepassen.

Nu we deze ranking-dictionary hebben, gaan we uitzoeken hoeveel (in procent) beide rankingmethodes door de jaren heen verschillen: de twee zijn 100% set-gelijk als de geselecteerde top 5 universiteiten hetzelfde zijn, ook al zijn ze niet in dezelfde volgorde gerankt.

Zoals je hebt gemerkt, was dit nogal omslachtig. Kan dit beter en idiomatischer met Pandas?

Natuurlijk! Filter eerst het ranking-DataFrame zodat je alleen de top 5 universiteiten per jaar en rankingmethode overhoudt. Bekijk het resultaat met de functie head():

Nu je het juiste DataFrame hebt om mee te werken, gebruik je de methode .groupby om beide rankingmethodes te vergelijken met de hierboven gedefinieerde set-similariteit.

Je krijgt dezelfde resultaten als hierboven, met minder gedoe.

5. Visualisatie

Nu je al wat eerste analyses van je datasets hebt gedaan, is het ook tijd om je data visueel te verkennen. Meer idiomatische Pandas-code betekent ook dat je gebruikmaakt van Pandas’ integratie met het Matplotlib-pakket voor plotten. Daardoor maak je in no-time mooie grafieken!

Voor deze sectie ga je terug naar de datasets times_df en shanghai_df om enkele basisvisualisaties met Matplotlib en Seaborn te maken.

Bovenstaande plot maakt meteen duidelijk dat er enkele 0-waarden zijn voor de kolom alumni. Dit is iets om zeker rekening mee te houden wanneer je je data verkent: met behulp van data profiling kun je dit soort 0-waarden zien en aanpakken. Wil je hier meer over weten, bekijk dan DataCamp’s Data Profiling Tutorial.

Of, als je waarden hebt die niet in je dataset thuishoren, kun je ze eenvoudig vervangen door NaN en vervolgens alle NaN-waarden uit de kolommen verwijderen die het plotten bemoeilijken. Let op dat dit slechts een snelle manier is om je data aan te passen en dat je waarschijnlijk een uitgebreidere data profiling-stap nodig hebt om je datakwaliteit echt te verbeteren, want je ziet in de plot hieronder nog steeds 0-waarden voor de kolom num_students:

Natuurlijk hoef je je niet te beperken tot Matplotlib om je data te visualiseren. Er zijn ook andere libraries waarmee je snel visualisaties kunt maken, zoals Seaborn.

De plotting-tool Seaborn wordt vooral gebruikt om statistische plots te maken die er visueel aantrekkelijk uitzien (zoals op de officiële website staat). Voor versie 2.0 van Matplotlib was het namelijk best een gedoe (hoewel mogelijk) om mooie plots te maken.

De combinatie van Pandas met Seaborn stelt je ook in staat snel over je data te itereren via visualisaties.

Laten we wat voorbeelden bekijken!

Bekijk de volgende plot, waarin je telt hoe vaak een specifiek land in je data voorkomt. Je neemt de eerste tien observaties en zorgt ervoor dat je de tellingen van hoog naar laag sorteert wanneer je de barplot maakt:

Vervolgens kun je deze landen en hun gemiddelde scores plotten:

Je plots kunnen ook vrij complex worden. Bekijk de volgende pairplot, die is bedoeld om de pairwise-relaties in een dataset duidelijker te laten zien:

import numpy as np

np.seterr(invalid='ignore')

sns.pairplot(times_df, hue='country')

plt.show()

Op dezelfde manier kun je deze combinatie van FacetGrid en regplot bekijken, die je inzicht geeft in de evolutie van de total_score door de jaren heen voor de top 5 landen:

Tot slot kan ook een correlatieplot handig zijn als je je data verkent. Je kunt hiervoor de functie heatmap() uit Seaborn gebruiken:

Je kunt eindeloos doorgaan met deze visualisaties, dus misschien is het goed om hier even te stoppen :)