Python et API : comment utiliser les requêtes Python pour créer des applications pilotées par API

Salut! Cherchez-vous à améliorer vos compétences Python et à apprendre à intégrer de puissantes API dans vos applications ? Alors ce guide est pour vous.

Je vais vous expliquer comment utiliser la fantastique bibliothèque Python Requests pour interagir avec des API Web de toutes sortes. Avec quelques connaissances de base et requêtes Python, vous serez capable de :

Interroger des données à partir de n'importe quel point de terminaison d'API
Créez des applications qui s'intègrent à des services populaires tels que Twitter, Stripe, Twilio, etc.
Automatisez les flux de travail en connectant les API entre elles
Débloquez des tonnes de données et de fonctionnalités utiles pour améliorer vos applications Python

Cela semble excitant, n'est-ce pas ? Allons-y !

Pourquoi utiliser des API en Python ?

Avant d'entrer dans le code, comprenons d'abord why la connexion aux API est très utile pour les développeurs.

Les API permettent à différentes applications logicielles de communiquer entre elles. Les entreprises et les organisations exposent des API pour permettre aux développeurs de créer plus facilement des applications avec leurs services.

Voici quelques-unes des principales raisons d’utiliser des API dans votre code :

Gagner du temps – Ne reconstruisez pas à partir de zéro quelque chose qui existe déjà en tant qu'API !
Exploiter les données – Accédez à des sources de données utiles telles que la météo, les actions, les réseaux sociaux, etc.
Étendre les fonctionnalités – Intégrez des cartes, des paiements, des notifications et bien plus encore.
Automatisez les flux de travail – Connectez différents systèmes entre eux de manière transparente.
Créez des applications plus rapidement – Concentrez-vous sur la logique de votre application plutôt que sur l’infrastructure sous-jacente.

En bref, des API bien conçues vous aident à développer de meilleures applications, plus rapidement.

Selon Rapport 2024 sur l'état de l'API de Postman, l'adoption des API publiques connaît une croissance rapide :

72 % des organisations utilisent des API publiques dans le cadre de leur cœur de métier.
58 % disposent eux-mêmes d’API publiques.
Les demandes d'API ont augmenté de plus de 650 % entre 2020 et 2021 pour les répondants.

Les API étant de plus en plus omniprésentes dans tous les secteurs, c'est le moment idéal pour améliorer vos compétences pour vous y connecter avec Python.

Premiers pas avec les requêtes Python

Python possède des bibliothèques fantastiques qui facilitent le travail avec les API. Le plus populaire est Demandes.

Les requêtes vous permettent d'appeler des API avec seulement quelques lignes de code :

import requests

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

Par rapport aux alternatives de niveau inférieur comme la version intégrée de Python urllib module, Requests vous fait gagner beaucoup de temps et de maux de tête.

Quelques fonctionnalités clés des requêtes :

API simple et élégante
Rend les requêtes HTTP extrêmement simples
Prise en charge JSON intégrée
Gestion des en-têtes, paramètres, authentification
Nouvelles tentatives automatiques sur les erreurs réseau
Large gamme de fonctionnalités avancées

Pour installer Requests, exécutez simplement :

pip install requests

Ensuite import requests dans votre code et vous êtes prêt à commencer à faire des appels API !

Passons en revue quelques exemples simples.

Faire une requête GET

L'appel d'API le plus courant est une requête GET pour récupérer des données à partir d'un point de terminaison.

Voici comment faire une requête GET avec Requests :

import requests 

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

Cela enverra une requête GET au point de terminaison de l'API GitHub pour récupérer les données sur le référentiel Requests.

Nous récupérons un Response objet contenant le code d’état, les en-têtes de réponse et les données.

Pour imprimer le code d'état de la réponse :

print(response.status_code)

>>> 200

Un code d'état de 200 indique que notre demande a réussi. Il existe de nombreux autres codes d’état indiquant des erreurs ou des échecs – nous verrons comment les gérer plus tard.

Pour accéder aux données de réponse, appelez simplement .json():

data = response.json()

print(data[‘stargazers_count‘])

>>> 64245

