ctd - on the teacher notebooks as well

Author: parmentelat

notebooks/geo-tps/addresses/.teacher/README-addresses-corrige-nb.md

@@ -81,8 +81,6 @@ import pandas as pd
 vous pouvez charger le fichier `data/addresses.csv`; toutes ces adresses sont situées à PARIS
 
 ```{code-cell} ipython3
-:tags: []
-
 # load the data in data/addresses.csv
 # and display a few first lines
 
@@ -174,8 +172,6 @@ import requests
 ```
 
 ```{code-cell} ipython3
-:tags: []
-
 # here's how to use the API
 
 def localize_one(num, typ, nom):
@@ -286,6 +282,7 @@ curl -X POST -F data=@path/to/file.csv -F columns=voie -F columns=ville https://
   ```bash
   curl -o lapageweb.html http://github.com/flotpython/
   ```
+
 * quand on utilise une API, comme on vient de le faire pour aller chercher la position de la rue des bernardins, on doit **passer des paramètres** à l'API  
 et pour faire ça dans une requête http, il y a **deux mécanismes: GET et POST**
 
@@ -334,22 +331,26 @@ sauf que nous, on ne veut pas utiliser `curl`, on veut faire cette requête en P
 2. le résultat - toujours au format csv - pourra être également transformé en dataframe
 3. qu'il ne restera plus qu'à `merge` (ou `join` si vous préférez) avec la dataframe de départ, pour ajouter les résultats de la géolocalisation dans les données de départ
    pour cette étape on peut envisager de ne garder que certaines colonnes de la géolocalisation (assez bavarde par ailleurs), je vous recommande de conserver uniquement:
+
    * `latitude`, `longitude` - *of course*
    * `result_city` pour pouvoir vérifier la validité des résultats - ici on devrait toujours avoir `Paris`
    * `result_type` qui devrait toujours renvoyer `housenumber`, ça permet à nouveau de vérifier qu'on a bien une adresse connue
 
 +++
 
 ````{tip}
+
 * pour envoyer un POST avec des paramètres, on peut faire
   ```python
   response = requests.post(url, file=some_dict, data=another_dict)
   ```
+
 * et donc dans notre cas, puisque `data` est un paramètre de type fichier, alors que `columns` est un paramètre usuel, on fera
   ```python
   response = requests.post(url, files={'data': file_like}, data={'columns': ['col1', ...]})
   ```
   dans lequel `file_like` désigne le résultat d'un `open()` 
+
 * enfin, `pd.read_csv` s'attend à un paramètre de type fichier, i.e. du genre de ce qu'on obtient avec `open()`  
   et du coup pour reconstruire une dataframe à partir du texte obtenu dans la requête http, on a deux choix
   1. soit on commence par sauver le texte dans un fichier temporaire (juste faire attention à choisir un nom de fichier qui n'existe pas, de préférence dans un dossier temporaire, voir le module `tempfile`)
@@ -365,8 +366,6 @@ je vous recommande d'y aller pas à pas, commencez par juste l'étape 1, puis 1
 c'est utile aussi de commencer par une toute petite dataframe pour ne pas attendre des heures pendant la mise au point...
 
 ```{code-cell} ipython3
-:tags: []
-
 import requests
 # this one is to fake a file from a string
 import io

notebooks/numpy-exos/.teacher/EXO-indices-corrige-nb.md

@@ -1,10 +1,5 @@
 ---
 jupytext:
-  cell_metadata_filter: all,-hidden,-heading_collapsed,-run_control,-trusted
-  notebook_metadata_filter: all, -jupytext.text_representation.jupytext_version, -jupytext.text_representation.format_version,
-    -jupytext.custom_cell_magics, -language_info.version, -language_info.codemirror_mode.version,
-    -language_info.codemirror_mode, -language_info.file_extension, -language_info.mimetype,
-    -toc, -vscode
   text_representation:
     extension: .md
     format_name: myst

notebooks/numpy-exos/.teacher/EXO-mandelbrot-corrige-nb.md

