Python en API's: Python-verzoeken gebruiken voor het bouwen van API-gestuurde apps

Hoi! Wilt u uw Python-vaardigheden naar een hoger niveau tillen en leren hoe u krachtige API's in uw applicaties kunt integreren? Dan is deze gids iets voor jou.

Ik ga je helpen met het gebruik van de fantastische Python Requests-bibliotheek voor interactie met allerlei soorten web-API's. Met enige basiskennis en -verzoeken over Python kun je:

Vraag gegevens op vanaf elk API-eindpunt
Bouw apps die kunnen worden geïntegreerd met populaire services zoals Twitter, Stripe, Twilio enz.
Automatiseer workflows door API's met elkaar te verbinden
Ontgrendel talloze nuttige gegevens en functionaliteit om uw Python-apps te verbeteren

Klinkt spannend toch? Laten we erin duiken!

Waarom API's gebruiken in Python?

Voordat we op de code ingaan, moeten we het eerst begrijpen Waarom verbinding maken met API's is zo handig voor ontwikkelaars.

API's zorgen ervoor dat verschillende softwareapplicaties met elkaar kunnen communiceren. Bedrijven en organisaties stellen API's beschikbaar zodat ontwikkelaars gemakkelijker apps met hun services kunnen bouwen.

Hier zijn enkele van de belangrijkste redenen om API's in uw code te gebruiken:

Tijd BESPAREN – Bouw niet iets helemaal opnieuw op dat al als API bestaat!
Maak gebruik van gegevens – Toegang tot nuttige gegevensbronnen zoals het weer, aandelen, sociale media en meer.
Breid de functionaliteit uit – Integreer kaarten, betalingen, meldingen en meer.
Automatiseer workflows – Verbind verschillende systemen naadloos met elkaar.
Bouw apps sneller – Concentreer u op uw app-logica in plaats van op de onderliggende infrastructuur.

Kortom, goed ontworpen API’s helpen u sneller betere applicaties te ontwikkelen.

Think Postman's State of the API-rapport 2024, de publieke API-adoptie groeit snel:

72% van de organisaties gebruikt publieke API’s als onderdeel van hun kernactiviteiten.
58% beschikt zelf over publieke API’s.
De API-verzoeken zijn tussen 650 en 2020 met meer dan 2021% gestegen voor responders.

Nu API's alomtegenwoordiger worden in alle sectoren, is het een goed moment om je vaardigheden te verbeteren om er met Python verbinding mee te maken.

Aan de slag met Python-verzoeken

Python heeft fantastische bibliotheken die het werken met API's eenvoudig maken. De meest populaire is Aanvragen.

Met Requests kunt u API's aanroepen met slechts een paar regels code:

import requests