Les données sont automatiquement analysées au format JSON. Cela rend le travail avec les API JSON très simple.

Paramètres de transmission

Pour de nombreuses API, vous devez transmettre des paramètres pour filtrer les données, paginer les résultats, etc.

Transmettez les paramètres sous forme de dictionnaire au params argument:

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

Requests code les paramètres et les ajoute à l’URL pour vous.

Vous pouvez également passer des paramètres directement dans l'URL :

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

Dans les deux cas, cela fonctionne, mais passer un dictionnaire est considéré comme plus propre.

Demandes POST

Pour créer des ressources sur le serveur, vous utiliserez une requête POST.

Transmettez les données à publier sous forme de dictionnaire au json paramètre:

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

Cela code les données au format JSON et envoie un POST à l'API pour créer une nouvelle ressource utilisateur.

Pour les POST, vous devez également valider le code d'état renvoyé :

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

Le statut 201 signifie que la ressource a été créée avec succès sur le serveur.

METTRE, CORRIGER, SUPPRIMER

Outre GET et POST, les autres méthodes HTTP courantes sont :

PUT – Mettre à jour une ressource existante
PATCH – Mise à jour partielle d’une ressource
EFFACER – Supprimer une ressource

Ceux-ci fonctionnent de la même manière, appelez simplement la méthode correspondante sur 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‘)

Vous savez maintenant comment effectuer des appels API en utilisant toutes les méthodes HTTP courantes !

Gestion des réponses API

Lorsque vous travaillez avec des API, vous devez gérer les données de réponse en fonction du code d'état renvoyé par le serveur.

Les API utilisent des codes d'état HTTP standard pour indiquer le succès, les erreurs ou les échecs. Parmi les plus courants, citons :

200 – OK – La demande a réussi
201 – Créé – La ressource a été créée avec succès
400 – Mauvaise demande – La demande était mal formée ou des données manquaient
401 – Non autorisé – L’authentification est requise
403 – Interdit – Vous n'avez pas accès à cette ressource
404 – Not Found – La ressource n’existe pas
500 – Erreur de serveur – Le serveur a rencontré une erreur inattendue

Vous vérifiez le code d'état sur l'objet Réponse :

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

Par souci de concision, je recommande d'envelopper tous vos appels Requests dans une fonction d'assistance telle que :

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

  response.raise_for_status()

  return response.json()

Cela rend le code plus propre et centralise la gestion des erreurs en un seul endroit.

raise_for_status() lèvera une exception s'il y a un code d'erreur HTTP tel que 500 ou 404, vous évitant ainsi de vérifier manuellement à chaque fois.

Authentification avec les API

De nombreuses API nécessitent une authentification pour restreindre l'accès. Certaines formes courantes d'authentification API incluent :

Clés API – Transmettre une clé API unique via un en-tête ou un paramètre de requête
Authentification de base – Passer un nom d’utilisateur et un mot de passe avec la demande
Jetons au porteur – Envoyez un jeton de porteur OAuth 2.0 du fournisseur d'authentification
Authentification condensée – Semblable à l’authentification de base mais les informations d’identification sont cryptées

Les requêtes simplifient la gestion de l’authentification.

Pour utiliser une clé API, transmettez-la en en-tête :

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

Pour l'authentification de base, fournissez le nom d'utilisateur et le mot de passe sous forme de tuple :

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

Les demandes géreront correctement l’encodage de vos informations d’identification.

Pour les jetons au porteur des fournisseurs OAuth comme Facebook, Twitter, Google, etc. :

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

Transmettez le jeton d'accès en tant que paramètre et les requêtes se chargeront du reste.

Une authentification appropriée est essentielle pour accéder en toute sécurité aux API de vos applications et flux de travail Python.

Meilleures pratiques pour travailler avec les API

Maintenant que vous connaissez how Pour appeler des API avec Python, discutons de quelques bonnes pratiques pour travailler efficacement avec elles :

Gérer les erreurs avec élégance

Les API peuvent échouer de manière inattendue : les serveurs tombent en panne, les réseaux tombent en panne, les fournisseurs apportent des modifications.

Lors des requêtes API :

