# CP Python: Seance 7

### A discuter
* Planning ?

| Séance | Date |
| -------- | -------- |
| Séance 8: Classes et Objets | Vendredi 12/12, 10h30 |
| Séance 9: Héritage | A déterminer |
| Séance 10: Polymorphisme | A déterminer |
| Séance 11: Listes chaînées | A déterminer |
| Séance 12: Bonus ? | A déterminer |

### Terminer séance 6
* Guide de la séance: https://hackmd.io/@Tb5Z2PdeRLSnkxJEsjcLXg/BJfkfKCcD
* REPL de la séance: https://repl.it/join/scphfkxk-guillaumegst
- [x] __Terminer d'implémenter `getMax(filename)`__
> 💡 Hint:
Avant de commencer l'exercice, considérez ce qui suit:
> - Une liste complète des exceptions peut être trouvée [ici](https://docs.python.org/3/library/exceptions.html)
> - Considérez, entre autres, l'exception `OSError`;
> - Considérez qu'il est possible de mettre un bloc `try...except` dans un autre bloc`try...except`.
> - Exécutez le code suivant pour voir comment Python se comporte dans ce cas:
>
> ```python=
> def div_value ():
> try:
> while True:
> try:
> value = int(input("Provide a value:"))
> return 1/value
> except ValueError:
> print ( "Incorrect value" )
> except ZeroDivisionError:
> print ( "Incorrect calculation" )
> return -1
>
> print ( div_value () )
> ```

def getMax ( filename ):
""" pre: filename est une chaîne de caractères
    post: 
        - Renvoie le plus grand nombre réel >= 0 trouvé dans le fichier 
        de nom filename.
        - Les lignes ne représentant pas un seul nombre réel >= 0 sont ignorées.
        - Si le fichier n'existe pas ou si une erreur d'entrée/sortie survient,
        la fonction renvoie la valeur -1, est imprime a message d'erreur.
        - Si le fichier ne contient aucune ligne valide, renvoie 
        la valeur -1.

        Par exemple, la méthode retourne 10.0 pour le fichier de contenu suivant:
          0.345.67
          hello
          -543.0
          500.0 1000.0 2000.0
          10.0
          3.1416
"""

- [x] __Essayer de résoudre Session 6: Q* Hogwarts - Quidditch (niveau difficile)__

> The scores list would be provided as a file. The content of this file would follow this format:
> - Two first lines: Names of the teams
> - Lines after: Team_scoring points
> - In case of error, just raise it.
>

- [x] __Essayer de résoudre Session 6: Q* Sauvegarde (niveau intermédiaire/difficle)__

> - You have to create two functions: one to save the data and one to load the data previously saved.
> - You are free to store the data like you want in the file, but putting one integer per line is probably the easiest.
> - If there is no file to load when using the function `load_data` (for exemple, the player starts a new game), you must raise a `FileNotFoundError`.

----
## Dictionnaries (new REPL)
- [ ] __Relire la [théorie](https://syllabus-interactif.info.ucl.ac.be/syllabus/info1-theory/PART_II/dictionaries) liée aux dictionnaires__
* A dictionary in Python is a set of `key: value` pairs.
* A dictionary is __unordered__, changeable and does not allow duplicates
* __NB__ *Si l'ordre est important, il faut utiliser des listes* :wink:
* Dictionaries are optimized to add, remove and retrieve values when the key is known
`("hello" in v)`
– Efficace si `v` est un dictionnaire
– Moins efficace si `v` est une liste
<div style="text-align:center;border:1px solid;padding:0.5em;margin:0.5em;">
<img src="https://i.imgur.com/K6HMY8U.png" width=450>
</div>

* Methods: `d.get(my_key,return_var)`, `d.keys()`, `d.values()`, `d.items()` ?
* NB: `sort()` vs `sorted()` ?

- [ ] __Essayer de résoudre Session 7: Egalité entre structures__
> Soit `m` une matrice representée en utilisant des listes imbriquées;
> Soit `d` une matrice representée en utilisant un dictionnaire, où les zéros ne sont pas stockés;
>
> Écrivez une fonction `equal(m,d)` qui détermine si `d` contient les même valeurs que `m` pour chaque entrée de `m`. (Nous permettons que `d` soit plus large que `m`.)

- [x] __Dans l'interro, comprendre l'implémentation `plus_frequent` de Guillaume, avec l'usage d'un dictionnaire__
- [ ] __Résoudre la QBF liée aux dictionnaires__

Implémentez la méthode dont la spécification est reprise ci-dessous :

def topk_words(words, k):
 """ 
 - pre: words est une liste de mots, k est un nombre entier > 0
 - post: Renvoie les k mots les plus fréquents dans la liste de mots, en utilisant une liste de tuples (compte, mot) en ordre décroissant; si plusieurs mots ont la même fréquence que le k^me mot, tous les mots avec cette fréquence sont retournés.
 
 
Par exemple, sur cette liste de mots:
["while", "the", "congress", "of", "the", "republic", "endlessly",
"debates", "this", "alarming", "chain", "of", "events", "the", "supreme", "chancellor", "has", "secretly", "dispatched", "two", "jedi", "knights"
]
avec k=2, la fonction doit retourner
[(3,"the"), (2,"of")]
avec k=3, la fonction retourne tous les mots, puisque tous les mots qui restent ont la même fréquence (1).
Si le nombre de mots dans la liste est moins que k, on retourne tous les mots.
"""

> Avant de commencer l’exercice, considérez ce qui suit :
> Est-ce qu’il est possible de décomposer le problème ? Considérez :
> — la création d’un dictionnaire contenant la fréquence de chaque mot
> — la création d’une fonction pour déterminer les top-k tuples d’une liste de tuples
> — on peut trier une liste de tuples dans l’ordre inverse en utilisant `sorted(l,reverse=True)`.
> — Faites attention : les dictionnaires ne sont pas ordonnés.