Compléter la définition de la fonction clefs_communes_somme_valeurs ci-dessous de façon

• à ce qu'elle accepte deux arguments de type dict (on supposera que les valeurs de ces dictionnaires sont des entiers ou des flottants);
• et à ce qu'elle retourne un nouveau dictionnaire dont les clefs sont exactement celles en commun aux deux dictionnaires passés en argument et tel que la valeur associé à une clef donnée est la somme des valeurs associées à cette clefs dans les deux autres dictionnaires

On vérifiera que les tests qui suivent ne génèrent pas d'erreur

def clefs_communes_somme_valeurs(d1, d2):
    d_res = {}
    for clefs_d1 in d1:
        if ?? in d2:
            d_res[??] = ??
    return d_res          

d1 = {"a": 3, "b": 4}
d2 = {"a": 6, "c": 8}
d_good_res = {"a": 9}
assert clefs_communes_somme_valeurs(d1, d2) == d_good_res

Écrire la définition d'une fonction clefs_apparait_somme_valeurs de façon

• à ce qu'elle accepte deux arguments de type dict (on supposera que les valeurs de ces dictionnaires sont des entiers ou des flottants);
• et à ce qu'elle retourne un nouveau dictionnaire
  • dont les clefs sont exactement les éléments qui sont des clefs d'au moins l'un des deux dictionnaires
  • tel que la valeur associé à une clef apparaissant dans les deux dictionnaires est leur somme
  • tel que la valeur associé à une clef apparaissant dans un seul des des dictionnaire soit la valeur associée dans ce dictionnaire.

On verifiera que le test suivant n'échoue pas

d1 = {"a": 3, "b": 4}
d2 = {"a": 6, "c": 8}
d_good_res = {"a": 9, "b": 4, "c": 8}
assert clefs_apparait_somme_valeurs(d1, d2) == d_good_res

Écrire la définition d'une fonction composition_dictionnaire de façon

• à ce qu'elle accepte deux arguments d1 et d2 de type dict (on supposera que les clefs et les valeurs de ces dictionnaires sont des chaînes de caractères);
• et à ce qu'elle retourne un nouveau dictionnaire d_res
  • dont les clefs sont les clefs de d1 pour lesquelles la valeur associée dans d1 est une clefs de d2
  • et dont la valeur associée par d_res est égal à la valeur associée à la clefs de d2 dont il est question ci-dessus

On verifiera que le test suivant n'échoue pas

fr_en = {"bonjour": "hello", "fourchette": "fork", "ordinateur": "computer"}
en_de = {"hello": "hallo", "fork": "Gabel", "funny": "lustig"}
fr_de = {"bonjour": "hallo", "fourchette": "Gabel"}
assert composition_dictionnaire(fr_en, en_de) == fr_de

1. Compléter la fonction mot_vers_dict_lettres cei-dessous qui accepte un argument de type str et qui retrourne un dictionnaire dont les clefs sont les lettres de la chaîne de caractères passée en arguments une fois converties en minuscules (on utilisera la méthode lower du type str) et les valeurs associées le nombre d'occurrences de cette lettre

   def mot_vers_dict_lettres(chaine):
       d = ??
       for lettre in chaine:
           if ?? in ??:
               ??
           else:
               ??
   

   On verifiera que le test suivant n'échoue pas et on ajoutera un troisième test.

   chaine = "Grothendieck"
   d = {'g': 1, 'r': 1, 'o': 1, 't': 1, 'h': 1, 'e': 2, 'n': 1, 'd': 1, 'i': 1, 'c': 1, 'k': 1}
   assert mot_vers_dict_lettres(chaine) == d
   
   chaine = "kayak"
   d = {'k': 2, 'a': 2, 'y': 1}
   assert mot_vers_dict_lettres(chaine) == d
   

2. À l'aide de la fonction précédente écrire une fonction sont_anagrammes qui accepte deux chaînes de caractères et qui renvoie True si les chaines de caractères sont anagrammes et False sinon. On ajoutera des tests.
3. Dresser la listes des mots du fichier liste_mots_fr.txt qui sont des anagrammes du mot oser. Il faudra utiliser la méthode strip du type str pour supprimer le retour à la ligne.