Utiliser les blocs try/sauf détecter les erreurs
Gérez les exceptions courantes comme ConnectionErrors
Vérifiez les codes d'état et gérez les réponses non-200
Utiliser une stratégie d'attente exponentielle pour réessayer les demandes ayant échoué

Cela garantit que votre application se dégrade progressivement lorsque les API échouent.

Respecter les limites de taux

Pour éviter les abus, les API imposent des limites de débit aux requêtes par heure/jour.

Le dépassement de ces limites bloquera votre accès, éventuellement de façon permanente.

Pour éviter cela:

Examiner la documentation sur les limites de débit et comprenez votre quota
Limiter les demandes – ne téléphoner que lorsque cela est nécessaire
Implémenter une minuterie d'attente si vous atteignez la limite, faites une pause avant de réessayer
Ne spammez jamais et n'abusez jamais de l'API ! Cela entraînera des blocages.

Les limites de débit protègent les API afin qu'elles fonctionnent pour tous les utilisateurs. Respectez-les dans votre utilisation.

Réponses du cache

Les API peuvent être lentes en fonction de la connectivité. Pour des raisons de performances, envisagez de mettre en cache les réponses, surtout si les données ne changent pas fréquemment.

Les bibliothèques de mise en cache Python populaires incluent Redis, Memcached et SQLAlchemy.

La mise en cache évite les appels réseau inutiles pour des requêtes répétées.

Exemples et utilisations de l'API Python

Examinons maintenant quelques exemples concrets d'API populaires et comment vous pouvez y accéder en Python.

API Twitter

L'API Twitter permet d'interroger les tweets, les utilisateurs, les hashtags et les analyses. Vous devez demander un compte de développeur Twitter pour obtenir les informations d'identification de l'API.

Installez l' pleurnichard bibliothèque pour une interface API Twitter plus conviviale :

pip install tweepy

Exemple de récupération de tweets pour un 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)

Voir le documents tweety pour plus de détails.

API GitHub

L'API GitHub permet un accès par programmation aux référentiels GitHub, au code, aux utilisateurs et bien plus encore sans authentification.

Exemple de récupération des référentiels d'un utilisateur :

import requests

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

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

Voir le Documentation sur l'API GitHub pour plus de cas d'utilisation.

API Stripe

L'API Stripe permet d'intégrer des paiements dans des applications et des sites Web.

Installez l' bande bibliothèque et importation :

pip install stripe

import stripe

Exemple de création d'une charge :

stripe.api_key = ‘STRIPE_SECRET_KEY‘ 

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

Stripe gère le gros du travail des paiements pour vous.

See Documentation sur l'API de Stripe pour la référence complète de l'API.

Il existe des tonnes d'autres excellentes API comme Slack, Twilio, Google Maps, AWS et bien plus encore ! La clé est de trouver la bonne source de données pour votre application et d’exploiter la puissance des API.

Conclusion

J'espère que ce guide a fourni un aperçu utile de la création de requêtes API en Python à l'aide de la bibliothèque Requests. Voici quelques points clés à retenir :

Demandes simplifie l'appel des API : installez-le à l'aide de pip
Utilisez des méthodes HTTP courantes telles que GET, POST, PUT, DELETE pour les opérations CRUD
Transmettez facilement les paramètres, l’authentification, les en-têtes et les données
Gérer correctement les codes d'état et les erreurs
Mettre en œuvre les meilleures pratiques telles que la limitation du débit et la mise en cache
Intégrez des API intéressantes comme Twitter, GitHub, Stripe et plus encore !

Les API vous aident à créer plus rapidement de meilleures applications en vous permettant d'exploiter les données et les services existants. Python et les requêtes constituent un excellent moyen de libérer la puissance des API dans votre code.

Pour les prochaines étapes, je vous recommande de parcourir le site officiel Demandes de documents, en lisant la documentation API de tous les services que vous souhaitez intégrer et en examinant certains référentiels à l'aide d'API Python telles que ici.

J'espère que vous avez trouvé ce guide utile ! Faites-moi savoir si vous avez d'autres questions sur l'utilisation de Python et des API. Bon codage !