% Programmation avec Python (chapitre 7) % Dimitri Merejkowsky
\center \huge Un nouveau mot-clé
Des mots qui ne peut être utilisé pour des noms de variales.
On a déjà vu: def
, class
, import
, etc ...
sys.exit()
\center \huge Rappels sur les classes
Construire la classeCounter
avec un attribut count
:
class Counter:
def __init__(self):
self.count = 0
Construire une nouvelle instance de Counter
>>> counter = Counter()
>>> counter.count
0
Ajouter une méthode pour incrémenter le compteur:
class Counter:
def __init__(self):
self.count = 0
def increment(self):
self.count += 1
>>> counter = Counter()
>>> counter.count
0
>>> counter.increment()
>>> counter.count
1
\center \huge Compléments sur les classes
En vrai les attributs qu’on a vu maintenant sont des attributs d’instance. Ils sont liés à l’instance courante.
Mais on dit souvent “attribut” tout court.
Il existe un autre type d’attribut.
Dans le bloc de la classe, mais à l’extérieur des blocs de méthodes:
class Car:
total_number_of_cars = 0
def __init__(self, color="black"):
# attribut d'instance: avec self
self.color = color
# attribut de classe: avec le nom de la classe
Car.total_number_of_cars += 1
Les attributs de classe sont partagés entre toutes les instances:
>>> ford = Car()
>>> ferrari = Car(color="red")
>>> Car.total_number_of_cars
2
De même, techniquement les méthodes qu’on a vu sont des méthodes d’instance, et il existe des méthodes de classe
Avec un joli @classmethod
au-dessus
class Car:
total_number_of_cars = 0
@classmethod
def print_number_of_cars(cls):
print(cls.total_number_of_cars, "have been made")
def print_color(self):
print("This car is", self.color)
Notez le cls
Pour appeler:
>>> ferrari = Car(color="red")
>>> ford = Car()
>>> Car.print_number_of_cars()
2 cars have been made
car.print_color()
\vfill
# self = car
def print_color(self):
print(self.color)
Car.print_number_of_cars()
\vfill
# cls = Car
@classmethod
def print_number_of_cars(cls):
print(cls.total_number_of_cars)
\center \huge Les API Web
Une façon pour des machines différentes de parler entre elles.
On fait toujours un aller-retour du client vers le serveur.
Une requête part du client vers le serveur et consite en:
Une réponse revient du serveur vers le client et contient
Quand vous tapez une url dans votre navigateur ou que vous suivez un lien, c’est votre navigateur qui fait la requête.
Le serveur lui renvoie un contenu particulier (du HTML) C’est ce que vous voyez quand vous faites “show source”
Vous voyez parfois le code de retour (le plus connu étant 404)
C’est très simplifié
Notez qu’on a absolument aucune connaissance du code qui tourne sur le serveur!
Examples:
["one", "two"]
{
"color": "blue",
"size": 3
}
On peut imbriquer les objets les uns dans les autres:
{
"a": 42,
"b": true,
"c": ["one", "two"],
}
On dit que JSON est un format texte par ce qu’on peut le mettre dans une string.
Python | JSON |
---|---|
dictionnary | object |
True | true |
False | false |
None | null |
>>> import json
>>> data = json.loads("...")
>>> data["a"]
42
>>> import json
>>> my_object = { "key1" : ["one", "two"] }
>>> json.dumps(my_object, indent=2)
"""
{
"key1": ["one", "two"]
}
"""
\center \huge Atelier
La librarie pour faire des requêtes HTTP en Python.
Malheureusement pas dans la librarie standard.
import requests
>>> response = request.get(url)
>>> response.status_code
200 # si tout va bien
>>> response.text
"<!DOCTYPE html ..."> # le texte de la réponse
>>> response = requests.get(url)
>>> text = response.text
>>> data = json.loads(text)
Ou directement
>>> response = requests.get(url)
>>> data = response.json()