Cours de NSI Première
Constructions élémentaires Booléens Fonctions Chaînes de caractères Tableaux p-uplets et dictionnaires Tables de données Flottants Algorithmes classiques Index Énoncés
Cours de NSI Première
Constructions élémentaires Booléens Fonctions Chaînes de caractères Tableaux p-uplets et dictionnaires Tables de données Flottants Algorithmes classiques Index Énoncésp-uplets, fonctions retournant un p-uplet, p-uplets nommés, dictionnaires, clés et valeurs
Un p-uplet permet, comme un tableau, de stocker en mémoire plusieurs valeurs dans une seule variable. En Python, le type p-uplet est appelé tuple.
Les extrémités du p-uplet sont repérées par des parenthèses et les valeurs sont séparées par des virgules.
date = ('La prise de la Bastille', 14, 7, 1789)
Comme pour un tableau, les valeurs contenues dans un p-uplet sont indexées par des entiers, à partir de l'index 0, et la fonction len permet de connaître le nombre de valeurs contenues dans le p-uplet.
print(date[0] + ' a eu lieu le ' + str(date[1]) + '/' + str(date[2]) + '/' + str(date[3]) + '.')
len(date)
Mais, à la différence d'un tableau, il n'est pas possible de modifier les valeurs contenues dans un p-uplet, ou d'en ajouter. On parle d'immutabilité.
date[0] = 'La fête de la Fédération' # Ces affectations
date[3] = 1790 # provoquent une erreur
Seule une redéfinition complète du p-uplet est possible.
date = ('La fête de la Fédération', 14, 7, 1790)
print(date[0] + ' a eu lieu le ' + str(date[1]) + '/' + str(date[2]) + '/' + str(date[3]) + '.')
Le tableau union_europeenne défini ci-dessous contient six p-uplets représentant les six pays fondateurs de l'UE.
Chaque p-uplet contient trois valeurs : le nom du pays, sa population en 2016 (en milliers d'habitants) et sa superficie (en kilomètres carrés).
union_europeenne = [('Allemagne', 82162, 356900),
('Belgique', 11289, 30500),
('France', 66661, 544000),
('Italie', 60665, 301300),
('Luxembourg', 576, 2600),
('Pays-Bas', 16979, 41200)]
Question 1 : Ecrire le code permettant de calculer la population totale des six pays fondateurs de l'UE.
population_totale = 0
for k in range(6):
population_totale += union_europeenne[k][1]
population_totale *= 1000
print(population_totale)
Question 2 : Ecrire le code permettant d'afficher, pour chaque pays fondateur de l'UE, sa densité de population (en habitants par kilomètre carré, arrondie à l'entier le plus proche grâce à la fonction round).
for k in range(6):
pays = union_europeenne[k]
print(pays[0], ':', round(pays[1] * 1000 / pays[2]), 'hab/km2')
Question 3 : Ecrire la spécification de la fonction suivante :
def perimetre_et_aire_triangle(a, b, c):
"""
Calcule le périmètre et l'aire d'un triangle dont les côtés mesurent a, b et c
- Entrées : a, b, c (nombres strictement positifs)
- Sortie : couple de nombres constitué du périmètre et de l'aire du triangle
"""
if type(a) not in [int, float] or type(b) not in [int, float] or type(c) not in [int, float]:
raise TypeError('les arguments doivent être des nombres')
if a <= 0 or b <= 0 or c <= 0:
raise ValueError('les arguments doivent être strictement positifs')
perimetre = a + b + c
demi_per = perimetre / 2
# l'aire du triangle est calculée avec la formule de Héron
aire = (demi_per * (demi_per-a) * (demi_per-b) * (demi_per-c))**0.5
return (perimetre, aire)
Il y a deux façons d'appeler une fonction qui retourne un p-uplet.
couple = perimetre_et_aire_triangle(3, 4, 5)
print('Le périmètre est', couple[0], 'et l\'aire est', couple[1])
Dans le premier cas, les deux valeurs du p-uplet retourné sont stockées dans une seule variable.
p, a = perimetre_et_aire_triangle(3, 4, 5)
print('Le périmètre est', p, 'et l\'aire est', a)
Dans le second cas, ces deux valeurs sont stockées dans deux variables indépendantes.
Question 4 : Définir une fonction nouveau_pays qui demande à l'utilisateur de saisir successivement au clavier le nom, la population et la superficie d'un pays, et qui retourne un p-uplet de la forme (nom, population, superficie).
def nouveau_pays():
nom = input('Nom du pays : ')
pop = int(input('Population (en milliers) : '))
sup = int(input('Superficie (en km2) : '))
return (nom, pop, sup)
Question 5 : Après avoir exécuté les deux cellules ci-dessous, expliquer le rôle de la fonction clear_output.
from IPython.display import clear_output
for _ in range(21):
union_europeenne.append(nouveau_pays())
clear_output()
clear_output permet d'effacer du Notebook Jupyter l'affichage situé sous la cellule en cours d'exécution, ce qui en améliore la lisibilité dans certaines situations.
Question 6 : Ecrire un programme calculant la population, la superficie et la densité de population de l'UE.
population_totale = 0
superficie_totale = 0
for k in range(27):
population_totale += union_europeenne[k][1]
superficie_totale += union_europeenne[k][2]
population_totale *= 1000
print('La population de l\'UE est de ' + str(population_totale) + ' habitants.')
print('La superficie de l\'UE est de ' + str(superficie_totale) + ' km2.')
print('La densité de l\'UE est de ' + str(population_totale//superficie_totale) + ' hab/km2.')
Les éléments d'un tableau ou d'un p-uplet sont toujours indexés par des entiers positifs, ce qui peut rendre leur manipulation délicate ou créer des confusions.
En reprenant l'exemple des pays de l'UE traité précédemment, il est nécessaire de se souvenir que chaque pays est représenté par un p-uplet dont la première valeur est le nom du pays, la deuxième la population et la troisième la superficie.
Si on souhaite que les valeurs soient indexées par des mots-clés plutôt que par des entiers, on utilise un type de variable particulier : un dictionnaire.
Les extrémités d'un dictionnaire sont repérées par des accolades. Chaque valeur est précédée d'une clé, avec la syntaxe cle : valeur, et les associations clé/valeur sont séparées les unes des autres par des virgules.
pays = {'nom' : 'la France', 'population' : 66661, 'superficie' : 544000}
Question 7 : Après avoir exécuté la cellule suivante, expliquer le rôle de la fonction len et des commandes .keys(), .values() et .items().
print(len(pays))
print(pays.keys())
print(pays.values())
print(pays.items())
len renvoie la longueur (c'est-à-dire le nombre de clés) du dictionnaire qui est passé en argument..keys() liste les clés du dictionnaire, la commande .values() liste les valeurs et la commande .items() liste les associations clé/valeur.
Question 8 : Dans la cellule suivante, on définit une fonction afficher_informations. Compléter la spécification de la fonction en indiquant quelles clés doit au minimum contenir le dictionnaire p pour que l'exécution se déroule sans erreur.
def afficher_informations(pays):
"""
Affiche à l'écran diverses informations sur le pays
- Entrée : pays (dictionnaire contenant au moins les clés 'nom', 'population' et 'superficie')
- Effet de bord : affichage à l'écran
"""
if type(pays) != dict:
raise TypeError('l\'argument doit être un dictionnaire')
for cle in ['nom', 'population', 'superficie']:
if cle not in pays.keys():
raise KeyError('l\'argument doit posséder la clé ' + str(cle))
print('La population de ' + pays['nom'] + ' est de ' + str(pays['population']*1000) + ' hab.')
print('Sa superficie est de ' + str(pays['superficie']) + ' km2.')
print('Sa densité est de ' + str(round(pays['population']*1000/pays['superficie'])) + ' hab/km2.')
if 'monnaie' in pays.keys():
print('Sa monnaie est ' + pays['monnaie'] + '.')
afficher_informations(pays)
pays passé en argument contient bien au moins les clés 'nom', 'population' et 'superficie'.
Un dictionnaire est mutable : il est possible de modifier la valeur associée à une clé, de créer une clé supplémentaire ou de supprimer une clé.
# On modifie la valeur associée à trois clés existantes
pays['nom'] = 'la Grèce'
pays['population'] = 10993
pays['superficie'] = 132000
# On définit deux nouvelles clés
pays['capitale'] = 'Athènes'
pays['monnaie'] = 'l\'euro'
afficher_informations(pays)
pays, à savoir 'capitale' et 'monnaie'.dictionnaire[nouvelle_cle] = nouvelle_valeur.
# On supprime une clé
del pays['nom']
print(pays.keys())
'nom'.del dictionnaire[cle_a_supprimer].
round pour arrondir une valeur numérique.clear_output pour effacer l'affichage sous la cellule en cours d'exécution.len et les commandes .keys(), .values() et .items().