1. Types de séquences et mutabilité

Avant de commencer à parler de tuples et de dictionnaires, nous devons introduire deux concepts importants: les types de séquence et la mutabilité.

Les types de séquences

Un type de séquence est un type de données en Python qui est capable de stocker plus d’une valeur (ou moins d’une, car une séquence peut être vide), et ces valeurs peuvent être parcourues séquentiellement (d’où le nom), élément par élément.

La boucle for étant un outil spécialement conçu pour parcourir les séquences, nous pouvons définir une séquence comme suit :

Une séquence est une donnée qui peut être parcourue par la boucle for.

Vous avez rencontré jusqu’à présent un type de séquence Python : la liste.

La liste est un exemple classique d’une séquence Python, bien qu’il existe d’autres séquences qui méritent d’être mentionnées, et nous allons vous les présenter maintenant.

La mutabilité

C’est une propriété de toutes les données de Python qui décrit sa disponibilité à être librement modifiée pendant l’exécution du programme.

Il existe deux types de données Python:

  • mutables : peuvent être mises à jour librement à tout moment - nous appelons une telle opération in situ.

  • non mutables : Les données non mutables (ou immuable) ne peuvent pas être modifiées.

2. Qu’est-ce qu’un tuple ?

2.1. Définition

Un tuple est un type de séquence non mutable. Il peut se comporter comme une liste, mais ne peut pas être modifié.

On ne peut ni lui ajouter, lui modifier ou lui supprimer un élément. Cela signifie que l’ajout d’un élément à la fin de la liste nécessiterait la recréation de la liste à partir de zéro.

En mathématiques, on parle de p-uplet.

2.2. Représentation

On le représente avec des parenthèses ou simplement en séparant les données qu’il contient avec des virgules :

# tuple1 contient des entiers
tuple1 = (1, 2, 4, 8)
# tuple2 contient des flottants (réels)
tuple2 = 1., .5, .25, .125

print(tuple1)
print(tuple2)

La sortie d’un tel code donne :

(1, 2, 4, 8)
(1.0, 0.5, 0.25, 0.125)

2.3. Comment créer un tuple?

Il est possible de créer un tuple vide, des parenthèses sont alors nécessaires :

empty_tuple = ()

Si vous souhaitez créer un tuple de un seul élément, vous devez terminer la valeur par une virgule :

oneElementTuple1 = (1, )
oneElementTuple2 = 1.,

Un tuple doit être distingué d’une valeur simple ordinaire, ce qui ne serait pas possible sans cette virgule, on obtiendrait à la place de simples variables.

2.4. Comment utiliser un tuple ?

Si vous souhaitez obtenir les éléments d’un tuple afin de les relire, vous pouvez utiliser les mêmes conventions auxquelles vous êtes habitué lors de l’utilisation des listes.

Exemple
myTuple = (1, 10, 100, 1000)

print(myTuple[0])
print(myTuple[-1])
print(myTuple[1:])
print(myTuple[:-2])

for elem in myTuple:
    print(elem)

Exécutez-le et vérifiez que le programme produit bien la sortie suivante :

1
1000
(10, 100, 1000)
(1, 10)
1
10
100
1000

2.5. Travail à faire : Créer un tuple à partir d’une liste

  • Créer la liste une_liste qui contient les éléments suivant : 1, 2, 3, 4

  • Créer un tuple un_tuple à partir de la liste une_liste

  • Afficher le contenu du tuple un_tuple

  • Ajouter l’élément 5 à la liste une_liste

  • Afficher le contenu de la liste une_liste

  • Ajouter l’élément 5 au tuple un_tuple.

  • Afficher le contenu du tuple un_tuple. Celui-ci doit contenir (1, 2, 3, 4, 5)

On ne peut pas ajouter d’élément dans un tuple. Il faut donc supprimer le tuple et le recréer à partir de la liste.

2.6. Les opérateurs des tuples

  • la fonction len() accepte les tuples en argument et retourne le nombre d’éléments qu’il contient.

  • l’opérateur + permet de joindre des tuples ensemble

  • l’opérateur * peut multiplier les tuples, tout comme les listes;

  • l’opérateur = peut affecter à un tuple un autre tuple

  • les opérateurs in et not in fonctionnent de la même manière que dans les listes.

Exemple
myTuple = (1, 10, 100)