@@ -22,10 +22,6 @@ notebookname: Mandelbrot
 </div>
 
 ```{code-cell} ipython3
----
-slideshow:
-  slide_type: slide
----
 import numpy as np
 import matplotlib.pyplot as plt
 %matplotlib ipympl
@@ -44,30 +40,33 @@ il s'agit de calculer l'image de la convergence de mandelbrot:
 
 ## comment ça marche ?
 
-+++ {"cell_style": "center", "slideshow": {"slide_type": "slide"}}
++++ {"cell_style": "center"}
 
 * dans l'espace complexe, on définit pour chaque $c\in\mathbb{C}$ la suite
    * $z_0 = c$
    * $z_{n+1} = z_n^2 + c$
 * on démontre que 
   * lorsque $|z_n|>2$, la suite diverge
 
-+++ {"cell_style": "center", "slideshow": {"slide_type": "-"}}
++++ {"cell_style": "center"}
 
 il s'agit pour nous de 
 
 * partir d'un pavé rectangulaire; par exemple sur la figure, on a pris l'habituel  
   $re \in [-2, 0.8]$ et  $im \in [-1.4, 1.4]$
+
 * découper ce pavé en un maillage de $h \times w$ points  (sur la figure, 1000 x 1000)
 * on se fixe un nombre maximal `max` d'itérations (disons 20)  
   et pour chaque point du maillage, on va calculer si la suite diverge avant `max` itérations
+
 * c'est-à-dire plus spécifiquement on calcule un tableau `diverge` de la taille du maillage
   * pour chaque point `z`, on calcule les `max` premiers termes de la suite
   * et à la première itération `n` où la suite diverge (son module est supérieur à 2)  
     alors on affecte `diverge[z] = n`
+
 * on n'a plus qu'à afficher ensuite l'image obtenue `diverge` avec `plt.imshow`
 
-+++ {"slideshow": {"slide_type": "slide"}}
++++
 
 ````{admonition} indices
 
@@ -127,24 +126,16 @@ et je vous demande de mettre ici quelques tests de votre deuxième fonction
 
 # solution
 
-+++ {"slideshow": {"slide_type": "slide"}}
++++
 
 * une adaptation libre de l'[implementation proposée dans le tutorial scipy](https://docs.scipy.org/doc/numpy/user/quickstart.html#indexing-with-boolean-arrays)
 
 ```{code-cell} ipython3
----
-slideshow:
-  slide_type: slide
----
 import numpy as np
 import matplotlib.pyplot as plt
 ```
 
 ```{code-cell} ipython3
----
-slideshow:
-  slide_type: slide
----
 # it's a little confusing that 
 # real part = column = second dimension
 # imag part = line =   first  dimension
