Dictionnaires - Correction

📂 1. Manipulations de base

📂 2. Construction par compréhension

📂 3. Score au Scrabble

📂 4. Chiffres romains

📂 5. Analyse d'un texte

🗂 5.1. Analyse

🗂 5.2. Affichage ordonné

📂 6. Codage/décodage du morse

Dictionnaires - Correction

1. Manipulations de base

définir le dictionnaire personne contenant les informations suivantes relatives à une personne :


personne = {"Nom": "Dupuis", "Prénom": "Jacque", "Age": 30}

corriger l'erreur dans le prénom et afficher le dictionnaire. La bonne valeur est "Jacques".
```
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".
afficher la liste des clés du dictionnaire.
```
print(personne.keys())		    	
			    	
```

afficher la liste des valeurs du dictionnaire.


print(personne.values())

afficher la liste des paires clé/valeur du dictionnaire.
```
print(personne.items())	    	
			    	
```

afficher la phrase : "Jacques Dupuis a 30 ans" en utilisant le dictionnaire.


print(personne["Prénom"], personne["Nom"], "a", personne["Age"], "ans")

2. Construction par compréhension

11 premières puissances de 2 :


dico = {i: 2**i for i in range(11)}

print(dico)

Départements :


numeros = [...]
noms = [...]

departements = {numeros[i]: noms[i] for i in range(len(numeros))}

print(departements)

Chats hospitalisés :


ages = {...}

chats_ages = [chat for chat in ages if ages[chat] >= 7]

print(chats_ages)

3. Score au Scrabble

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.

4. Chiffres romains

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

5. Analyse d'un texte

5.1. Analyse

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))

5.2. Affichage ordonné

Il ne faut pas afficher toutes les lettres de l'alphabet, uniquement les caractères présents dans le texte !

Pour cela :

on "extrait" les clés du dictionnaire dans un tableau
on trie ce tableau par ordre alphabétique
on parcourt le tableau, en affichant, pour chacun de ses éléments, la valeur correspondant à cette clé dans le dictionnaire


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))

6. Codage/décodage du morse


"""
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'