t1 = myTuple + (1000, 10000)
t2 = myTuple * 3

print(len(t2))
print(t1)
print(t2)
print(10 in myTuple)
print(-10 not in myTuple)

Exécutez le code ci-dessus et vérifiez qu’il produit bien la sortie suivante :

9
(1, 10, 100, 1000, 10000)
(1, 10, 100, 1, 10, 100, 1, 10, 100)
True
True

L’utilisation de l’opérateur d’affectation peut se révéler utile pour échanger des valeurs de tuples :

var = 123
t1 = (1, )
t2 = (2, )
t3 = (3, var)
t1, t2, t3 = t2, t3, t1
print(t1, t2, t3)

Exécutez le code ci-dessus et vérifiez qu’il produit bien la sortie suivante :

(2,) (3, 123) (1,)

3. Qu’est-ce qu’un dictionnaire?

Le dictionnaire est une autre structure de données Python.

Ce n’est pas un type de séquence (mais peut être facilement adapté au traitement de séquence) et il est modifiable.

Depuis Python 3.6x, les dictionnaires sont devenus des collections ordonnées par défaut.

Pour expliquer ce qu’est réellement le dictionnaire Python, il est important de comprendre qu’il s’agit littéralement d’un dictionnaire.

Le dictionnaire Python fonctionne de la même manière qu’un dictionnaire bilingue. Par exemple, vous avez un mot anglais (par exemple, *cat*) et avez besoin de son équivalent français. Vous parcourez le dictionnaire afin de trouver sa traduction en français et c’est (très probablement) le mot *chat*.

  • Le mot recherché est nommé clé

  • Le mot retourné est nommé valeur

Un dictionnaire est un ensemble de paires clé-valeur :

  • chaque clé doit être unique : il n’est pas possible d’avoir plus d’une clé de la même valeur

  • une clé peut être des données de tout type : elle peut être un nombre (entier ou flottant) ou une chaîne de caractères

  • un dictionnaire n’est pas une liste : une liste contient un ensemble de valeurs numérotées, tandis qu’un dictionnaire contient des paires clé-valeurs;

  • la fonction len() fonctionne également pour les dictionnaires : elle renvoie le nombre d’éléments de clé-valeur dans le dictionnaire;

  • un dictionnaire est un outil à sens unique : si vous avez un dictionnaire anglais-français, vous pouvez rechercher des équivalents français de termes anglais, mais pas l’inverse.

4. Déclaration

La déclaration d’un dictionnaire se fait de la même manière que pour n’importe quelle variable. On lui donne un nom et on l’affecte d’une collection de clés-valeurs entre accolades {} et séparées par des virgules ,. Les clés et les valeurs sont séparés par : :

Soit une variable appelée dict de type `dict`et remplie d’une collection clés-valeurs :

>>> dictionnary = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}
>>> type(dictionnary)
<class 'dict'>

5. Comment utiliser un dictionnaire ?

Pour obtenir une des valeurs, il faut fournir une valeur de clé valide :

print (dict ['cat'])

Obtenir la valeur d’un dictionnaire ressemble à l’indexation pour les liste, en particulier grâce aux crochets entourant la valeur de la clé.

  • Si la clé est une chaîne, vous devez la spécifier sous forme de chaîne : 'une chaine'

  • Les clés sont sensibles à la casse : 'Suzy' est différent de 'suzy'.

5.1. Travail à faire : Créer un dictionnaire

  • Créer un dictionnaire vide empty_dictionnary.

  • Afficher son contenu.

  • Créer le dictionnaire phone_number qui contient les numéros de téléphones des personnes suivantes :

    • boss : 5551234567

    • Suzy : 22657854310

    • Andy : 34546676535

  • Afficher le contenu du dictionnaire phone_number

  • Rechercher et afficher le numéro de téléphone de Suzy

  • Rechercher et afficher le numéro de téléphone de John

5.2. Travail à faire : Rechercher dans un dictionnaire

  • Créer le dictionnaire suivant : dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}

  • Créer la liste suivante : words = ['cat', 'lion', 'horse']

  • Parcourir la liste words et afficher la valeur correspondante à chaque clé du dictionnaire qu’elle contient.

Utiliser l’opérateur in pour tester la présence de la clé dans le dictionnaire.

 
# Déclaration du dictionnaire dict
# Déclaration de la liste words
# parcours de la liste
for word in words:
  #si word est dans le dictionnaire dict
  if ??? in ???:
      #Affiche clé->valeur
      print(word, "->", ???)
    else:
        print(word, "is not in dictionary")