response = requests.get(‘https://api.data.gov/education‘)

Vergeleken met alternatieven op een lager niveau, zoals de ingebouwde Python urllib module, Verzoeken bespaart u een hoop tijd en kopzorgen.

Enkele belangrijke kenmerken van verzoeken:

Eenvoudige, elegante API
Maakt HTTP-verzoeken uiterst eenvoudig
Ingebouwde JSON-ondersteuning
Afhandeling van headers, parameters, authenticatie
Automatische nieuwe pogingen bij netwerkfouten
Breed scala aan geavanceerde functies

Om Requests te installeren, voert u eenvoudigweg het volgende uit:

pip install requests

Dan import requests in uw code en u bent klaar om API-aanroepen te maken!

Laten we enkele eenvoudige voorbeelden doornemen.

Een GET-verzoek indienen

De meest voorkomende API-aanroep is een GET-verzoek om gegevens van een eindpunt op te halen.

Zo kunt u een GET-verzoek indienen met Verzoeken:

import requests 

response = requests.get(‘https://api.github.com/repos/requests/requests‘)

Hiermee wordt een GET-verzoek naar het GitHub API-eindpunt verzonden om gegevens uit de Requests-repository op te halen.

Wij krijgen terug A Response object dat de statuscode, antwoordheaders en gegevens bevat.

Om de antwoordstatuscode af te drukken:

print(response.status_code)

>>> 200

Een statuscode van 200 geeft aan dat ons verzoek is geslaagd. Er bestaan nog veel meer statuscodes die fouten of mislukkingen aangeven. Hoe u hiermee omgaat, bespreken we later.

Om toegang te krijgen tot de antwoordgegevens hoeft u alleen maar te bellen .json():

data = response.json()

print(data[‘stargazers_count‘])

>>> 64245

De gegevens worden automatisch geparseerd als JSON. Dit maakt het werken met JSON API’s zeer eenvoudig.

Parameters doorgeven

Voor veel API's moet u parameters doorgeven om gegevens te filteren, resultaten te pagineren en meer.

Geef de parameters als woordenboek door aan de params argument:

params = {‘type‘: ‘owner‘, ‘sort‘: ‘updated‘}
response = requests.get(‘https://api.github.com/repos/kennethreitz/requests‘, 
                        params=params)

Requests codeert de parameters en voegt deze voor u toe aan de URL.

U kunt parameters ook rechtstreeks in de URL doorgeven:

response = requests.get(‘https://api.github.com/repos/kennethreitz/requests?type=owner&sort=updated‘)

Hoe dan ook werkt, maar het doorgeven van een woordenboek wordt als schoner beschouwd.

POST-verzoeken

Om bronnen op de server te creëren, zou u een POST-verzoek gebruiken.

Geef de gegevens door die u als woordenboek wilt posten, naar de json parameter:

data = {‘name‘: ‘John Smith‘, ‘email‘: ‘[email protected]‘}
response = requests.post(‘https://api.example.com/users‘, json=data)

Dit codeert de gegevens als JSON en stuurt een POST naar de API om een nieuwe gebruikersbron te maken.

Voor POST's moet u ook de geretourneerde statuscode valideren:

if response.status_code == 201:
  print(‘User created!‘)

De status 201 betekent dat de bron met succes op de server is aangemaakt.

PLAATSEN, PATCHEN, VERWIJDEREN

Naast GET en POST zijn de andere veelgebruikte HTTP-methoden:

PUT – Een bestaande bron bijwerken
PATCH – Gedeeltelijke update van een bron
VERWIJDEREN – Een bron verwijderen

Deze werken op dezelfde manier, roep gewoon de overeenkomstige methode aan requests:

# PUT - Update user
requests.put(‘https://api.example.com/users/123‘, json=updated_data) 

# PATCH - Partial update  
requests.patch(‘https://api.example.com/users/123‘, json=partial_data)

# DELETE - Delete user
requests.delete(‘https://api.example.com/users/123‘)

Nu weet u hoe u API-aanroepen kunt maken met behulp van alle gebruikelijke HTTP-methoden!

API-reacties afhandelen

Wanneer u met API's werkt, moet u de responsgegevens verwerken op basis van de statuscode die door de server wordt geretourneerd.

API's gebruiken standaard HTTP-statuscodes om succes, fouten of mislukkingen aan te geven. Enkele veel voorkomende zijn:

200 – OK – Het verzoek is geslaagd
201 – Aangemaakt – De bron is succesvol aangemaakt
400 – Ongeldig verzoek – Het verzoek was onjuist opgemaakt of er ontbreken gegevens
401 – Ongeautoriseerd – Authenticatie is vereist
403 – Verboden – U heeft geen toegang tot deze bron
404 – Niet gevonden – De bron bestaat niet
500 – Serverfout – De server heeft een onverwachte fout aangetroffen

U controleert de statuscode op het Response-object:

response = requests.get(‘https://api.example.com/items/123‘)

if response.status_code == 200:
  # Success!
elif response.status_code == 404:
  # Notify user item does not exist

Voor de beknoptheid raad ik aan om al uw Requests-aanroepen in een helperfunctie te verpakken, zoals:

def make_api_request(endpoint):
  response = requests.get(endpoint)

  response.raise_for_status()

  return response.json()

Dit maakt de code schoner en centraliseert de foutafhandeling op één plek.

raise_for_status() zal een uitzondering genereren als er een HTTP-foutcode is, zoals 500 of 404, waardoor u niet elke keer handmatig hoeft te controleren.

Verificatie met API's

Veel API's vereisen authenticatie om de toegang te beperken. Enkele veel voorkomende vormen van API-authenticatie zijn onder meer:

API-sleutels – Geef een unieke API-sleutel door via een verzoekheader of parameter
Basisverificatie – Geef een gebruikersnaam en wachtwoord door bij het verzoek
Tokens aan toonder – Verzend een OAuth 2.0-bearertoken van de auth-provider
Digest-auth – Vergelijkbaar met basisauthenticatie, maar de inloggegevens zijn gecodeerd

Verzoeken maken het afhandelen van authenticatie eenvoudig.

Om een API-sleutel te gebruiken, geeft u deze als header door:

headers = {‘Authorization‘: ‘Bearer YOUR_API_KEY‘}
response = requests.get(‘https://api.example.com‘, headers=headers)

Voor basisauthenticatie geeft u de gebruikersnaam en het wachtwoord op als een tupel:

requests.get(‘https://api.example.com‘, 
            auth=(‘username‘, ‘password‘))

Verzoeken zorgen ervoor dat uw inloggegevens correct worden gecodeerd.

Voor tokens aan toonder van OAuth-providers zoals Facebook, Twitter, Google enz.:

params = {‘access_token‘: ‘OAUTH_TOKEN‘}
requests.get(‘https://api.example.com‘, params=params)

Geef het toegangstoken door als parameter en Requests handelt de rest af.

Een goede authenticatie is van cruciaal belang voor veilige toegang tot API's in uw Python-apps en -workflows.

Best practices voor het werken met API's

Nu dat je het weet hoe Om API's aan te roepen met Python, bespreken we enkele best practices om er effectief mee te werken:

Ga netjes om met fouten

API's kunnen op onverwachte manieren falen: servers vallen uit, netwerken vallen uit, providers brengen wijzigingen aan.

Bij het indienen van API-verzoeken:

Gebruik try/except-blokken fouten op te vangen
Omgaan met veelvoorkomende uitzonderingen, zoals ConnectionErrors
Controleer statuscodes en handel niet-200-reacties af
Gebruik een exponentiële uitstelstrategie om mislukte aanvragen opnieuw te proberen

Dit zorgt ervoor dat uw applicatie op een goede manier degradeert wanneer API's falen.

Respecteer de tarieflimieten

Om misbruik te voorkomen, hanteren API's tarieflimieten voor verzoeken per uur/dag.

Als u deze limieten overschrijdt, wordt uw toegang mogelijk permanent geblokkeerd.

Om dit te voorkomen:

Controleer de documentatie over de tarieflimieten en begrijp uw quotum
Beperk verzoeken – alleen bellen als dat nodig is
Implementeer een uitsteltimer als je de limiet bereikt om te pauzeren voordat je het opnieuw probeert
Spam nooit en maak geen misbruik van de API! Dit zal tot blokkades leiden.

Tarieflimieten beschermen API's zodat ze voor alle gebruikers werken. Respecteer ze in uw gebruik.

Cachereacties

API's kunnen traag zijn, afhankelijk van de connectiviteit. Voor de prestaties kunt u overwegen reacties in de cache op te slaan, vooral als de gegevens niet vaak veranderen.

Populaire cachingbibliotheken voor Python zijn Redis, Memcached en SQLAlchemy.

Caching voorkomt onnodige netwerkoproepen voor herhaalde verzoeken.

Voorbeelden en toepassingen van Python API

Laten we nu eens kijken naar enkele voorbeelden uit de praktijk van populaire API's en hoe u deze kunt openen in Python.

Twitter-API

Met de Twitter API kunnen tweets, gebruikers, hashtags en analyses worden opgevraagd. Je moet een Twitter-ontwikkelaarsaccount aanvragen om API-inloggegevens te krijgen.

Installeer de tweepie bibliotheek voor een vriendelijkere Twitter API-interface:

pip install tweepy

Voorbeeld van het ophalen van tweets voor een hashtag:

import tweepy

client = tweepy.Client(bearer_token=TWITTER_TOKEN)

tweets = client.search_recent_tweets(query="#python")

for tweet in tweets.data:
   print(tweet.text)

Zie de tweepy-documenten voor meer details.

GitHub-API

De GitHub API maakt programmatische toegang tot GitHub-opslagplaatsen, code, gebruikers en meer mogelijk zonder authenticatie.

Voorbeeld van het ophalen van de repository's van een gebruiker:

import requests

response = requests.get(‘https://api.github.com/users/kennethreitz/repos‘)

for repo in response.json():
  print(repo[‘name‘])

Zie de GitHub API-documenten voor meer gebruiksscenario's.

Stripe-API

Met de Stripe API kunnen betalingen in apps en websites worden ingebouwd.

Installeer de streep bibliotheek en import:

pip install stripe

import stripe

Voorbeeld van het aanmaken van een toeslag:

stripe.api_key = ‘STRIPE_SECRET_KEY‘ 

charge = stripe.Charge.create(
  amount=1000,
  currency=‘usd‘,
  source=‘tok_visa‘ # Token from Stripe.js
)

Stripe verzorgt het zware werk van betalingen voor u.

Bekijk Stripe's API-documenten voor de volledige API-referentie.

Er zijn talloze andere geweldige API's beschikbaar, zoals Slack, Twilio, Google Maps, AWS en meer! De sleutel is het vinden van de juiste gegevensbron voor uw toepassing en het benutten van de kracht van API's.

Conclusie

Ik hoop dat deze handleiding een nuttig overzicht biedt van het maken van API-verzoeken in Python met behulp van de Requests-bibliotheek. Hier zijn enkele belangrijke inzichten:

Aanvragen maakt het aanroepen van API's eenvoudig: installeer het met pip
Gebruik algemene HTTP-methoden zoals GET, POST, PUT, DELETE voor CRUD-bewerkingen
Geef parameters, authenticatie, headers en gegevens eenvoudig door
Ga op de juiste manier om met statuscodes en fouten
Implementeer best practices zoals snelheidsbeperking en caching
Integreer coole API's zoals Twitter, GitHub, Stripe en meer!

Met API's kunt u sneller betere apps bouwen doordat u bestaande gegevens en services kunt benutten. Python en Requests bieden een geweldige manier om de kracht van API's in uw code te ontsluiten.

Voor de volgende stappen raad ik aan om door de ambtenaar te bladeren Documenten opvragen, het lezen van de API-documenten van alle services die u wilt integreren, en het beoordelen van enkele repositories met behulp van Python API's zoals deze.

Ik hoop dat je deze gids nuttig vond! Laat het me weten als je nog andere vragen hebt over het gebruik van Python en API's. Veel codeerplezier!