1. En complétant les codes ci-dessous écrire une fonctions nombre_lignes qui prend en paramètre un chemin de fichier (sous forme d'une chaîne de caractères) et qui retourne le nombre de lignes de ce fichier en utilisant la méthode readlines. Pour information l'appel f.readlines() retourne la liste des lignes du fichier ouvert en lecture f (donc retourne une liste de chaînes de caractères)

   def nombre_lignes(fpath):
       with ?? as ??:
           list_of_lines = f.readlines()
       ???
   

   Vérifier que le fichier DDHH_fr.txt contient 119 lignes.

2. En complétant le code ci-dessous écrire une fonction nombre_lignes_v2 qui fait la même chose que la précédente mais sans utiliser la méthode readlines

   def nombre_lignes_v2(fpath):
       ??
       with ?? as ??:
           ??
           for line in f:
               ??
       ??
   

3. Compléter les deux fonctions nombre_j et nombre_j_v2 qui comptent le nombre de j dans le fichier dont le chemin est donné en argument. Remarque: l'appel f.read() retourne le contenu du fichier associé à f comme une seule chaîne de caractère (mauvaise idée si le fichier est volumineux ou s'il vient de sources non sûres…).

   def nombre_j(fpath):
       with open(fpath) as f:
           ??
           for line in f:
               for letter in line:
                   ??
       ??
   

   def nombre_j_v2(fpath):
       ??
       with open(fpath) as f:
           whole_file_content = f.read()
           for letter in whole_file_content:
               ??
       ??
   

   Vérifier que le fichier DDHH_fr.txt en contient 11 .