5.3. Utiliser les clés

La méthode keys() renvoie la liste des clés utilisées dans un dictionnaire. On peut itérer cette liste avec une boucle for.

dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}
for key in dict.keys():
    print(key, "->", dict[key])

Exécutez le code ci-dessus et vérifiez qu’il produit bien la sortie suivante :

horse -> cheval
dog -> chien
cat -> chat

5.4. Trier les clés

  • Utiliser la fonction sorted() pour trier les clés.

dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}
for key in sorted(dict.keys()):
    print(key, "->", dict[key])

Exécutez le code ci-dessus et vérifiez qu’il produit bien la sortie suivante :

cat -> chat
dog -> chien
horse -> cheval

5.5. Utiliser les valeurs

Il existe également une méthode nommée values(), qui fonctionne de manière similaire à keys(), mais renvoie une liste de valeurs.

dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}
for french in dict.values():
    print(french)

Exécutez le code ci-dessus et vérifiez qu’il produit bien la sortie suivante :

chat
chien
cheval

Les dictionnaires n’étant pas en mesure de trouver automatiquement une clé pour une valeur donnée, le rôle de cette méthode est plutôt limité.

5.6. Utiliser les items

Une autre méthode pour accéder aux clés et aux valeurs consiste à utiliser la méthode items().

Cette méthode renvoie une liste de tuples où chaque tuple est une paire clé-valeur.

 
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}

for english, french in dict.items():
    print(english, "->", french)

Notez la manière dont le tuple a été utilisé comme variable de boucle for.

Exécutez le code ci-dessus et vérifiez qu’il produit bien la sortie suivante :

cat -> chat
dog -> chien
horse -> cheval

5.7. Modifier une valeur

Attribuer une nouvelle valeur à une clé existante est simple. Comme les dictionnaires sont mutables, il n’y a aucun obstacle à les modifier.

Nous allons remplacer la valeur *chat* par *minou*.

dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}

dict['cat'] = 'minou'
print(dict)

Exécutez le code ci-dessus et vérifiez qu’il produit bien la sortie suivante :

{'dog': 'chien', 'horse': 'cheval', 'cat': 'minou'}

5.8. Travail à faire : Modifier une valeur

  • Modifier la valeur qui correspond à la clé dog en cabot

  • Modifier la valeur qui correspond à la clé horse en canasson

5.9. Ajouter un item clé-valeur

L’ajout d’une nouvel item clé-valeur à un dictionnaire est aussi simple que de changer une valeur, il suffit d’affecter une valeur à une nouvelle clé, auparavant inexistante.

Cette affectation est très différente de celle des listes :

Les listes ne permettent pas d’attribuer des valeurs à des indices inexistants.
Exemple
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}

dict['swan'] = 'cygne'
print(dict)

Exécutez le code ci-dessus et vérifiez qu’il produit bien la sortie suivante :

{'swan': 'cygne', 'horse': 'cheval', 'dog': 'chien', 'cat': 'chat'}

Vous pouvez également insérer un élément dans un dictionnaire en utilisant la méthode update()
Exemple
dict = {"cat": "chat", "dog": "chien", "horse": "cheval"}

dict.update ({"duck": "canard"})
print(dict)

5.10. Travail à faire : Ajouter des items

Ajouter les items suivants : * pig : cochon. * fish : poisson. * cow : vache. * sheep : mouton.

5.11. Supprimer des items

Pour supprimer un item, on utilise l’instruction del :

Exemple
dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}

del dict['dog']
print(dict)

Exécutez le code ci-dessus et vérifiez qu’il produit bien la sortie suivante :

{'cat': 'chat', 'horse': 'cheval'}

Pour supprimer le dernier élément d’un dictionnaire, vous pouvez utiliser la méthode popitem() :

dict = {"cat" : "chat", "dog" : "chien", "horse" : "cheval"}

dict.popitem() print(dict) # outputs: {'cat' : 'chat', 'dog' : 'chien'}

Dans les versions de Python antérieures à 3.6.7, la méthode popitem() supprime un élément aléatoire du dictionnaire.

6. Travail à faire : Dictionnaire et tuple

