Python-API’s onder de knie: een complete gids voor het bouwen en gebruiken van API’s in Python

API’s, of application programming interfaces, zijn de echte helden van moderne softwareontwikkeling. Ze maken communicatie tussen verschillende softwaresystemen mogelijk, waardoor je services kunt integreren en applicaties kunt bouwen. API’s beheersen is een belangrijke vaardigheid voor iedereen die met data in Python wil werken, zeker als je developer bent. Je zult versteld staan van de deuren die opengaan: zodra je deze skill beheerst, kun je webapplicaties bouwen, koppelen aan externe services of zelfs realtime data gebruiken in machinelearningprojecten.

In deze gids duiken we in de wereld van API’s: we leren hoe je ze gebruikt in Python, hoe je je eigen API bouwt met FastAPI en hoe je veelvoorkomende uitdagingen aanpakt die ongetwijfeld opduiken. Aan het einde van deze tutorial heb je een solide begrip van hoe je API’s in je projecten gebruikt, zodat je ontwikkelproces efficiënter wordt en je applicaties krachtiger. Voelt het op enig moment te veel? Probeer dan onze cursus Introduction to APIs in Python, waarin elk onderdeel tot in detail wordt behandeld.

Wat is een API?

Een API is als een brug tussen verschillende softwareapplicaties. Het laat deze applicaties met elkaar communiceren en informatie uitwisselen.

Stel je een API voor als een ober in een restaurant. Jij vertelt de ober wat je wilt (je bestelling), en die geeft je verzoek door aan de keuken. De keuken bereidt je eten en de ober brengt het terug. Op dezelfde manier stuur je een verzoek naar een API, die je verzoek verwerkt en vervolgens de resultaten terugstuurt.

Om dit concreter te maken, een paar echte toepassingen: je kunt bijvoorbeeld een publieke API gebruiken om financiële data op te halen voor een aandelenmarktanalyse of realtime weersdata in te lezen voor een klimaatvoorspellingsmodel. Zoals je merkt, zijn API’s vooral belangrijk bij grote datasets en/of als je realtime data nodig hebt; anders levert de integratie meestal weinig problemen op.

Hoe een Python-API werkt. Afbeelding door Napkin.AI

API’s gebruiken in Python

API’s gebruiken in Python is een krachtige manier om met externe services te communiceren, data op te halen en allerlei functionaliteit in je applicaties te integreren. Python maakt werken met API’s simpel en efficiënt, vooral via de requests-bibliotheek, waarmee je HTTP-verzoeken kunt sturen om met API’s te interageren.

Introductie tot API’s in Python

In Python is met API’s werken eenvoudig dankzij de requests-bibliotheek. Deze vereenvoudigt het versturen van HTTP-verzoeken, zodat je met API’s kunt communiceren en data kunt ophalen of versturen.

API-verzoeken doen in Python

Voordat je API-verzoeken kunt doen in Python, heb je de requests-bibliotheek nodig. Je installeert deze met het volgende commando:

pip install requests

De basis van API-verzoeken

Laten we ons restaurantvoorbeeld koppelen aan wat er in Python echt gebeurt. Hier is de vereenvoudigde opzet:

1. Vind de juiste plek: identificeer het API-endpoint, het specifieke webadres waar je je verzoek naartoe stuurt.

2. Plaats je bestelling: gebruik de requests-bibliotheek van Python om het verzoek naar de API te sturen. Je geeft aan welk type actie je wilt uitvoeren (zoals data ophalen of versturen).

3. Krijg je eten: de API stuurt een response terug, die je kunt verwerken om de informatie te halen die je nodig hebt.

GET-verzoeken

Een GET-verzoek is het meest gebruikte type HTTP-verzoek om data van een server op te halen, vergelijkbaar met informatie opvragen; als je een URL in je browser typt en op enter drukt, stuur je in feite een GET-verzoek naar die server, waarbij je de gewenste resource specificeert. De server verwerkt dit, zoekt en bereidt de gevraagde data, en stuurt die terug in een formaat zoals JSON of XML.

import requestsresponse = requests.get('https://api.example.com/data')data = response.json()print(data)

In dit voorbeeld sturen we een GET-verzoek naar een fictieve API en printen we de JSON-response. GET-verzoeken worden vaak gebruikt om data op te halen zonder die te wijzigen.

POST-verzoeken