1. Écrire une fonction traduit_par_car qui accepte trois arguments

   • les deux premiers représentant des chemins de fichiers
   • le troisième un dictionnaire dont les clefs sont des caractères et les valeurs des chaînes de caractères

   et qui recopie le contenu du premier fichier dans le second en traduisant les caractères un à un à l'aide du dictionnaire (si un caractère lu dans le fichier n'est pas une clefs du dictionnaire alors il est recopié tel quel). Ainsi avec le dictionnaie {"e": "ee", "a",: "b", "z": ""} tous les "e" doivent êtres doublés, les "z" supprimés et les "a" changés en des b (le autres lettres n'étant pas affectées). On pourra s'inspirer du code suivant

   def traduit_par_car(in_fpath, out_fpath, trad_dict):
       ??
       with ?? as ??:
           with ?? as ??:
               for in_line in ??:
                   for c in in_line:
                       if ??:
                           ??.write(??)
                       else:
                           ??.write(??)
   

2. En utilisant le dictionnaire ci-dessous et à l'aide de la question précédente

   d = {c: "" for c in "aàeéèiîïoùy"}
   

   vérifier que la déclaration universelle des droits de l'homme est encore lisible sans ses voyelles.

3. Écrire une fonction dict_occur_lettres qui prend en paramètre un nom de fichier (sous forme d'une chîne de caractères) et renvoie un dictionnaire qui associe à chaque caractère le nombre de fois où il apparaît dans le fichier.

1. Écrire une fonction dict_occur_pairs qui prend en paramètre un nom de fichier (sous forme d'une chîne de caractères) et renvoie un dictionnaire qui associe à chaque chaîne chaîne de longueur deux apparaissant sur une même ligne (car pou simplifier on va compresser ligne à ligne) le nombre de fois où elle apparaît dans le fichier.

   {'Dé': 7, 'éc': 18, 'cl': 47, 'la': 102, 'ar': 51, 'ra': 68, 'at': 83, 'ti': 160, 'io': 114, 'on': 246, 'n ': 118, ' u': 37, 'un': 64, 'ni': 36, 'iv': 27, 've': 28, 'er': 118, 'rs': 48, 'se': 59, 'el': 42, 'll': 28, 'le': 179, 'e ': 510, ' d': 341, 'de': 191, 'es': 207, 's ': 323, 'dr': 70, 'ro': 94, 'oi': 104, 'it': 149, 'ts': 40, ' l': 242, "l'": 44, "'h": 12, 'ho': 18, 'om': 35, 'mm': 30, 'me': 84, 'Pr': 2, 'ré': 26, 'éa': 2, 'am': 24, 'mb': 6, 'bu': 4, 'ul': 21, 'Co': 7, 'ns': 89, 'si': 34, 'id': 24, 'dé': 33, 'ér': 26, 'an': 88, 'nt': 170, 't ': 273, ' q': 46, 'qu': 79, 'ue': 56, 'a ': 138, ' r': 46, 're': 133, 'ec': 32, 'co': 70, 'nn': 40, 'na': 53, 'ai': 58, 'is': 57, 'ss': 41, 'sa': 51, 'nc': 33, 'ce': 53, 'di': 39, 'ig': 23, 'gn': 11, 'té': 78, 'é ': 49, ' i': 37, 'in': 74, 'nh': 2, 'hé': 1, 'en': 153, 'te': 118, ' à': 61, 'à ': 63, ' t': 50, 'to': 30, 'ou': 114, 'us': 33, ' m': 33, 'em': 46, 'br': 13, ' f': 34, 'fa': 19, 'mi': 28, 'il': 30, ' h': 12, 'hu': 8, 'um': 12, 'ma': 23, 'ne': 89, ' e': 148, 'et': 98, 'eu': 38, 'ur': 61, ' é': 32, 'ég': 17, 'ga': 23, 'au': 62, 'ux': 29, 'x ': 28, 'al': 56, 'li': 87, 'ié': 10, 'én': 8, 'ab': 11, 'bl': 21, ' c': 96, 'st': 31, 'tu': 18, 'fo': 25, 'nd': 43, 'ib': 31, 'be': 19, 'rt': 66, 'é,': 14, ', ': 111, ' j': 10, 'ju': 7, 'ic': 55, ' p': 166, 'pa': 43, 'ix': 5, 'da': 30, 'mo': 11, 'e,': 41, 'mé': 9, 'ép': 8, 'pr': 55, 'ri': 49, ' o': 50, 'du': 27, 'ui': 33, ' a': 115, 'ac': 25, 'ct': 44, ' b': 9, 'ba': 2, 'rb': 5, 'ie': 46, 'i ': 31, 'év': 8, 'vo': 15, 'ol': 13, 'lt': 6, 'sc': 11, 'ci': 32, "'a": 21, 'av': 16, 'vè': 1, 'èn': 1, "d'": 25, "'u": 6, 'où': 4, 'ù ': 4, ' ê': 13, 'êt': 19, 'tr': 51, ' s': 131, 'rl': 1, 'r ': 76, 'cr': 8, 'ir': 42, 'bé': 2, 'és': 33, 'rr': 7, 'sè': 1, 'èr': 3, 'ét': 21, 'oc': 24, 'pl': 27, 'lu': 13, 'ha': 11, 'ut': 67, 'as': 20, 'sp': 11, 'pi': 5, "u'": 11, "'i": 11, 'l ': 36, 'so': 80, 'ot': 14, 'gé': 9, 'gi': 10, 'im': 17, 'po': 23, ' n': 48, 't,': 16, 'su': 23, 'up': 7, 'rê': 4, 'êm': 4, 's,': 18, 'ty': 1, 'yr': 1, "'o": 8, 'op': 15, 'pp': 8, 'n,': 14, "'e": 20, 'ag': 16, 'ge': 19, 'lo': 17, 'pe': 61, 'ca': 17, ' C': 1, 'Ch': 4, ' N': 5, 'Na': 5, ' U': 5, 'Un': 5, 'no': 11, 'uv': 6, 'ea': 2, 'u ': 61, 'ta': 38, ' v': 18, 'va': 17, "'é": 8, 'fe': 10, 'ls': 7, 'or': 26, 'og': 4, 'gr': 9, 'rè': 4, 'ès': 5, 'ia': 19, 'ei': 19, 'vi': 23, ' g': 10, ' E': 5, 'Et': 5, ' M': 2, 'Me': 2, 'ng': 6, 'r,': 5, 'oo': 2, 'pé': 8, 'c ': 6, "'O": 1, 'Or': 1, 'rg': 3, 'ef': 6, 'ff': 10, 'if': 6, 'f ': 2, 'ep': 3, 'pt': 2, 'mu': 7, 'mp': 13, "L'": 6, "'A": 1, 'As': 1, 'lé': 8, 'ée': 15, 'né': 9, ' D': 7, 'tt': 7, 'af': 4, 'fi': 8, 'ay': 10, 'ya': 1, "s'": 5, 'rc': 9, 'éd': 9, 'uc': 14, 'rd': 5, 'rn': 8, 'l,': 5, 'ap': 3, 'rm': 6, 'pu': 10, 'x-': 1, '-m': 1, 'mê': 3, 'cé': 5, 'n.': 7, 'Ar': 30, 'To': 27, 's.': 21, '. ': 10, ' I': 2, 'Il': 2, 'do': 13, 'ué': 2, 'nv': 6, 'fr': 3, 'é.': 7, ' 2': 11, 'cu': 21, 'ex': 10, 'xe': 3, 'gu': 1, 'iq': 20, 'ua': 4, 'De': 3, 'ys': 8, 'lc': 2, 'nq': 4, ' 3': 2, 'sû': 1, 'ûr': 1, 'e.': 12, ' 4': 1, 'Nu': 8, 'nu': 5, 'rv': 2, 'ud': 2, 'e;': 2, '; ': 6, ' 5': 1, 'ru': 3, 'ad': 2, ' 6': 1, ' 7': 1, 'ev': 6, 'i.': 2, ' T': 3, 'ov': 1, ' 8': 1, ' 9': 1, 'bi': 12, 'xi': 3, ' 1': 10, '10': 1, 'éq': 4, 'ub': 9, 'a,': 1, 'ob': 5, 'n-': 3, '-f': 1, 'cc': 6, 'iè': 2, '11': 1, 'sé': 6, 'él': 7, 'sq': 1, "'à": 2, 'lp': 1, 'cè': 2, 'éf': 3, 'mn': 1, 'i,': 1, 'l.': 2, 'nf': 8, 'fl': 1, '12': 1, 'bj': 1, 'je': 1, 'xt': 2, 'vé': 4, '13': 1, 'ch': 15, 't.': 4, ' y': 4, 'y ': 4, '14': 1, 'he': 5, 'Ce': 2, 'oq': 1, 'ip': 3, '15': 1, '16': 1, 'A ': 1, "'â": 1, 'âg': 1, 'eg': 1, 'd ': 1, 'Le': 2, 'fu': 1, 'x.': 2, 'La': 3, 'ém': 5, "'E": 1, '17': 1, '18': 1, 'n;': 1, '19': 1, 'xp': 3, 'lq': 1, 'oy': 3, 'ye': 3, '20': 1, 'éu': 1, '21': 1, 'cs': 1, 's;': 2, 'nê': 1, 'od': 3, 'uf': 2, '22': 1, 'bt': 1, 'sf': 4, 'râ': 1, 'âc': 1, 'aq': 2, '23': 1, 'hô': 2, 'ôm': 2, 'Qu': 1, 'u,': 2, 'sy': 2, 'yn': 2, '24': 1, 'os': 3, 'yé': 1, '25': 1, '-ê': 2, 'bs': 1, 'jo': 3, '26': 1, ' L': 3, 'hn': 1, 'of': 1, 'é;': 1, 'El': 1, 'éh': 1, 'x,': 1, 'nr': 1, '27': 1, 'r.': 1, '28': 1, 'èg': 1, '29': 1, 'Da': 1, "n'": 1, 'xc': 1, 'vu': 1, '30': 1, 'Au': 1, 'rp': 1, 'vr': 1}
   

Écrire une fonction pair_occ_rank qui prend en paramètre un dictionnaire du mê type que celui renvoyé par dict_occur_pairs (qui a des chaînes de caractère associe un entier) et qui retourne un dictionnaire avec les même clef mais où la valeur associée à une clef est le rang.

def pair_occ_rank(d):
    L = [(d[pair],pair) for pair in d]
    L.sort(reverse=True)
    res_dict = {}
    for i in range(len(L)):
        ??
    ??

Écrire une fonction compresse_sous_chaine

• qui accepte comme arguments
  • un dictionnaire du même type que celui retourné par la fonction pair_occ_rank (qui a une chaîne de caractères de longueur 2 associe un entier)
  • une chaîne de caractères de longueur 2
  • en entier positifs \(n\)
• et qui retourne la chaîne encodée de la façon suivante
  • si la chaîne n'est pas une clefs du dictionnaire une exception est levée
  • les \(n\) pairs les plus fréquente (selon le dictionnaire) sont encodées sur une seule lettre minuscule à savoir "a" pour la paire plus fréquente, "b" pour la suivante, etc. Aide: on pourra executer chr(ord("a")+0), chr(ord("a")+1), chr(ord("a")+2) et chr(ord("a")+25) dans la console…
  • les autres sont encodées en les prefixant par un _ (tiret bas ou underscore)

Ainsi les tests suivants ne doivent pas échouer.

d_test = {"ab":0, "cd": 1, "ef": 2}
test_data = [["ef", 2, "_ef"],
             ["ef", 3, "c"],
             ["cd", 1, "_cd"],
             ["cd", 2, "b"]]
for s, n, true_res in test_data:
    res = compresse_sous_chaine(d_test, s, n)
    assert res == true_res, f"{s} {n} {res} {true_res}"

• qui accepte comme arguments
  • un dictionnaire du même type que celui retourné par la fonction pair_occ_rank (qui a une chaîne de caractères de longueur 2 associe un entier)
  • une chaîne de caractères de longueur multiple de \(2\)
  • en entier positifs \(n\)
• et qui retourne la chaîne encodée en l'encodant par blocs de taille \(2\) à l'aide de la fonction compresse_sous_chaine.

def fonction_a_renommer_correctement(fpath):
    pairs_occ_dict = dict_occur_pairs(fpath)
    pairs_occ_list = [(pairs_occ_dict[pair],pair) for pair in pairs_occ_dict]
    pairs_occ_list.sort(reverse=True)
    pairs_sorted_by_occ = [pair for nbr_occur, pair in pairs_occ_list]
    return pairs_sorted_by_occ

pairs_sorted_by_occ = fonction_a_renommer_correctement(DDH_fpath)
print(pairs_sorted_by_occ)

['e ', ' d', 's ', 't ', 'on', ' l', 'es', 'de', 'le', 'nt', ' p', 'ti', 'en', 'it', ' e', 'a ', 're', ' s', 'te', 'n ', 'er', ' a', 'ou', 'io', ', ', 'oi', 'la', 'et', ' c', 'ro', 'ns', 'ne', 'an', 'li', 'me', 'at', 'so', 'qu', 'té', 'r ', 'in', 'dr', 'co', 'ra', 'ut', 'rt', 'un', 'à ', 'au', 'ur', 'u ', 'pe', ' à', 'se', 'ai', 'is', 'ue', 'al', 'pr', 'ic', 'na', 'ce', 'tr', 'sa', 'ar', ' t', ' o', 'é ', 'ri', 'rs', ' n', 'cl', 'ie', 'em', ' r', ' q', "l'", 'ct', 'pa', 'nd', 'ir', 'el', 'ss', 'e,', 'ts', 'nn', 'di', 'ta', 'eu', ' u', ' i', 'ni', 'l ', 'om', 'si', ' f', 'és', 'us', 'ui', 'nc', 'dé', ' m', 'ec', 'ci', ' é', 'st', 'ib', 'i ', 'to', 'mm', 'il', 'da', 'Ar', 'ux', 'x ', 've', 'mi', 'll', 'pl', 'iv', 'du', 'To', 'ér', 'ré', 'or', 'fo', "d'", 'ac', 'oc', 'id', 'am', 'vi', 'su', 'po', 'ma', 'ig', 'ga', 'ét', 'ul', 's.', 'cu', 'bl', "'a", 'iq', 'as', "'e", 'êt', 'ia', 'ge', 'fa', 'ei', 'be', 'éc', 'tu', 's,', 'ho', ' v', 'ég', 'va', 'lo', 'im', 'ca', 't,', 'av', 'ag', 'ée', 'vo', 'op', 'ch', 'é,', 'uc', 'ot', 'n,', 'ol', 'mp', 'lu', 'do', 'br', ' ê', 'um', 'e.', 'bi', "'h", ' h', "u'", 'sp', 'sc', 'no', 'mo', 'ha', 'gn', 'ab', "'i", ' 2', 'pu', 'ié', 'gi', 'ff', 'fe', 'ex', 'ay', '. ', ' j', ' g', ' 1', 'éd', 'ub', 'rc', 'né', 'mé', 'gé', 'gr', ' b', 'év', 'ép', 'én', 'ys', 'rn', 'pé', 'pp', 'nf', 'lé', 'hu', 'fi', 'cr', 'Nu', "'é", "'o", 'él', 'é.', 'up', 'tt', 'rr', 'n.', 'mu', 'ls', 'ju', 'Dé', 'Co', ' D', 'uv', 'sé', 'rm', 'nv', 'ng', 'mb', 'lt', 'if', 'ev', 'ef', 'cc', 'c ', "L'", '; ', "'u", 'ém', 'ès', "s'", 'rd', 'rb', 'r,', 'pi', 'ob', 'nu', 'l,', 'ix', 'he', 'cé', 'Un', 'Na', 'Et', ' U', ' N', ' E', 'ù ', 'êm', 'éq', 'y ', 'vé', 'ua', 't.', 'sf', 'rê', 'rè', 'où', 'og', 'nq', 'bu', 'af', 'Ch', ' y', 'éf', 'èr', 'ye', 'xp', 'xi', 'xe', 'ru', 'rg', 'oy', 'os', 'od', 'n-', 'mê', 'jo', 'ip', 'fr', 'ep', 'ap', 'La', 'De', ' T', ' L', 'ôm', 'éa', 'yn', 'xt', 'x.', 'ué', 'uf', 'ud', 'u,', 'sy', 's;', 'rv', 'pt', 'oo', 'nh', 'lc', 'l.', 'iè', 'i.', 'hô', 'f ', 'ea', 'e;', 'cè', 'bé', 'ba', 'aq', 'ad', 'Pr', 'Me', 'Le', 'Il', 'Ce', '-ê', "'à", ' M', ' I', ' 3', 'ûr', 'éu', 'éh', 'é;', 'èn', 'èg', 'âg', 'âc', 'yé', 'yr', 'ya', 'xc', 'x-', 'x,', 'vè', 'vu', 'vr', 'ty', 'sû', 'sè', 'sq', 'râ', 'rp', 'rl', 'r.', 'ov', 'oq', 'of', 'nê', 'nr', 'n;', "n'", 'mn', 'lq', 'lp', 'je', 'i,', 'hé', 'hn', 'gu', 'fu', 'fl', 'eg', 'd ', 'cs', 'bt', 'bs', 'bj', 'a,', 'Qu', 'Or', 'El', 'Da', 'Au', 'As', 'A ', '30', '29', '28', '27', '26', '25', '24', '23', '22', '21', '20', '19', '18', '17', '16', '15', '14', '13', '12', '11', '10', '-m', '-f', "'â", "'O", "'E", "'A", ' C', ' 9', ' 8', ' 7', ' 6', ' 5', ' 4']

1. Compléter la fonction dict_occur_lettre ci-dessous pour qu'elle retourne un dictionnaire dont les clefs sont les caractères de la chaîne de caractères passée en argument et les clefs sont le nombre d'occurences de ce caractère dans ce mot. Par exemple l'appel dict_occur_lettre("kayak") doit retourner {'k': 2, 'a': 2, 'y': 1}.
2. En déduire une fonction sont_anagrammes acceptant deux chaînes de caractères en arguments et qui retourne True si ces chaînes sont des anagrammes l'une de l'autre et False sinon.

3. Compléter la fonction suivante pour qu'elle retourne tous les anagrammes du mot passé en argument présents dans le fichier de chemin passé en second argument (ce fichier contenant un mot par ligne). On en profitera pour déterminer des anagrammes du mot «intégrale»

   ana_lst =  tous_les_anagrammes("intégrale", liste_mots_fr_fpath)
   print(ana_lst)
   

1. Pour cela un étudiant propose la fonction ci-dessous

   print(max_anagrames(liste_mots_fr_fpath))
   

   Que se passe-t-il quadn vous executez ce script?

2. Pour accélérer les choses l'idée est de commencer par regrouper les mots qui sont susceptibles d'être des anagrammes. Par exemple si un mot contient 2 fois la lettre e alors il ne peut pas être anagramme d'un mot contenant 3 fois cette lettre.