Nous avons besoin d’un programme pour évaluer les notes moyennes des élèves :

  • le programme doit demander le nom de l’élève, suivi de sa note unique

  • les noms peuvent être entrés dans n’importe quel ordre

  • la saisie de Q termine la saisie des données

  • une liste de tous les noms, avec le score moyen évalué, doit ensuite être fournie.

Complétez et évaluer le programme suivant :

# créer le dictionnaire vide schoolClass

while True:
  name = input("Entrez le nom de l'élève (ou 'Q' pour stopper): ")
  #Si Q est saisie on arrête
  if name == ???:
      break

  note = int(input("Entrez la note de l'élève (0-20): "))

  #Si l'élève existe dans le dictionnaire
  if ??? in ???:
    #Ajouter la note à l'élève sous la forme d'un tuple
    schoolClass[???] += ???
  else:
    #Affecter la note à l'élève sous la forme d'un tuple
    schoolClass[???] = ???

#Parcourir la liste des clés triées du dictionnaire
for name in ???:
  #Variables pour préparer le calcul de la moyenne
  sum = 0
  counter = 0

  #Parcour du tuple des notes de l'élève en cours
  for note in ???:
    #sum contient la somme des notes de l'élève en cours
    sum ???
    #incrémentation de counter : counter contient le nombre de notes de l'élève en cours
    counter ???
  #Affichage du nom de l'élève et de sa moyenne
  print(name, ":", ???)

7. Point clés à retenir : les tuples

Un tuple est un type de données

Les tuples sont des collections de données ordonnées et non mutables (immuables). Ils peuvent être considérés comme des listes immuables. Ils sont écrits entre parenthèses :

myTuple = (1, 2, True, "a string", (3, 4), [5, 6], None)
print(myTuple)

myList = [1, 2, True, "a string", (3, 4), [5, 6], None]
print(myList)

Chaque élément d’un tuple peut être d’un type différent (entiers, chaînes, booléens, etc…​). De plus, les tuples peuvent contenir d’autres tuples ou listes (et inversement).
Creation d’un tuple

  • Vous pouvez créer un tuple vide comme cela :

emptyTuple = ()
print(type(emptyTuple))    # outputs: <class \'tuple\'>

  • Un tuple à un élément peut être créé comme cela :

oneElemTup1 = ("one", )    # brackets and a comma
oneElemTup2 = "one",       # no brackets, just a comma

ATTENTION : Si vous supprimez la virgule, vous direz à Python de créer une variable, pas un tuple :

myTup1 = 1,
print(type(myTup1))    # outputs: <class \'tuple\'>

myTup2 = 1
print(type(myTup2))    # outputs: <class \'int\'>

  • Vous pouvez également créer un tuple à l’aide d’une fonction intégrée Python appelée tuple(). Ceci est particulièrement utile lorsque vous souhaitez convertir un certain itérable (par exemple, une liste, une plage, une chaîne, etc.) en un tuple :

myTup = tuple((1, 2, "string"))
print(myTup)

lst = [2, 4, 6]
print(lst)    # outputs: [2, 4, 6]
print(type(lst))    # outputs: <class \'list\'>
tup = tuple(lst)
print(tup)    # outputs: (2, 4, 6)
print(type(tup))    # outputs: <class \'tuple\'>

  • De la même manière, lorsque vous souhaitez convertir un itérable en liste, vous pouvez utiliser une fonction intégrée Python appelée list() :

tup = 1, 2, 3,
lst = list(tup)
print(type(lst))    # outputs: <class \'list\'>
Accéder aux éléments d’un tuple

Vous pouvez accéder aux éléments de tuple en les indexant :

myTuple = (1, 2.0, "string", [3, 4], (5, ), True)
print(myTuple[3])    # outputs: [3, 4]
Les éléments d’un tuple sont immuables

Les tuples sont immuables, ce qui signifie que vous ne pouvez pas modifier leurs éléments (vous ne pouvez pas ajouter de tuples, ni modifier ou supprimer des éléments de tuple). L’extrait de code suivant provoquera une exception :

myTuple = (1, 2.0, "string", [3, 4], (5, ), True)
myTuple[2] = "guitar"    # a TypeError exception will be raised

Cependant, vous pouvez supprimer un tuple dans son ensemble :

myTuple = 1, 2, 3,
del myTuple
print(myTuple)    # NameError: name \'myTuple\' is not defined
Opérations sur un tuple

  • Parcourir les éléments d’un tuple :

