NSI Première
personne = {"Nom": "Dupuis", "Prénom": "Jacque", "Age": 30}
personne["Prénom"] = "Jacques" # modification de la valeur associée à la clé "Prénom"
print(personne) # affichage du dictionnaire
Si on se trompe dans l'écriture de la clé ( par exemple ici Prenom au lieu de Prénom ), Python ne signale aucune erreur mais créé une nouvelle entrée clé: valeur dans le dictionnaire.
Dans le cas d'une affectation d'une valeur à une clé inexistante, Il n'y a donc pas de risque d'erreur du type "Index out of range" avec un dictionnaire !
Par contre, un test sur une clé inexistante entraînera une erreur de type "KeyError".
print(personne.keys())
print(personne.values())
print(personne.items())
print(personne["Prénom"], personne["Nom"], "a", personne["Age"], "ans")
dico = {i: 2**i for i in range(11)}
print(dico)
numeros = [...]
noms = [...]
departements = {numeros[i]: noms[i] for i in range(len(numeros))}
print(departements)
ages = {...}
chats_ages = [chat for chat in ages if ages[chat] >= 7]
print(chats_ages)
L'idée : on parcourt ( par valeur ) les lettres de la chaîne mot, et on ajoute à une variable somme ( initialisée bien entendu auparavant à 0 ) la valeur associée à cette lettre dans le dictionnaire scrabble ( la lettre représente donc une clé dans ce dictionnaire ) :
def score(mot):
'''Fonction qui calcule le score d'un mot placé au Scrabble
ENTREE :
mot = chaîne de caractères représentant le mot à évaluer (str)
SORTIE :
le score associé à ce mot (int)
'''
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}
somme = 0
for lettre in mot:
somme = somme + scrabble[lettre]
return somme
Le dictionnaire scrabble ne sert a priori que dans la fonction, il est donc logique de le définir à l'intérieur de celle-ci.
Le principe ressemble au précédent, sauf que dans certains cas il faudra ajouter une valeur à une somme, et dans d'autres le soustraire.
Il faut donc là aussi parcourir la chaîne r caractère par caractère, mais en pouvant "s'adresser" également au caractère suivant le caractère courant; pour cela, un parcours par valeur n'est pas adapté, il faut donc forcément faire un parcours par indice de la chaîne.
Par conséquent, il faudra parcourir la chaîne jusqu'à son avant-dernier caractère, sinon on aura une erreur quand on cherchera à s'adresser au "caractère suivant le dernier caractère" !
Cela implique également de ne pas oublier ensuite ce dernier caractère dans la somme à calculer...
def rom_to_dec(r):
'''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 (str)
SORTIE :
le nombre converti en base 10 (int)
'''
romains = {"M": 1000, "D": 500, "C": 100, "L": 50, "X": 10, "V": 5, "I": 1 }
dec = 0 # variable qui contiendra le nombre en base 10
for i in range(len(r)-1): # parcours par index de la chaîne jusqu'à son avant-dernier caractère
v1 = romains[r[i]] # valeur associée dans le dictionnaire au caractère courant de la chaîne
v2 = romains[r[i+1]] # valeur associée au caractère suivant le caractère courant
if v1 >= v2: # si la valeur associée au caractère courant est plus grande ou égale,
dec = dec + v1 # alors on l'ajoute à la somme totale,
else:
dec = dec - v1 # sinon on la soustrait.
dec = dec + romains[r[i+1]] # à la fin, on ajoute à la somme totale la valeur associée au dernier caractère
return dec
Il faut parcourir le texte, et pour chaque nouveau caractère ( c'est à dire, qui n'est pas encore une clé dans le dictionnaire ), créer une entrée pour lui et lui donner une valeur de 1.
Si le caractère correspond déjà à une clé dans le dictionnaire, il faut simplement incrémenter la valeur de 1.
def analyse(phrase):
'''Fonction comptant le nombre d'occurrences de chaque caractère dans une chaîne
ENTREE :
phrase = chaîne de caractères (str)
SORTIE :
le dictionnaire associant à chaque caractère dans la chaîne son nombre d'occurrences (dict)
'''
occurrences = {} # dictionnaire clé = lettre / valeur = occurrence de cette lettre
for lettre in phrase: # pour chaque lettre dans la phrase,
if lettre not in occurrences: # si la lettre n'est pas encore une clé dans le dictionnaire,
occurrences[lettre] = 1 # alors on crée cette clé et on lui donne la valeur 1,
else: # sinon ( si la clé existe déja )
occurrences[lettre] += 1 # on incrémente l'occurence de 1
return occurrences
# Pour tester la fonction et afficher le dictionnaire "brut" :
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."
print(analyse(p))
Il ne faut pas afficher toutes les lettres de l'alphabet, uniquement les caractères présents dans le texte !
Pour cela :
def affiche(dico):
'''Fonction d'affichage d'un dictionnaire dans l'ordre alphabétique des lettres
ENTREE :
dico = le dictionnaire (dict)
SORTIE :
aucune
'''
lettres = [lettre for lettre in dico.keys()] # construction par compréhension du tableau des clés
lettres.sort() # tri du tableau
for lettre in lettres: # Pour chaque élément du tableau,
print(lettre, dico[lettre]) # on affiche cet élément et la valeur associée dans le dictionnaire
# Pour tester la fonction :
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."
affiche(analyse(p))
"""
Facile : on renvoie la valeur associée à la clé
'lettre' dans le dictionnaire 'morse'.
"""
def encode_lettre(lettre, morse):
return morse[lettre]
"""
On parcourt la chaîne 'msg', et on concatène au message codé
le résultat renvoyé par l'appel de
la fonction 'encore_lettre' pour chacune des lettres
du message.
"""
def encode_mots(msg, morse):
code = ""
for lettre in msg:
code += encode_lettre(lettre, morse)
return code
"""
Plus délicat : pour chaque code dans 'msg', on parcourt le
dictionnaire 'morse' pour trouver la lettre dont le code est le code courant;
on concatène alors la lettre au message décodé.
"""
def decode_mots(msg, morse):
decode = ""
codes_morse = msg.split()
for code in codes_morse:
for lettre in morse:
if code == morse[lettre]:
decode += lettre
return decode
morse = {' ': '/', 'E': '°', 'I': '°°', 'S': '°°°', 'H': '°°°°', 'V': '°°°-', 'U': '°°-', 'F': '°°-°', 'A': '°-', 'R': '°-°', 'L': '°-°°', 'W': '°--', 'P': '°--°', 'J': '°---', 'T': '-', 'N': '-°', 'D': '-°°', 'B': '-°°°', 'X': '-°°-', 'K': '-°-', 'C': '-°-°', 'Y': '-°--', 'M': '--', 'G': '--°', 'Z': '--°°', 'Q': '--°-', 'O': '---'}
message = "-°°° °-° °- °°°- --- / °--- ° °°- -° ° / °--° °- -°° °- °-- °- -° / °-°° °- / -° °°° °° / ° °°° - / °- °°°- ° -°-° / - --- °°"
print(encode_mots('SOS', morse)) # affiche : '°°°---°°°'
print(decode_mots(message, morse)) # affiche : 'BRAVO JEUNE PADAWAN LA NSI EST AVEC TOI'