@@ -194,10 +185,6 @@ def mandelbrot(height, width, *,
 ```
 
 ```{code-cell} ipython3
----
-slideshow:
-  slide_type: slide
----
 plt.figure(figsize=(10, 10))
 diverge = mandelbrot(1024, 1024)
 plt.imshow(diverge)

notebooks/numpy-tps/images/.teacher/README-images1-corrige-nb.md

@@ -100,11 +100,13 @@ plt.rc('figure', figsize=(2, 2))
   :width: 100px
   :align: right
   ```
+
 * l'affichage à l'écran, d'une image couleur `rgb`, utilise les règles de la synthèse additive  
 `(r, g, b) = (255, 255, 255)` donne la couleur blanche  
 `(r, g, b) = (0, 0, 0)` donne du noir  
 `(r, g, b) = (255, 0, 0)` donne du rouge
 `(r, g, b) = (255, 255, 0)` donne du jaune ...
+
 * pour afficher le tableau `im` comme une image, utilisez: `plt.imshow(im)`
 * pour afficher plusieurs images dans une même cellule de notebook faire `plt.show()` après chaque `plt.imshow(...)`
 ````
@@ -116,6 +118,7 @@ plt.rc('figure', figsize=(2, 2))
 1. Créez un tableau **non initialisé**, pour représenter une image carrée **de 91 pixels de côté**, d'entiers 8 bits non-signés, et affichez-le  
    ```{admonition} indices
    :class: tip
+
    * il vous faut pouvoir stocker 3 `uint8` par pixel pour ranger les 3 couleurs
    * on s'intéresse uniquement à la taille, et pas au contenu puisqu'on a dit "non initialisé"; que vous ayez du blanc, du noir ou du bruit, c'est OK
    ```
@@ -367,6 +370,7 @@ im = plt.imread(filename)
 
 * vous pouvez créer plusieurs figures depuis une seule cellule  
   pour cela, faites plusieurs fois la séquence `plt.imshow(...); plt.show()`
+
 * vous pouvez ensuite choisir de 'replier' ou non la zone *output* en hauteur;  
   c'est-à-dire d'afficher soit toute la hauteur, soit une zone de taille fixe avec une scrollbar pour naviguer  
   pour cela cliquez dans la marge gauche de la zone *output*
@@ -447,6 +451,7 @@ R, G, B = im[:, :, 0], im[:, :, 1], im[:, :, 2]
     * mais pour afficher une image unidimensionnelle contenant des nombres de `0` à `255`, 
       il faut bien lui dire à quoi correspondent les valeurs  
       (lors de l'affichage, le `255` des rouges n'est pas le même `255` des verts)
+
     * du coup, voyez le paramètre `cmap=` de `plt.imshow`; et notamment avec `'Reds'`,  `'Greens'` ou  `'Blues'`
     ```
 
@@ -483,6 +488,7 @@ for (channel, cmap) in (R, 'Reds'), (G, 'Greens'), (B, 'Blues'):
 ```
 
 5. Copiez l'image, et dans la copie, remplacer le carré de taille `(200, 200)` en bas à droite:
+
    * d'abord par un carré de couleur RGB `(219, 112, 147)` (vous obtenez quelle couleur)  
    * puis par un carré blanc avec des rayures horizontales rouges de 1 pixel d'épaisseur
 

notebooks/numpy-tps/images/.teacher/README-images2-corrige-nb.md

@@ -131,6 +131,7 @@ on obtiendrait cette fois (observez la taille en pixels de l'image)
 
 ```{admonition} indice
 :class: tip dropdown
+
 * votre fonction retourne un tuple avec deux morceaux: le nombre de lignes, et le nombre de colonnes
 * dans un premier temps, vous pouvez vous contenter d'une version un peu brute: on pourrait utiliser juste la racine carrée, et toujours fabriquer des carrés
   
@@ -182,6 +183,7 @@ for n in range(1, 18):
 
 ````{admonition} indices
 :class: dropdown
+
 * sont potentiellement utiles pour cet exo:
   * la fonction `np.indices()`
   * [l'indexation d'un tableau par un tableau](https://numerique.info-mines.paris/numpy-optional-indexing-nb/)
@@ -504,6 +506,7 @@ B' = 0.272 * R + 0.534 * G + 0.131 * B
 * dans notre cas on suppose qu'en entrée on a des entiers non-signé 8 bits
 * mais attention, les calculs vont devoir se faire en flottants, et pas en uint8  
 pour ne pas avoir, par exemple, 256 devenant 0
+
 * toutefois on veut tout de même en sortie des entiers non-signé 8 bits !
 
 ça signifie qu'il va sans doute vous falloir faire un peu de gymnastique avec les types de vos tableaux

notebooks/numpy-tps/pentominos/.teacher/README-pentominos-corrige-nb.md

@@ -256,6 +256,7 @@ you have 12 pieces and 60 slots to fill, so you need 72 columns
 ### model the problem
 
 decide how to represent the board and pieces:
+
 * using nd-arrays, so rectangular spaces
 * use only **booleans** to model **obstacles** in the board and the actual **contour** of pieces
 

notebooks/numpy-tps/sounds/.teacher/README-sounds-corrige-nb.md

@@ -183,11 +183,8 @@ def MyAudio(what, **kwds):
 ```
 
 ```{code-cell} ipython3
----
-slideshow:
-  slide_type: ''
-tags: [raises-exception, gridwidth-1-2]
----
+:tags: [raises-exception, gridwidth-1-2]
+
 # je peux me contenter de faire ceci
 
 MyAudio(la_1seconde)
@@ -259,8 +256,6 @@ def sine(freq, duration=1):
 #MyAudio(sine(LA, 1.5), autoplay=True)
 ```
 
-+++ {"tags": []}
-
 ### pour les rapides
 
 on veut obtenir un effet de 'note qui monte'
@@ -270,16 +265,12 @@ améliorer un peu pour générer une courbe avec un fréquence qui croit (ou dé
 écrire une fonction `sine_linear(freq1, freq2, duration)`
 
 ```{code-cell} ipython3
-:tags: []
-
 # votre code
 def sine_linear(freq1, freq2, duration):
     ...
 ```
 
 ```{code-cell} ipython3
-:tags: []
-
 # prune-cell
 def sine_linear(freq1, freq2, duration):
     t = np.linspace(0, duration, int(duration*RATE))
@@ -288,8 +279,6 @@ def sine_linear(freq1, freq2, duration):
 ```
 
 ```{code-cell} ipython3
-:tags: []
-
 # décommenter pour écouter
 #MyAudio(sine_linear(440, 660, 3))
 ```
@@ -477,6 +466,7 @@ ce qui nous amène à une petite digression: profitons-en pour regarder un peu c
 l'encodage des **entiers signés** fonctionne comme suit; on regarde ici les types `int8` et `uint8` car c'est plus simple, le principe est exactement le même pour des tailles plus grandes
 
 il y a deux types d'encodages pour les entiers:
+
 * `uint8` (le `u` signifie *unsigned*): les entiers **non signés** reposent sur un encodage "naturel": on décompose en base 2, et donc avec 8 bits, on peut aller **de 0 à 255**
 * `int8`: par contre pour les entiers **signés**, on va devoir utiliser **un bit comme bit de signe**, ce qui limite le spectre de ce qu'il est possible d'encoder; avec en tout 8 bits on peut encoder de **-128 à 127 inclus**
 

notebooks/numpy-tps/taylor/.teacher/README-taylor-2-numpy-corrige-nb.md

@@ -150,8 +150,6 @@ def taylor2(X, f, n):
 ### avec sinus au degré 10
 
 ```{code-cell} ipython3
-:tags: []
-
 # Y est le sinus de X
 # Y2 est l'image de X par l'approximation de Taylor pour sinus au degré 10
 

notebooks/numpy-tps/taylor/.teacher/README-taylor-3-interactive-corrige-nb.md

@@ -47,8 +47,10 @@ le but du jeu dans cette dernière partie du TP est de créer un dashboard qui p
 ## modes disponibles
 
 la solution à cet exercice est relativement différente selon le mode de restitution choisi pour `matplotlib`; notamment il y a 
+
 * `%matplotlib inline` qui est le mode par défaut, **très ancien** et **pas du tout interactif** (on ne peut pas agrandir, zoomer, etc... dans la figure)
   c'est plutôt plus simple à coder, mais le résultat est vraiment rustique du coup, bref c'est plutôt déconseillé d'investir dans cette voie
+
 * `%matplotlib notebook` qui était déjà plus moderne; avec ce mode on peut agrandir / zoomer mais il est **devenu obsolète**
 * `%matplotlib ipympl` qui est, en 2024, le successeur du précédent - notamment si vous voulez visualiser vos rendus interactifs  
   ce mode nécessite une installation supplémentaire (et [voir aussi cette page pour plus de détails](#label-dashboard-ipympl))

notebooks/pandas-exos/.teacher/EXO-bornes-corrige-nb.md

@@ -73,11 +73,13 @@ il s'agit donc de démêler l'écheveau pour fabriquer une table qui a 6 lignes,
 
 * on a vu dans le cours que sur un objet Series on pouvait avoir besoin
   occasionnellement d'utiliser l'attribut `str`
+
 * ici on a envie de passer par un objet liste; notamment je vous rappelle
   * la méthode `replace()` sur les chaines de caractères
   * la méthode `split()` sur les chaines de caractères
 * une fois que vous êtes arrivés à mettre une liste dans une cellule d'une Series, 
   il peut être intéressant de remplacer ce contenu par .. un objet Series
+
 * vous pourrez ensuite invoquer la méthode `.stack()` sur la Series englobante
 
 +++