t1 = (1, 2, 3)
for elem in t1:
    print(elem)

  • Vérifier si un élément spécifique est (pas) présent dans un tuple :

t2 = (1, 2, 3, 4)
print(5 in t2)      # return False
print(5 not in t2)  # return True

  • Utiliser la fonction len() pour vérifier combien d’éléments il y a dans un tuple :

t3 = (1, 2, 3, 5)
print(len(t3))    # return 4

  • Joindre ou multiplier des tuples :

t4 = t1 + t2
t5 = t3 * 2

print(t4) # return (1, 2, 3, 1, 2, 3, 4)
print(t5) # return (1, 2, 3, 5, 1, 2, 3, 5)
Execices autocorrigés

  • Quelle est la sortie de cet extrait de code :

myTup = (1, 2, 3)
print(myTup[2])
  1. 1
  2. 2
  3. 3

  • Quelle est la sortie de cet extrait de code :

tup = 1, 2, 3
a, b, c = tup

print(a * b * c)
  1. 6
  2. tup
  3. (1, 2, 3)

  • Complétez le code ci-dessous pour compter le nombre de 2 présents dans le tuple :

tup = 1, 2, 3, 2, 4, 5, 6, 2, 7, 2, 8, 9
duplicates = # your code

print(duplicates)    # outputs: 4
  1. tup.count(2)
  2. count(tup,2)
  3. len(tup,2)

8. Point clés à retenir : les dictionnaires

Un dictionnaire est un type de données

  • Les dictionnaires sont des collections de données ordonnées (depuis Python 3.6x), modifiables (mutables) et indexées.

  • Chaque dictionnaire est un ensemble de paires clé/valeur. Vous pouvez les créer en utilisant la syntaxe suivante :

myDictionary = {
    key1 : value1,
    key2 : value2,
    key3 : value3,
    }
Accès aux éléments dans un dictionnaire

Si vous souhaitez accéder à un élément du dictionnaire, vous pouvez le faire en faisant référence à sa clé à l’intérieur d’une paire de crochets ou en utilisant la méthode get() :

polEngDict = {
    "kwiat" : "flower",
    "woda"  : "water",
    "gleba" : "soil"
    }

item1 = polEngDict["gleba"]    # ex. 1
print(item1)    # outputs: soil

item2 = polEngDict.get("woda")
print(item2)    # outputs: water
Modifier un élément d’un dictionnaire

Si vous souhaitez modifier la valeur associée à une clé spécifique, vous pouvez le faire en vous référant au nom de la clé de l’élément de la manière suivante :

polEngDict = {
    "zamek" : "castle",
    "woda"  : "water",
    "gleba" : "soil"
    }

polEngDict["zamek"] = "lock"
item = polEngDict["zamek"]    # outputs: lock
Ajouter un élément à un dictionnaire

Si vous souhaitez ajouter un élément (item) à un dictionnaire, vous pouvez le faire en utilisant la méthode update() :

polEngDict = {
    "zamek" : "castle",
    "woda"  : "water",
    "gleba" : "soil"
    }

item = {"piwo" : "beer"}
polEngDict.update(item)
print(polEngDict["piwo"])   # outputs : beer
Parcourir les éléments d’un dictionnaire

Vous pouvez utiliser la boucle for pour parcourir un dictionnaire, par exemple :

polEngDict = {
    "zamek" : "castle",
    "woda"  : "water",
    "gleba" : "soil"
    }

for item in polEngDict:
    print(item)    # outputs: zamek
                   #          woda
                   #          gleba
Parcourir les clés d’un dictionnaire

Si vous souhaitez parcourir les clés et les valeurs d’un dictionnaire, vous pouvez utiliser la méthode items(), par exemple :

polEngDict = {
    "zamek" : "castle",
    "woda"  : "water",
    "gleba" : "soil"
    }

for key, value in polEngDict.items():
    print("Pol/Eng ->", key, ":", value)
Vérifier la présence d’une clé dans un dictionnaire

pour vérifier si une clé donnée existe dans un dictionnaire, vous pouvez utiliser le mot clé in :

polEngDict = {
    "zamek" : "castle",
    "woda"  : "water",
    "gleba" : "soil"
    }

if "zamek" in polEngDict:
    print("Yes")
else:
    print("No")
