NSI Première
NSI Première
Un tableau associatif est un type de variable qui permet de regrouper des données, un peu comme un tableau, sauf que les éléments ne sont pas repérés par leur indice dans cet ensemble mais pas leur clé, qui peut être un entier, une chaîne de caractères, etc...
En Python les tableaux associatifs correspondent au type construit dictionnaire ( dict ).
Les dictionnaires se révèlent très pratiques lorsque l'on doit manipuler des structures complexes à décrire et que les tableaux présentent leurs limites.
Un dictionnaire est défini par des accolades { }.
Chaque élément d'un dictionnaire est composé d'une clé et d'une valeur, séparées par deux points :.
La structure d'un dictionnaire est alors :
dico = {clé1: valeur1, clé2: valeur2, ...}
Les clés d'un dictionnaire doivent être uniques. Elles doivent être non mutables ( donc de type int, float, str, tuple ), ce qui signfie que l'on ne peut pas par exemple
utiliser des clés de type list.
Les valeurs d'un dictionnaires peuvent elles être multiples et mutables ou non mutables ( tous les types sont acceptés ).
À la différence des tableaux et des tuples, les éléments d'un dictionnaire n'ont pas d'ordre particulier, d'où l'appellation d'ensemble non-ordonné : il n'y a pas de "premier élément", "deuxième élément", etc...
Exemples :
animaux = {"nom": "singe", "poids": 70, "taille": 1.75} # clés de type str et valeurs de type variés
placard = {"chemise" : 3, "pantalon" : 6, "tee-shirt" : 7} # clés de type str et valeurs de type int
simpson = {"père" : "Homer" , "mère" : "Marge", "fils" : "Bart", "fille" : "Lisa"} # clés et valeurs de type str
dressing = {"chemise" : ["M", "Bleu", "tiroir du bas"], "pantalon" : ["M", "Vert", "tiroir du milieu"]} # clés de type str et valeurs de type list
C'est la méthode la plus simple. Elle consiste à créer le dictionnaire en utilisant le symbole d'affectation = , et en saisissant les éléments les uns après les autres.
simpson = {"père" : "Homer" , "mère" : "Marge", "fils" : "Bart", "fille" : "Lisa"}
Cette méthode ressemble à celle utilisée pour remplir les tableaux. Au lieu d'indiquer les crochets du tableau [ ], on utilise les accolades du dictionnaire { }.
Exemples :
carre = {a: a**2 for a in range(0, 11)}
>>> carre = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}
vide = {i: None for i in range(5)}
>>> vide = {0: None, 1: None, 2: None, 3: None, 4: None}
Pour accéder à la valeur correspondant à une clé, on utilise, comme pour les valeurs dans un tableau, la notation crochets [ ] en
indiquant la clé au lieu de l'indice : dico[clé] .
print(simpson["père"])
>>> Homer
print(simpson["mère"])
>>> Marge
Bien entendu, une erreur est générée si la clé n'existe pas dans le dictionnaire.
print(simpson["tante"])
>>> KeyError: 'tante'
Comme un tableau ou un tuple, un dictionnaire peut se parcourir élément par élément.
C'est l'équivalent du parcours par indice d'un tableau :
for cle in simpson :
print(cle)
père
mère
fils
fille
for cle in simpson :
print(simpson[cle])
Homer
Marge
Bart
Lisa
On utilise la méthode values() :
for valeur in simpson.values() :
print(valeur)
Homer
Marge
Bart
Lisa
On utilise la méthode items() qui renvoie un tuple constitué de chaque élément clé/valeur :
for cle, valeur in vide.items():
print(cle, valeur)
0 None
1 None
2 None
3 None
4 None
Un dictionnaire est mutable comme un tableau ( mais à la différence d'un tuple ), c'est à dire que l'on peut en modifier les éléments.
Du fait qu'il soit mutable, la copie d'un dictionnaire présentera donc les mêmes problèmes que la copie d'un tableau.
Pour ajouter un élément clé/valeur à un dictionnaire, on utilise l'instruction : dico[clé] = valeur.
Exemple :
user = {'Marcel': 1234, 'Maurice': 0123, 'Gustave': 0000}
user['Bond'] = 007
>>> user = {'Marcel': 1234, 'Maurice': 0123, 'Gustave': 0000, 'Bond': 007}
user['Bond'] = 008
>>> user = {'Marcel': 1234, 'Maurice': 0123, 'Gustave': 0000, 'Bond': 008}
Pour supprimer un ensemble clé/valeur à un dictionnaire, on utilise l'instruction del dico[clé].
Exemple :
del user["Maurice"]
>>> user = {'Marcel': 1234, 'Gustave': 0000, 'Bond': 008}
L'opérateur in permet de tester si une clé, une valeur ou un ensemble clé/valeur se trouve dans le dictionnaire :
>>> "Marcel" in user.keys()
True
>>> "Maurice" in user.keys()
False
>>> "Bond" in user.values()
False
>>> 1234 in user.values()
True
>>> ('Bond', '008') in user.items()
True
définir le dictionnaire personne contenant les informations suivantes relatives à une personne :
2**0 jusqu'à 2**10) :
dico = {0:1, 1:2, 2:4, 3:8, 4:16, 5:32, 6:64 ...}
numeros = ["1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","2A","2B","21","22","23","24","25","26","27","28","29","30","31","32","33","34","35","36","37","38","39","40","41","42","43","44","45","46","47","48","49","50","51","52","53","54","55","56","57","58","59","60","61","62","63","64","65","66","67","68","69","70","71","72","73","74","75","76","77","78","79","80","81","82","83","84","85","86","87","88","89","90","91","92","93","94","95","971","972","973","974","976"]
noms = ["Ain","Aisne","Allier","Alpes-de-Haute-Provence","Hautes-Alpes","Alpes-Maritimes","Ardèche","Ardennes","Ariège","Aube","Aude","Aveyron","Bouches-du-Rhône","Calvados","Cantal","Charente","Charente-Maritime","Cher","Corrèze","Corse-du-Sud","Haute-Corse","Côte-d'Or","Côtes d'Armor","Creuse","Dordogne","Doubs","Drôme","Eure","Eure-et-Loir","Finistère","Gard","Haute-Garonne","Gers","Gironde","Hérault","Ille-et-Vilaine","Indre","Indre-et-Loire","Isère","Jura","Landes","Loir-et-Cher","Loire","Haute-Loire","Loire-Atlantique","Loiret","Lot","Lot-et-Garonne","Lozère","Maine-et-Loire","Manche","Marne","Haute-Marne","Mayenne","Meurthe-et-Moselle","Meuse","Morbihan","Moselle","Nièvre","Nord","Oise","Orne","Pas-de-Calais","Puy-de-Dôme","Pyrénées-Atlantiques","Hautes-Pyrénées","Pyrénées-Orientales","Bas-Rhin","Haut-Rhin","Rhône","Haute-Saône","Saône-et-Loire","Sarthe","Savoie","Haute-Savoie","Paris","Seine-Maritime","Seine-et-Marne","Yvelines","Deux-Sèvres","Somme","Tarn","Tarn-et-Garonne","Var","Vaucluse","Vendée","Vienne","Haute-Vienne","Vosges","Yonne","Territoire de Belfort","Essonne","Hauts-de-Seine","Seine-St-Denis","Val-de-Marne","Val-D'Oise","Guadeloupe","Martinique","Guyane","La Réunion", "Mayotte"]
Compléter l'instruction ci-dessous afin d'obtenir un dictionnaire dont les clefs correspondent aux numéros des départements et dont les valeurs correspondent aux noms des départements :
departements = { "1" : "Ain", "2" : "Aisne", "3" : "Allier", ...}
ages = {'Mirza' : 7, 'Tom' : 4, 'Moustache' : 6, 'Patoune' : 5, 'Frisco' : 6, 'Tacos' : 5, 'Sleepy' : 3, 'Belle' : 4, 'Zaza' : 11, 'Oxmo' : 13}
Compléter l'instruction suivante afin d'obtenir la liste de tous les noms de chats ayant plus de 7 ans :
Le dictionnaire scrabble ci-dessous contient la valeur de chacune des lettres de l'alphabet au Scrabble :
scrabble = {"A":1,"B":3,"C":3,"D":2,"E":1,"F":4,"G":2,"H":4,"I":1,"J":8,"K":10,"L":1,"M":2,"N":1,"O":1,"P":3,"Q":8,"R":1,"S":1,"T":1,"U":1,"V":4,"W":10,"X":10,"Y":10,"Z":10}
score() qui calcule, en utilisant le dictionnaire scrabble, le score obtenu en plaçant un mot passé en argument à la fonction ( sans tenir compte des cases bonus : lettre compte-double,
mot compte-triple, etc...)
def score(mot: str)->int:
'''Fonction qui calcule le score d'un mot placé au Scrabble
ENTREE :
mot = chaîne de caractères représentant le mot à évaluer
SORTIE :
le score associé à ce mot
'''
pass
doctest ) :
score('NSI') == 3
score('BONJOUR') == 16
score('KIWI') == 22
score('ANTICONSTITUTIONNELLEMENT') == 28
Les Romains n'utilisaient pas la numération de position comme nous le faisons, mais un système où chaque symbole représente une certaine valeur décimale :
Pour obtenir le nombre exprimé par une suite de ces "chiffres romains", il faut faire la somme de toutes leurs valeurs décimales, en suivant les règles suivantes :
Exemple :
"MCMXIX" = "M - C + M + X - I + X" = 1000 - 100 + 1000 + 10 - 1 + 10 = 1919
rom_to_dec() qui utilise le dictionnaire romains pour convertir en base 10 un nombre en chiffres romains passé en argument.
def rom_to_dec(r: str)->int:
'''Fonction de conversion d'un nombre en chiffres romains en base 10
ENTREE :
r = chaîne de caractères représentant le nombre en chiffres romains
SORTIE :
le nombre converti en base 10
'''
romains = {} # dictionnaire des équivalences chiffres romains <-> valeur décimale ( à compléter )
pass
analyse() qui prend en argument une chaîne de caractères et renvoie un dictionnaire associant à chaque caractère apparaissant dans la chaîne le nombre de ses occurrences,
c'est à dire le nombre de fois où ce caractère apparaît dans la chaîne.
def analyse(phrase: str)->dict:
'''Fonction comptant le nombre d'occurrences de chaque caractère dans une chaîne
ENTREE :
phrase = chaîne de caractères
SORTIE :
le dictionnaire associant à chaque caractère dans la chaîne son nombre d'occurrences
'''
pass
tableau.sort() qui appliquée à un tableau, trie celui-ci en place.
def affiche(dico: dict):
'''Fonction d'affichage d'un dictionnaire dans l'ordre alphabétique des lettres
ENTREE :
dico = le dictionnaire
SORTIE :
aucune
'''
pass
p = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur condimentum nulla eu tempus luctus. Quisque scelerisque eu ipsum feugiat egestas. Curabitur viverra velit vitae viverra accumsan. Etiam sodales turpis quis arcu imperdiet, eu faucibus erat sodales. Sed consequat risus non eleifend mollis. Donec vel est nec ligula mattis tincidunt in id neque. Sed quis aliquet augue, a imperdiet neque. Ut tristique eros iaculis est accumsan ullamcorper. Sed vitae tellus at diam efficitur fermentum ut et odio. Maecenas ac diam at urna ornare varius ac at felis. Vestibulum magna enim, gravida ut malesuada eu, iaculis ac ipsum."