Waar GET-verzoeken data ophalen, sturen POST-verzoeken instructies naar een server. Ze worden vaak gebruikt om nieuwe resources te maken (zoals een gebruiker toevoegen) of bestaande te updaten (zoals een profiel bewerken).

Stel dat je een online formulier invult om je te registreren voor een dienst. Als je op verzenden klikt, stuur je in feite een POST-verzoek met jouw informatie. Hier is een eenvoudig voorbeeld:

# Data to send (like user information)data = {'name': 'John Doe', 'email': '[email protected]'}# Send the data to the API (replace the URL with the actual API endpoint)response = requests.post('https://api.example.com/users', json=data)# Check if the request was successful (usually a status code of 201 for creation)if response.status_code == 201:    print("User created successfully!")else:    print("Error:", response.status_code)

Dit voorbeeld stuurt een dictionary met gebruikersgegevens als JSON naar de API. Daarna controleren we de statuscode om te zien of de gebruiker succesvol is aangemaakt.

Responses afhandelen

Wanneer je een API-verzoek doet, stuurt de server een response terug met twee kernonderdelen:

• Statuscode: een getal dat aangeeft of het verzoek is geslaagd of niet. 200 betekent meestal succes, terwijl 404 betekent dat de resource niet gevonden is.
• Data: de informatie die je hebt opgevraagd, vaak in JSON-formaat. Dit is waar de waardevolle inhoud zit.

Hier is een Python-voorbeeld:

response = requests.get('https://api.example.com/data')if response.status_code == 200:    data = response.json()    print(data)   else:    print(f"Request failed with status code {response.status_code}")   

API-statuscodes in Python begrijpen

API-statuscodes zijn gestandaardiseerde responses die servers terugsturen om het resultaat van een clientverzoek aan te geven. Deze codes helpen developers te begrijpen of een verzoek is geslaagd, of er een fout is opgetreden of dat verdere actie nodig is.

Veelvoorkomende statuscodes

• 200 OK: Deze statuscode geeft aan dat het verzoek is geslaagd. Als je bijvoorbeeld een GET-verzoek doet om data van een API op te halen, betekent een 200 OK-response dat de data correct is opgehaald.  

• 404 Not Found: Deze code wordt teruggegeven als de server de gevraagde resource niet kan vinden. Als je bijvoorbeeld een endpoint probeert te benaderen dat niet bestaat, krijg je een 404 Not Found-fout.

• 500 Internal Server Error: Deze code geeft aan dat er iets misging aan de serverzijde. Het is een algemene foutmelding die door allerlei oorzaken kan optreden, zoals bugs in de servercode of problemen met de database.

Verschillende statuscodes afhandelen

API-statuscodes effectief afhandelen in je Python-applicaties zorgt ervoor dat je code voorspelbaar werkt en fouten netjes kan opvangen. Bij een 200-response kun je doorgaan met het verwerken van de teruggestuurde data. Bij een 404-fout controleer je of de endpoint-URL klopt en implementeer je zo nodig een fallback of informeer je de gebruiker dat de resource niet beschikbaar is. Bij 500-fouten kun je overwegen om het verzoek na een korte pauze opnieuw te proberen of de fout te loggen voor verder onderzoek. Vermijd echter overmatig opnieuw proberen om de server niet te overbelasten.

Python-API’s bouwen

Met Python API’s bouwen stelt je in staat krachtige en efficiënte applicatie-interfaces te creëren. De eenvoud van Python en de sterke libraries maken het een uitstekende keuze voor API-ontwikkeling.

Introductie tot FastAPI

Nu je weet hoe je API’s gebruikt, kijken we hoe we onze eigen API kunnen bouwen. FastAPI is een modern, snel (high-performance) webframework voor het bouwen van API’s met Python. Zoals de naam al doet vermoeden, is het ontworpen om eenvoudig te gebruiken te zijn. Een ding dat ik fijn vind aan FastAPI is dat het automatisch interactieve documentatie genereert.

FastAPI instellen

Om te beginnen heb je Python en de pakketmanager pip nodig. Installeer vervolgens FastAPI en Uvicorn, een high-performance ASGI-server:

pip install fastapi uvicorn

Zijnoot: Loop je tegen problemen aan met Python of pip? Bekijk dan onze tutorial: How to Upgrade Python and Pip in Windows, MacOS, and Linux.

Een eenvoudige API maken

Laten we een rechttoe-rechtaan API bouwen die een eenvoudige begroeting teruggeeft:

from fastapi import FastAPIapp = FastAPI()@app.get("/")def read_root():    return {"Hello": "World"}

Start deze API met het volgende commando:

uvicorn main:app --reload

Dit commando start de Uvicorn-server en serveert je API op http://127.0.0.1:8000. Als je deze URL in je browser opent, krijg je de response {"Hello": "World"}.

Geavanceerde functies van FastAPI

FastAPI draait niet alleen om snel eenvoudige API’s maken; het biedt ook een reeks geavanceerde functies die het geschikt maken voor complexe en high-performance applicaties. Enkele belangrijke mogelijkheden: 

Queryparameters

In FastAPI is het toevoegen en afhandelen van queryparameters eenvoudig dankzij het gebruik van type hints in Python. Queryparameters maken deel uit van de URL en worden gebruikt om optionele gegevens aan het endpoint door te geven, vaak om de teruggegeven data te filteren of aan te passen.

Queryparameters toevoegen

Om in FastAPI een queryparameter toe te voegen, definieer je die simpelweg als een functieargument in je path operation-functie. Als een parameter optioneel is, kun je een standaardwaarde toekennen, zoals None. Stel, je hebt een endpoint dat items uit een database ophaalt. Je wilt gebruikers laten filteren op een zoekquery:

app = FastAPI()@app.get("/items/")def read_items(q: str = None):    if q:        return {"items": ["Item 1", "Item 2", "Item 3"], "query": q}    return {"items": ["Item 1", "Item 2", "Item 3"]}

In dit voorbeeld is q een optionele queryparameter. Als we een waarde voor q meegeven, filtert het de resultaten op basis van die query. Zonder q geeft het endpoint alle items terug.

Queryparameters afhandelen

FastAPI handelt queryparameters automatisch af, inclusief typevalidatie en conversie. Als je bijvoorbeeld een queryparameter als integer specificeert, valideert FastAPI dat de input inderdaad een integer is. Komt de input niet overeen met het verwachte type, dan geeft FastAPI een duidelijke foutmelding terug.

Hier is een voorbeeld met een vereiste padparameter en typevalidatie:

@app.get("/items/{item_id}")def read_item(item_id: int, q: str = None):    return {"item_id": item_id, "query": q}

In dit geval is item_id een padparameter en q een optionele queryparameter. FastAPI zorgt ervoor dat item_id een integer is en verwerkt de queryparameter q als die is meegegeven.

Verschillende HTTP-methoden afhandelen

Het implementeren van verschillende HTTP-methoden zoals GET, POST, PUT en DELETE is eenvoudig en lijkt op hoe je routes in andere frameworks definieert. Elke methode hoort bij een specifiek type operatie, zoals data ophalen (GET), nieuwe data creëren (POST), bestaande data bijwerken (PUT) of data verwijderen (DELETE).

GET-methode

De GET-methode wordt gebruikt om data van de server op te halen. In FastAPI definieer je een GET-endpoint als volgt:

@app.get("/items/")def get_items():    return {"items": ["Item 1", "Item 2", "Item 3"]}

POST-methode

De POST-methode wordt gebruikt om nieuwe data te creëren. Je definieert een POST-endpoint en ontvangt data in de request body:

@app.post("/items/")def create_item(item: dict):    return {"item": item}

PUT-methode

De PUT-methode wordt gebruikt om bestaande data te updaten. Meestal geef je zowel een identifier als de nieuwe data mee:

@app.put("/items/{item_id}")def update_item(item_id: int, item: dict):    return {"item_id": item_id, "updated_item": item}

DELETE-methode

De DELETE-methode wordt gebruikt om data te verwijderen. In FastAPI definieer je een DELETE-endpoint als volgt:

@app.delete("/items/{item_id}")def delete_item(item_id: int):    return {"message": f"Item {item_id} deleted"}

Authenticatie en beveiliging

FastAPI biedt verschillende mechanismen om authenticatie en beveiliging te implementeren:

• HTTP Basic Auth: Eenvoudig, maar over het algemeen niet aan te raden voor productieomgevingen vanwege beveiligingsrisico’s.
• API-sleutels: Een veiligere optie waarbij je unieke sleutels voor clients genereert.
• OAuth 2.0: Een complex maar robuust standaardprotocol voor autorisatie, vaak gebruikt voor integraties van derden.
• JSON Web Tokens (JWT): Een populaire aanpak om claims veilig tussen twee partijen te vertegenwoordigen.