Supprimer un élément ou un dictionnaire

Vous pouvez utiliser le mot clé del pour supprimer un élément spécifique ou supprimer un dictionnaire. Pour supprimer tous les éléments du dictionnaire, vous devez utiliser la méthode clear() :

polEngDict = {
    "zamek" : "castle",
    "woda"  : "water",
    "gleba" : "soil"
    }

print(len(polEngDict))    # outputs: 3
del polEngDict["zamek"]    # remove an item
print(len(polEngDict))    # outputs: 2

polEngDict.clear()   # removes all the items
print(len(polEngDict))    # outputs: 0

del polEngDict    # removes the dictionary
Copier un dictionnaire

Pour copier un dictionnaire, utilisez la méthode copy() :

polEngDict = {
    "zamek" : "castle",
    "woda"  : "water",
    "gleba" : "soil"
    }

copyDict = polEngDict.copy()
Execices autocorrigés

  • Compélétez le programme ci-dessous qui doit «coller» les deux dictionnaires (d1 et d2) ensemble pour en créer un nouveau (d3). :

d1 = {'Adam Smith':'A', 'Judy Paxton':'B+'}
d2 = {'Mary Louis':'A', 'Patrick White':'C'}
d3 = {}

for item in (d1, d2):
    # your code

print(d3)
  1. d3[item] = d1[item] + d2[item]
  2. d3 = d1 + d2
  3. d3.update(item)

  • Compélétez le programme ci-dessous qui convertira le tuple de couleurs en dictionnaire. :

colors = (("green", "#008000"), ("blue", "#0000FF"))

# your code

print(colDict)
  1. colDict[colors[0]]=colors[1]
  2. colDict = dict(colors)
  3. colDict.update(colors)

  • Quelle est la sortie du programme suivant :

colors = {
    "white" : (255, 255, 255),
    "grey"  : (128, 128, 128),
    "red"   : (255, 0, 0),
    "green" : (0, 128, 0)
    }

for col, rgb in colors.items():
    print(col, ":", rgb)

  1. "white" : 255, 255, 255
    "grey" : 128, 128, 128,
    "red" : 255, 0, 0,
    "green" : 0, 128, 0

  2. "white" : "255, 255, 255"
    "grey" : "128, 128, 128",
    "red" : "255, 0, 0",
    "green" : "0, 128, 0"

  3. "white" : (255, 255, 255)
    "grey" : (128, 128, 128),
    "red" : (255, 0, 0),
    "green" : (0, 128, 0)

9. Projet : La météo dans ma ville

Le but du projet est de réaliser une application qui fournie les principales données météorologiques d’une ville de France (ou du monde pourquoi pas !). On s’appui pour cela sur une API (Application Pargrammable Interface) qui offre la possibilité d’obtenir les informations de la base de données ouverte OpenWeather : https://openweathermap.org

9.1. Récupération des données météo

Les données météos sont obtenues depuis l’API de https://openweathermap.org/current grace à une clé d’API. Cette clé est personnelle et gratuite. Vous pouvez utiliser la mienne ou vous créer un compte pour obtenir votre propre clé :

https://openweathermap.org/api

Les données récupérées sont au format JSON :

{"coord":{"lon":-0.13,"lat":51.51},"weather":[{"id":300,"main":"Drizzle","description":"light intensity drizzle","icon":"09d"}],"base":"stations","main":{"temp":280.32,"pressure":1012,"humidity":81,"temp_min":279.15,"temp_max":281.15},"visibility":10000,"wind":{"speed":4.1,"deg":80},"clouds":{"all":90},"dt":1485789600,"sys":{"type":1,"id":5091,"message":0.0103,"country":"GB","sunrise":1485762037,"sunset":1485794875},"id":2643743,"name":"London","cod":200}

9.2. Code de bases

Récupérer le code de base sur github.classroom pour démarrer le Projet

Obtenir le code du projet (ne faire qu’une seule fois !)

9.3. Accéder au données :

Compléter le code python pour :

  • Afficher le nom et les coordonnées de la ville

  • Afficher la température en °C

  • Afficher l’humidité relative

  • Afficher la pression atmosphérique en hpa

  • Afficher la vitesse du vent et son orientation

9.4. Interroger l’API

Compléter le code pour qu’un utilisateur puisse interroger l’API pour la ville de son choix. On se limitera à la France.

the_end.jpg