Jouer avec une API Stock : un développeur JavaScript/React apprend Python

En tant que nouveau venu sur Python, je me suis récemment lancé dans un voyage pour explorer ses capacités tout en travaillant avec une API stock. En cours de route, j'ai appris à :

• Mettre en place un environnement virtuel
• Gérer les colis
• Utiliser des variables d'environnement pour les données sensibles
• Effectuer des requêtes HTTP et gérer JSON
• Implémenter la gestion des erreurs et le formatage des chaînes
• Travailler avec les dictionnaires Python
• Comprendre les schémas fournis par les API

Voici un aperçu de mon expérience d’apprentissage et des principaux points à retenir !

1. Configuration Python

Les environnements virtuels de Python (venv) vous permettent d'isoler les dépendances de votre projet, garantissant que vos packages n'entrent pas en conflit avec les autres. C’est formidable pour le développement professionnel.

Étapes pour créer et activer un environnement virtuel : Créer un environnement virtuel

python -m venv venv

Activez-le (Mac/Linux)

source venv/bin/activate

Activez-le (Windows)

venvScriptsactivate

Cela permet de séparer les packages de votre projet des autres.

Gestion des packagesGrâce à pip, l'installateur de packages de Python, j'ai appris à gérer les dépendances :

Installer des packages

demandes d'installation pip python-dotenv

Enregistrer les exigences

gel du pip> exigences.txt

Installer à partir des exigences

pip install -r exigences.txt

2. Variables d'environnement

Pour sécuriser les données sensibles, j'ai utilisé des fichiers .env pour les clés API et les informations d'identification :

 Fichier .env

SCHWAB_CLIENT_ID=my_secret_id

SCHWAB_CLIENT_SECRET=ma_clé_secret

Code Python

depuis dotenv import load_dotenv

importer le système d'exploitation

load_dotenv() # Charger les variables depuis .env

api_key = os.getenv('SCHWAB_CLIENT_ID')

Important : Ne validez jamais de fichiers .env dans Git. Utilisez un fichier .gitignore pour les exclure.

• 3. Faire des requêtes HTTP

J'ai utilisé la bibliothèque de requêtes pour interagir avec les API :

demandes d'importation

Faire une requête GET

response = requêtes.get(url, headers=headers, params=params)

Vérifiez si la demande a abouti

si réponse.status_code == 200 :

data = réponse.json() # Convertir la réponse en JSON

4. Comprendre les schémas

Avant d'interagir avec un point de terminaison d'API, j'ai exploré son schéma. Un schéma d'API est comme un plan qui vous indique :

• Schéma de demande : quelles données vous devez envoyer, y compris les champs obligatoires, les types de données et les contraintes.
• Schéma de réponse : quelles données vous pouvez vous attendre à recevoir, y compris la structure, les types de données et des exemples.

Par exemple, si un point de terminaison d'API récupère les cours des actions, le schéma peut ressembler à ceci :

Schéma de demande :

{

« symbole » : « chaîne »,

« date » : « chaîne (AAAA-MM-JJ) »,

"intervalle": "chaîne (par exemple, '1d', '1m')"

}

Schéma de réponse :

{

« symbole » : « chaîne »,

« tarifs » : [

{

« date » : « chaîne (AAAA-MM-JJ) »,

« ouvert » : « flotter »,

« fermer » : « flotter »,

« haut » : « flottant »,

« bas » : « flotter »,

« volume » : « entier »

}

]

}

Connaître le schéma aide de deux manières :

1. Préparation : Elle garantit que vous structurez correctement votre demande et que vous savez gérer la réponse.
2. Prévention des erreurs : le respect des schémas minimise les demandes non valides ou les réponses mal interprétées.

Les schémas m'ont fait gagner du temps et ont rendu le débogage beaucoup plus facile lorsque je travaillais avec l'API.

5. Travailler avec JSON

Les API renvoient souvent des données au format JSON. Voici comment je l'ai géré en Python :

importer json

Lire le JSON à partir d'un fichier

avec open('tokens.json', 'r') comme f :

données = json.load(f)

Écrire du JSON dans un fichier

avec open('tokens.json', 'w') as f :

json.dump(data, f, indent=4)

6. Gestion des erreurs

Les blocs try/sauf de Python m'ont aidé à gérer les erreurs avec élégance :

essayez :

réponse = requêtes.get(url)

data = réponse.json()

sauf exception comme e :

print(f”Erreur : {str(e)}”)

retour Aucun

7. Formatage des chaînes

Les f-strings de Python et la méthode .format() simplifient le formatage des chaînes :

Utiliser des f-strings

print(f"Stock : {name}, Prix : ${price:.2f}")

Utiliser .format()

print("Stock : {}, Prix : ${:.2f}".format(nom, prix))

8. Opérations de dictionnaire

Les dictionnaires en Python sont puissants pour gérer les données d'API imbriquées :

Obtenez de la valeur par défaut

prix = data.get('prix', 'N/A')

Accéder aux dictionnaires imbriqués

stock = données[symbole]

quote = stock.get('quote', {})

prix = quote.get('lastPrice', 'N/A')

9. Conseils de débogage

Le débogage en Python est simple et efficace :

Débogage d'impression

print(f”Debug : {variable}”)

Vérifier les types de variables

print(f”Type : {type(data)}”)

De jolis dictionnaires imprimés

importer json

print(json.dumps(data, indent=2))

10. Surmonter les défis d'authentification

L'un des plus grands obstacles que j'ai rencontrés a été de faire fonctionner l'authentification. Je suis resté coincé pendant quelques jours, essayant différentes approches sans succès. Finalement, j'ai décidé de demander de l'aide pour comprendre pourquoi cela ne fonctionnait pas.

Il s'est avéré que le problème était lié au type de compte que j'utilisais. Pour m'authentifier avec succès, j'avais besoin à la fois d'un compte de courtage et d'un compte de développeur. J'ai initialement supposé que seul un compte de développeur était requis, mais l'API nécessitait également les informations d'identification d'un compte de courtage actif.

Cette expérience m'a appris une leçon importante : n'hésitez pas à demander de l'aide en cas de besoin. En mettant mon ego de côté et en cherchant des conseils, j'ai acquis une compréhension plus profonde du problème et je l'ai résolu beaucoup plus rapidement que si j'avais continué à lutter seul

ConclusionPython est incroyablement convivial pour les débutants ! Voici ce que j'ai appris :

• Les environnements virtuels maintiennent les projets organisés.
• Les variables d'environnement protègent les données sensibles.
• Les bibliothèques telles que les requêtes simplifient les appels d'API.
• Une bonne gestion des erreurs est cruciale.
• Les noms de fonctions et les commentaires clairs améliorent la lisibilité.

Prochaines étapes

• Plongez plus profondément dans l'authentification API.
• Explorez la visualisation des données.
• Ajoutez une gestion des erreurs plus robuste.
• Mettre en œuvre des tests automatisés.

Pensées finales
La meilleure façon d’apprendre est de faire. N'ayez pas peur d'expérimenter et de faire des erreurs — chaque défi est une opportunité de grandir !

Référentiel d'analyse de données : https://github.com/Jesse-Chong/Schwab-Market-Analysis

Publié à l'origine sur Medium

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!