Ungol/ciel-b1
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions

Améliorations et relectures

Browse source
This commit is contained in:
Alexis Fourmaux 2025-08-27 16:16:42 +02:00
parent 0d2d74454f
commit 878b016119
12 changed files with 312 additions and 201 deletions
Download patch file Download diff file Expand all files Collapse all files

47
src/cours/CIEL1/01-bases-python/tp/01_decouverte.md
View file

@ -55,7 +55,7 @@ Vous pouvez utiliser l'interpréteur de python comme une calculatrice. C'est év
- Python utilise la notation anglo-saxonne pour les nombres non entiers (c'est à dire un point au lieu d'une virgule) : il écrira `4.5` et non pas `4,5`. Il en va de même lorsque vous écrirez des nombres en Python.
- Les symboles `+`, `-`, `*`, `/`... sont appelés **opérateurs** en Python
- L'opérateur modulo `%` est souvent utilisé pour savoir si un nombre est multiple d'un autre. Il vaut mieux s'en souvenir. Il permet de calculer le reste de la division euclidienne de deux nombres. Par exemple si on divise 5 par 2 on obtient 2 et il reste 1. 1 est donc notre reste et `5 % 2` nous donnera 1.
- Si l'on veut effectuer la division euclidiuenne d'un nombre par un autre, on peut le faire avec l'opérateur `//` qui est différent de `/`. Par exemple `5//2` nous donnera 2, alors que `5/2` nous donnera `2.5`
- Si l'on veut effectuer la division euclidienne d'un nombre par un autre, on peut le faire avec l'opérateur `//` qui est différent de `/`. Par exemple `5//2` nous donnera 2, alors que `5/2` nous donnera `2.5`
- Les nombres décimaux ont parfois des valeurs approximatives. Il faut être vigilant lorsqu'on les utilise dans des calculs.
```
@ -135,7 +135,7 @@ Nous allons donc affecter et utiliser nos premières variables.
>>> mon_age
~~~
5.
a. Le code suivant calcule le prix TTC d'un article à partir de sont prix hors taxes (45€), en lui ajoutant la TVA. Ecrivez-le dans l'interpréteur. Quel résultat obtenez-vous pour le prix TTC ?
a. Le code suivant calcule le prix TTC d'un article à partir de son prix hors taxes (45€), en lui ajoutant la TVA. Écrivez-le dans l'interpréteur. Quel résultat obtenez-vous pour le prix TTC ?
~~~python
>>> prix_ht = 45
>>> tva = 5.5 / 100
@ -145,16 +145,16 @@ Nous allons donc affecter et utiliser nos premières variables.
b. Modifiez la valeur de `tva` pour qu'elle prenne la valeur de 20%. Quelle valeur a `prix_ttc` ? Pourquoi ?
c. Recalculez la valeur de `prix_ttc` pour prendre en compte la modification de `tva` (Astuce: vous pouvez utiliser <kbd>&uarr;</kbd> pour retrouver la ligne déjà tapée). donnez la ligne que vous avez réexécutée.
c. Recalculez la valeur de `prix_ttc` pour prendre en compte la modification de `tva` (Astuce: vous pouvez utiliser <kbd>&uarr;</kbd> pour retrouver la ligne déjà tapée). Donnez la ligne que vous avez réexécutée.
d. Donnez l’expression qui permet d’évaluer le prix à payer par le client lorsqu’on lui accorde une réduction de 5% sur le prix **hors taxes**.
e. Donnez l'expression qui permet d'augmenter la TVA de 1%, quel que soit sont taux actuel.
```
### Les types et la fonction `type`
### Les types de données et la fonction `type`
Les variables peuvent contenir differents types de données. Nous avons surtout vu des nombres jusqu'à maintenant, mais elles peuvent aussi contenir des **chaînes de caractères** ou d'autres types plus complexes. Nous verrons dans un premier temps les plus simples.
Les variables peuvent contenir differents types de données. Nous avons surtout vu des nombres jusqu'à maintenant, mais elles peuvent aussi contenir des **chaînes de caractères** ou d'autres types plus complexes. Nous verrons dans un premier temps les plus courants.
```admonish success title="À retenir"
- Python est capable de trouver le type d'une donnée tout seul, et cette variable prend le type souhaité lors de l'affectation. On appelle ça du **typage dynamique**
@ -168,7 +168,7 @@ Les variables peuvent contenir differents types de données. Nous avons surtout
4. Affecter la valeur `"<votre prénom>"` à une variable `prenom` et donnez son type.
5. Ecrivez `age = '85'` (Attention aux guillemets) dans l'interpréteur. Donnez le type de `age`.
6. Ecrivez maintenant `age * 2`. Que se passe-t-il ? comment se comporte l'opérateur `*` lorsqu'il est utilisé avec des chaînes de caractères ?
7. Donnez une expression permettant d'affecter le *texte* `'21'` à la variable `mon_age_str` en utilsant uniquement la variable `mon_age` (question 1) et la fonction `str`. Utilisez la fonction type pour vérifier. Qu'en déduisez-vous sur la fonction `str` ?
7. En utilisant la variable `mon_age` (question 1) et la fonction `str`, donnez une expression permettant d'affecter le *texte* `'21'` à la variable `mon_age_str`. Utilisez la fonction type pour vérifier. Qu'en déduisez-vous sur la fonction `str` ?
8. De même donnez une expression permettant de d'affecter le *nombre* 85 à la variable `age_int` en utilisant uniquement `age` (question 6) et la fonction `int`. Qu'en déduisez-vous sur ce que fait la fonction `int` ?
```
@ -203,7 +203,7 @@ Il permet d'écrire du texte brut, sans aucune mise en forme, contrairement aux
L'une d'entre elles, probablement la plus importante, c'est la **coloration syntaxique** : les mots du code sont colorés de différentes manières pour vous aider à identifier la structure et les mots clés, les variables etc...
```
Dans Thonny, nous allons utiliser l'autre encadré, celui qui s'appelle `<sans nom>` pour l'instant. Nous verrons dans un prochain TP comment travailler avec Visual Studio Code, un logiciel très performant et puissant pour écrire du code. Pour l'instant, gardons les choses simples et continuons avec Thonny. Vous pouvez continuer à utiliser Thonny chez vous également, il comporte le nécessaire pour utiliser Python.
Dans Thonny, nous allons utiliser l'autre encadré, au dessus de l'interpréteur, celui qui s'appelle `<sans nom>` pour l'instant. Nous verrons dans un prochain TP comment travailler avec Visual Studio Code, un logiciel très performant et puissant pour écrire du code. Pour l'instant, gardons les choses simples et continuons avec Thonny. Vous pouvez continuer à utiliser Thonny chez vous également, il comporte le nécessaire pour utiliser Python.
Nous allons donc écrire un premier fichier comportant du code que vous pourrez exécuter autant de fois que nécessaire pour le tester, le modifier etc.
@ -315,9 +315,9 @@ Décorticons un peu ce programme.
Dans un nouveau fichier que vous appellerez `tp-01-conditions.py`
1.
a. Copiez et exécutez le code de l'exemple ci-dessus. Vérifiez que la phrase `Ma variable vaut 1` s'affiche correctement.
b. Au début du programme, nous avons déclaré `ma_variable`. Remplacez cette déclaration pour pouvoir saisir un nombre de manière interactive, avec `input`. Mettez la ligne modifiée dans le compte rendu.
c. Réexécutez le programme en testant différentes valeurs (dont `1` pour vérifier qu'il marche toujours comme en a.). Qu'affiche le programme et pourquoi ?
1. Copiez et exécutez le code de l'exemple ci-dessus. Vérifiez que la phrase `Ma variable vaut 1` s'affiche correctement.
1. Au début du programme, nous avons déclaré `ma_variable`. Remplacez cette déclaration pour pouvoir saisir un nombre de manière interactive, avec `input`. Mettez la ligne modifiée dans le compte rendu.
1. Réexécutez le programme en testant différentes valeurs (dont `1` pour vérifier qu'il marche toujours comme en 1.1.). Qu'affiche le programme et pourquoi ?
2. Maintenant, nous allons essayer d'écrire quelque chose lorsque la condition est respectée mais autre chose quand elle ne l'est pas. Pour cela, nous allons utiliser le mot clé `else` qui signifie "sinon". En faisant ça on pourra avoir un programme qui fera "**Si** ma condition est vraie *alors* je fais ça, **sinon** je fais ça".
@ -335,10 +335,6 @@ Dans un nouveau fichier que vous appellerez `tp-01-conditions.py`
Nous pouvons enchaîner plusieurs conditions grâce au mot clé `elif` (contraction de de "else if", c'est à dire "sinon, si..."). `elif` s'utilise exactement comme `if` mais doit forcément se trouver après une première condition `if`.
Modifiez le code précédent en rajoutant le cas des retraités, pour afficher une phrase `Vous êtes en retraite` lorsque la variable `age` est supérieure à 60 (Allez, on y croit !). Mettez ce code dans votre rapport de TP.
4. **Bonus :** Imaginons maintenant que l'on ait une autre variable, `annees_de_cotisation`. À partir de 60 ans, si on a 40 années de cotisation, on peut prendre la retraite. Sinon, il faut atteindre 40 années de cotisation.
Nous allons donc devoir rajouter une condition supplémentaire pour les personnes ayant plus de 60 ans, en fonction de la variable `annee_cotisation`. Rajoutez cette variable, et rajoutez une **condition imbriquée** dans la branche qui concerne les plus de 60 ans.
```
```admonish success title='À retenir'
@ -577,4 +573,25 @@ Les portions de code qui se trouvent après des `#` en python sont considérées
Mettez le code de votre programme à ce stade dans le compte rendu.
1. Ecrivez une nouvelle version de votre boucle, en utilisant `for` cette fois. L'utilisateur aura maximum 10 essais, et s'il dépasse le jeu affichera "Perdu !" avant de s'arrêter.
Mettez le code final de votre programme dans le compte rendu.
```
```
# Annexes
## Un petit peu d'anglais
|Français|Anglais|
|--------|-------|
|Interpréteur|Interpreter|
|Invite de commande|Command prompt|
|Opérateur|Operator|
|Fonction|Function|
|Racine carrée|Square root|
|Affecter une variable|Assign a variable|
|Sensible à la casse|Case sensitive|
|Mot-clé|Keyword|
|Mot clé réservé|Reserved keyword|
|Typage dynamique|Dynamic typing|
|Chaîne de caractères|String|
|Chaîne de caractères formatée|Formatted string|
|Boucle|Loop|

59
src/cours/CIEL1/01-bases-python/tp/02_fonctions.md
View file

@ -8,7 +8,7 @@ Dans ce TP, nous allons commencer à utiliser Visual Studio Code, qui nous servi
### Mise en route
Pour ce TP nous n'allons plus utiliser Thonny mais Visual Studio Code. Thonny est un excellent logiciel pour débuter en python, et il sera facile à utiliser pour vous entraîner à la maison, mais il n'est pas beaucoup utilisé par les professionnels car il manque de nombreuses fonctionnalités indispensables. Visual Studio Code est un éditeur de texte libre édité par Microsoft, compatible avec toutes les plateformes. Il permet de faire ce que fait Thonny, mais également plein d'autres choses. Il est également un logiciel très utilisé en entreprise et pourra vous servir pour de nombreux langages de programmation. C'est pour cela que nous allons commencer à l'utiliser, et vous vous habituerez à son fonctionnement au fil du temps.
Pour ce TP nous n'allons plus utiliser Thonny mais Visual Studio Code. Thonny est un excellent logiciel pour débuter en python, et il sera facile à utiliser pour vous entraîner à la maison, mais il n'est pas beaucoup utilisé par les professionnels car il manque de nombreuses fonctionnalités indispensables. Visual Studio Code est un éditeur de texte libre édité par Microsoft, compatible avec toutes les plateformes. Il permet de faire ce que fait Thonny, mais également plein d'autres choses. C'est un logiciel très utilisé en entreprise et pourra vous servir pour de nombreux langages de programmation. C'est pour cela que nous allons commencer à l'utiliser, et vous vous habituerez à son fonctionnement au fil du temps.
Lancez Visual Studio Code depuis le menu démarrer de votre machine. Vous verrez une interface comme ci-dessous. Sur la capture d'écran, les sections dont vous aurez besoin lors de ce TP sont indiquées par des flèches.
@ -57,19 +57,20 @@ Nous allons maintenant écrire un script que nous modifierons pour découvrir le
Vous connaissez déjà certaines fonctions, celles que vous avez utilisées lors du précédent TP : `print`, `input`, `math.sqrt`, `range` ... Ce sont des fonctions que vous avez **appelées** mais qui existent déjà, soit par défaut dans le langage Python, soit dans une bibliothèque (`math`).
```admonish travail
- Copiez le script suivant dans votre fichier `main.py`. Indiquez les fonctions que vous identifiez.
~~~python
import math
1. Copiez le script suivant dans votre fichier `main.py`. Indiquez les fonctions que vous identifiez.
nb = 7
~~~python
import math
print("Table par 7 : ")
for i in range(1, 11):
print(f"{i} * {nb}", "=", i*nb)
nb = 7
racine_carree = math.sqrt(7)
retour_print = print(f"Racine carrée de {nb} : {racine_carree}")
~~~
print("Table par 7 : ")
for i in range(1, 11):
print(f"{i} * {nb}", "=", i*nb)
racine_carree = math.sqrt(7)
retour_print = print(f"Racine carrée de {nb} : {racine_carree}")
~~~
1. Indiquez les symboles utilisés pour appeler des fonctions.
1.
@ -77,7 +78,7 @@ retour_print = print(f"Racine carrée de {nb} : {racine_carree}")
1. Quel symbole sert à les séparer ?
1. Que se passe-t-il si on retire ce symbole ?
1.
1. Modifiez l'ordre des arguments passés à `print` ligne 7. Qu'est-ce que ça change ? À votre avis pourquoi ?
1. Modifiez l'ordre des arguments passés à `print` ligne 7. Qu'est-ce que ça change ?
1. Ajoutez à la fonction `print` ligne 7 un argument `sep='-'`. Réexécutez le script. Qu'est-ce que ça change ?
1. Ajoutez maintenant un argument `end='|'` à la fonction `print` ligne 7. Réexécutez le script. Qu'est-ce que ça change ?
1. Expliquez selon vous ce que font les paramètres `sep` et `end` de la fonction `print`
@ -138,12 +139,12 @@ Si on reprend le code de la partie précédente, on voit qu'il permet d'afficher
2. Déplacez cette ligne tout en haut du fichier. Que se passe-t-il ? Pourquoi à votre avis ?
3. Replacez la ligne à la fin du fichier, comme en 3.1.
4. Bon, maintenant nous avons une fonction qui fait la même chose qu'avant. Mais si on veut calculer la table par 5 ou 8, il nous faudrait pouvoir passer la table en paramètre.
4. Bon, maintenant nous avons une fonction qui fait la même chose qu'avant. Mais si on veut calculer la table par 5 ou 8, il nous faudrait pouvoir passer la valeur en paramètre.
1. Renommez la fonction en `table`, puisqu'elle nous servira à d'autres tables que celle par 7
2. Ajoutez un argument `nb` dans la définition et retirez la variable `nb = 7`
~~~python
def table():
print("Table par {nb} : ")
def table(nb):
print(f"Table par {nb} : ")
for i in range(1, 11):
print(f"{i} * {nb}", "=", i*nb)
~~~
@ -156,7 +157,7 @@ Si on reprend le code de la partie précédente, on voit qu'il permet d'afficher
6. Dans la majorité des cas on voudra probablement afficher la table jusqu'à 10. Pour nous éviter de devoir préciser `maximum` à chaque fois, nous allons mettre une valeur par défaut à `maximum` pour que la fonction affiche les 10 premières lignes si le paramètre n'est pas précisé.
Pour cela ajoutez simplement `=10` dans la déclaration de la fonction.
Pour cela ajoutez simplement `=10` dans la déclaration de la fonction, à côté de l'argument `maximum`. Cela affectera la valeur 10 à `maximum` si rien n'est précisé.
Exécutez votre fonction avec `table(5, 20)` puis `table(7)` et vérifiez que nous avons bien la table par 5 de 1 à 20 dans le premier cas, et la table par 7 de 1 à 10 dans le second
@ -189,6 +190,7 @@ Si on reprend le code de la partie précédente, on voit qu'il permet d'afficher
```
```admonish tip title='Bonnes pratiques'
- On nomme les fonctions en `snake_case` en Python
- Faites des fonctions courtes qui vont à l'essentiel (20 lignes est un bon maximum)
- Choisissez bien les noms de vos fonctions et de vos paramètres pour qu'ils soient clairs et explicites
- Vous pouvez documenter vos fonctions à l'aide d'une **docstring** : après l'en-tête de la fonction, avant le bloc d'instructions vous pouvez écrire une chaîne de caractères qui commence par 3 `"` ou `'`.
@ -214,9 +216,9 @@ Si on reprend le code de la partie précédente, on voit qu'il permet d'afficher
Que fait l'instruction `return` selon vous ? N'hésitez pas à expérimenter
2. Donnez le code permettant d'affecter le résultat de la fonction à une variable pour ensuite l'afficher. Vous pourrez calculer l'aire d'un carré de côté 3m pour cet exemple.
1. Expérimentez pour répondre aux questions suivantes. Donnez le code utilisé à chaque fois.
a. Que retourne une fonction qui utilise l'instruction `return` sans préciser de valeur ?
b. Que se passe-t-il si une instruction se trouve après l'instruction `return` dans votre fonction ?
c. Que retourne une fonction qui n'a pas d'instruction `return` ?
1. Que retourne une fonction qui utilise l'instruction `return` sans préciser de valeur ?
1. Que se passe-t-il si une instruction se trouve après l'instruction `return` dans votre fonction ?
1. Que retourne une fonction qui n'a pas d'instruction `return` ?
1. Nous voulons maintenant que notre fonction renvoie l'aire **et** le périmètre d'un carré. Pour cela, modifions la fonction comme suit.
~~~python
def carre(cote):
@ -322,13 +324,13 @@ Imprégnez-vous bien des règles du jeu.
~~~
3. Expliquez les étapes du programme qui se déroulent dans la boucle à la fin du script, et quand est-ce qu'elle s'arrête.
1. Complétez à l'aide des règles du jeu au dessus les fonctions :
1. Complétez les fonctions suivantes à l'aide des règles du jeu :
1. `calculer_gains_numero`
1. `calculer_gains_couleur`. Comme nous voulons arrondir à l'entier supérieur, il faudra importer et utiliser la fonction `ceil` du module `math`.
Pour vérifier vos résultats, vous pouvez soit utiliser l'interpréteur en console, soit appeler les fonctions dans votre script et utiliser `print` pour afficher le résultat
2. Allez à la ligne `#TODO Écrire ici la condition principale, pour déterminer les gains`. Cette condition correspond à celle qui permet de savoir si un joueur a gagné ou non.
2. Allez à la ligne `#TODO Écrire ici la condition principale, pour déterminer les gains`. Cette condition est celle qui permet de savoir si un joueur a gagné ou non.
1. Écrivez la condition en utilisant les fonctions `calculer_gains_couleur` et `calculer_gains_numero`. N'oubliez pas le cas où le joueur perd.
2. Ajoutez des `print` dans chaque branche pour annoncer les gains ou pertes.
3. Testez les différents cas possibles en modifiant les valeurs retournées par la fonction `tourner_la_roulette`
@ -343,10 +345,21 @@ Imprégnez-vous bien des règles du jeu.
1. Le coeur du jeu semble maintenant fonctionner. Il ne reste plus qu'à permettre à la joueuse d'interagir avec le programme. Commençons par la mise.
1. Complétez la fonction `choisir_nombre` de façon à ce que l'on demande à la joueuse un nombre tant que celui-ci n'est pas valide. Pour simplifier, considérons que personne ne s'amusera à entrer autre chose que des nombres (nous verrons plus tard dans l'année un moyen bien plus efficace de gérer les erreurs).
2. Complétez la fonction `miser` pour qu'elle utilise notre fonction nouvellement complétée. Vérifiez que tout fonctionne comme prévu.
3. Sur le même modèle que `choisir_nombre`, écrivez une fonction `miser_jetons` qui permettra à la joueuse de choisir un nombre de jetons à miser. Attention : il faudra vérifier qu'elle ne mise pas plus de jetons que ce qu'elle a. Vous aurez donc besoin d'un paramètre pour passer les jetons restants à votre fonction.
3. Sur le même modèle que `choisir_nombre`, écrivez une fonction `miser_jetons` qui permettra à la joueuse de choisir un nombre de jetons à miser. Attention : il faudra vérifier qu'elle ne mise pas plus de jetons que ce qu'elle a. Vous aurez donc besoin d'un paramètre pour passer le nombre de jetons restants à votre fonction.
4. Complétez la fonction `miser` pour qu'elle utilise notre nouvelle fonction. Vérifiez que tout fonctionne comme prévu.
1. Maintenant, il ne reste plus qu'à demander au joueur s'il souhaite continuer de jouer, et mettre fin à la partie s'il n'a plus de jetons. Dans la fonction `continuer_de_jouer`, retirez la première ligne, celle qui contient un `return`. Complétez le reste de la fonction en remplaçant les lignes contenant la mention `#TODO`. Testez votre programme de bout en bout.
1. Mettez le programme final dans votre compte rendu.
```
```
# Annexes
## Un peu d'anglais
|Français|Anglais|
|-|-|
|Appeler une fonction|Call a function|
|Virgule|Comma|
|Parenthèses|Brackets|
|Crochets|Square brackets|
|Accolades|Curly brackets|

31
src/cours/CIEL1/01-bases-python/tp/_01_decouverte.md
View file

@ -1,31 +0,0 @@
```admonish success title="Opérateurs"
1. 5
2.
~~~python
4+7
3-12
6*7
9/2
4.2+1.5
5%2
2**10
37*(13+24) #1369
~~~
3. Le résultat semble faux : la dernière décimale affichée est 5 au lieu de 3 (qui devrait se poursuivre à l'infini). C'est une approximation erronée due à la manière dont les nombres sont codés en informatique.
```
```admonish success title="Module math"
1.
~~~python
math.sqrt(81)
abs(-2)
math.pi
math.cos(math.pi)
math.floor(3.56)
~~~
2.
- math.ceil() est arrondi à l'entier supérieur (ou au nombre lui même si c'est un entier)
- math.floor() prend la partie entière, c'est à dire le nombre entier situé avant la virgule. C'est un arrondi à l'entier inférieur.
```

4
src/cours/CIEL1/02-reseau/cours/divisions_hexa.svg Normal file
View file

File diff suppressed because one or more lines are too long
Side by side

After

Width:  |  Height:  |  Size: 158 KiB

140
src/cours/CIEL1/02-reseau/cours/numeration.md
View file

@ -10,15 +10,18 @@ Les nombres peuvent avoir plein de représentations différentes, selon les cont
On écrit les nombres avec une succession de symboles, les chiffres, qui représentent une valeur.
On utilise un système positionnel, c'est à dire que la valeur du symbole diffère selon sa position dans le nombre. Ex.
- le nombre 222 : le 2 le plus à gauche (celui des centaines) vaut 10 fois plus que celui du milieu (celui des dizaines), qui vaut lui même 10 fois plus que celui de droite (celui des unités). Et pourtant il s'agit toujours d'un 2, le même symbole.
On utilise un système positionnel, c'est à dire que la valeur du symbole diffère selon sa position dans le nombre.
```admonish example title="Exemple"
Le nombre 222 : le 2 le plus à gauche (celui des centaines) vaut 10 fois plus que celui du milieu (celui des dizaines), qui vaut lui même 10 fois plus que celui de droite (celui des unités). Et pourtant il s'agit toujours d'un 2, le même symbole.
```
La position dans le nombre s'appelle le **rang** et sa valeur s'appelle le **poids**. Plus le rang est élevé, plus le poids est élevé.
En base 10, le poids d'un nombre est multiplié par 10 à chaque fois qu'on monte d'un rang :
- Si le nombre est placé tout à droite, en première position, au niveau des unités, son poids sera la valeur du chiffre multiplié par 1 (ou 10⁰)
- Si le nombre est placé au niveau des dizaines, en seconde position, son poids sera 10 fois plus élevé : on multipliera le chiffre par 10 (ou 10¹)
- Si le nombre est placé au niveau des centaines, en troisième position, son poids sera encore 10 fois lus élevé (et 100 fois plus élevé que pour les unités) : on multipliera le chiffre par 100 (ou 10²).
- Si le nombre est placé tout à droite, en première position (rang 0), au niveau des unités, son poids sera la valeur du chiffre multiplié par 1 (ou 10⁰)
- Si le nombre est placé au niveau des dizaines, en seconde position (rang 1), son poids sera 10 fois plus élevé : on multipliera le chiffre par 10 (ou 10¹)
- Si le nombre est placé au niveau des centaines, en troisième position (rang 2), son poids sera encore 10 fois plus élevé (et 100 fois plus élevé que pour les unités) : on multipliera le chiffre par 100 (ou 10²).
- On peut ainsi extrapoler avec les milliers, les dizaines de milliers etc.
Donc un nombre représenté en base 10 pourra correspondre à la formule suivante (où les $a_i$ sont les chiffres de rang $i$) :
@ -34,10 +37,11 @@ Les $a_i$ diffèrent selon les bases :
- en base 2, on utilise les chiffres de 0 à 1
- en base 16, on utilise les chiffres de 0 à F (on utilisera des lettres pour les "chiffres" au delà de 9)
Par exemple :
```admonish example title="Exemple"
- $48_{|10}$ pour 48 en base 10 : $4\times10^1+8\times10^0$
- $56_{|16}$ pour 86 en base 16 : $5\times16^1+6\times16^0$
- $1011_{|2}$ pour 11 en base 2 : $1\times2^3+0\times2^2+1\times2^1+1\times2^0$
```
Remarquez que nous avons écrit la base avec le symbole | pour éviter les confusions
@ -53,11 +57,12 @@ Le système binaire est très utilisé en informatique. Il sert notamment en ré
Dans le système binaire, chaque symbole représente une puissance de 2. Comme il n'y en a que 2 nécessaires, on utilise le 0 et le 1.
Exemples:
```admonish example title="Exemple"
- $11_{|2} = 1\times2^1+1\times2^0 = 3_{|10}$
- $101_{|2} = 1\times2^3+0\times2^2+1\times2^1+1\times2^0 = 5_{|10}$
```
Chaque symbole est appelé un **bit** (**Bi**nary dig**it*) pour les distinguer des chiffres du système décimal.
Chaque symbole est appelé un **bit** (**Bi**nary dig**it**) pour les distinguer des chiffres du système décimal.
On regroupe souvent les bits en paquets de 8 que l'on va appeler **octets** (bytes en anglais). Un octet permet de représenter 256 nombres (de 0 à 255)
@ -67,10 +72,12 @@ Dans un nombre binaire on se réfère souvent aux bits situés aux extrémités:
- On parlera de **MSB** (*Most Significant Bit*) ou **bits de poids fort** pour les bits les plus à gauche (dont le **poids/rang** est plus élevé)
- On parlera de **LSB** (*Least Significant Bit*) ou **bits de poids faible** pour les bits les plus à droite (dont le **poids/rang** est plus bas)
Par exemple pour le nombre $1001_{|2}$ :
```admonish example title="Exemple"
Pour le nombre $1001_{|2}$ :
|1|0|0|1|
|-|-|-|-|
|MSB|||LSB|
```
### Multiples d'octets
@ -89,27 +96,10 @@ Pour parler des capacités de supports de stockage ou de la mémoire vive on par
- le gibioctet (Gio) = 2³⁰ octets = 1024 Mio
- le tébioctet (Tio) = 2⁴⁰ octets = 1024 Gio
## La base 16, système hexadécimal
Le système hexadécimal est également très utilisé :
- Les adresses MAC en réseau, ou les adresses IPv6
- Les couleurs dans la plupart des logiciels de dessin ou de retouche photo
- Les valeurs binaires dans de nombreux langages de programmation
Sur le même modèle que précédemment, les valeurs des symboles utilisés sont des puissances de 16. Dans ce système, on utilise les 10 chiffres du systèmes décimal (de 0 à 9), suivis des premières lettres de l'alphabet latin (de A à F pour les valeurs de 10 à 15).
- $\mathrm{3B} = 3_{|10}\times16^1 + 11_{|10}\times16^0 = 59_{|10}$
- $\mathrm{1CF} = 1_{|10}\times16^2 + 12_{|10}\times16^1 + 15_{|10}\times16^0 = 463_{|10}$
La convention pour écrire des nombres hexadécimaux est de les précéder par `0x` : `0x1CF`.
Cette écriture fonctionne en Python, qui interprètera votre valeur comme codée en hexadécimal si vous l'écrivez avec `0x`.
## Conversions
### Conversions
Dans de nombreux cas il sera nécessaire de pouvoir convertir les nombres d'une base à l'autre. Nous l'utiliserons souvent en réseau, mais également en informatique bas niveau (embarquée).
### Binaire - Décimal
#### Décimal vers binaire
##### Méthode des soustractions successives
@ -124,7 +114,8 @@ Procédez de cette manière :
1. Procédez comme ça jusqu'à ce que votre tableau soit rempli
1. Votre nombre binaire sera écrit dans les cases de votre tableau
Exemple: $137_{|10} = 10001001_{|2}$
```admonish example title="Exemple"
$137_{|10} = 10001001_{|2}$
|128|64|32|16|8|4|2|1|
|---|--|--|--|-|-|-|-|
@ -136,6 +127,7 @@ Exemple: $137_{|10} = 10001001_{|2}$
4. 9 - 8 = 1
5. 1 est inférieur à 4 et 2 donc on y met 0. On met 1 dans la colonne 1.
6. Nous avons rempli toutes nos colonnes : on peut lire notre nombre dans le tableau, de gauche à droite : $10001001_{|2}$
```
```admonish tip title='Astuce'
Pour savoir jusqu'où devrait aller votre tableau, vous devez savoir quelle sera la plus grande puissance de 2 impliquée. Pour cela :
@ -157,9 +149,11 @@ La méthode:
3. Procédez de cette manière jusqu'à avoir un quotient de 0
4. Pour trouver votre nombre binaire, prenez le reste de chacune de vos divisions dans l'ordre **inverse** de vos calculs. Le dernier reste trouvé sera votre bit de poids fort (MSB) et le premier reste calculé votre bit de poids faible (LSB)
Exemple avec le nombre $53_{|10}$ qui s'écrit $110101_{|2}$ en binaire :
```admonish example title="Exemple"
Le nombre $53_{|10}$ qui s'écrit $110101_{|2}$ en binaire :
![divisions successives](./divisions_successives.svg)
```
#### Binaire vers décimal
@ -169,6 +163,7 @@ Pour calculer le nombre décimal à partir du nombre binaire, il suffit de prend
Le bit de poids faible a une puissance de 0 (2⁰ = 1) et non pas de 1 (2¹ = 2)
```
```admonish example title="Exemple"
Ainsi pour $110101_{|2}$, cela revient à faire :
|Bits|1|1|0|1|0|1|
@ -179,8 +174,28 @@ Ainsi pour $110101_{|2}$, cela revient à faire :
Et donc :
$$1\times2^5 + 1\times2^4 + 0\times2^3 + 1\times2^2 + 0\times2^1 + 1\times2^0 = 32 + 16 + 4 + 1 = 53$$
```
### Binaire vers Hexadécimal
## La base 16, système hexadécimal
Le système hexadécimal est également très utilisé :
- Les adresses MAC en réseau, ou les adresses IPv6
- Les couleurs dans la plupart des logiciels de dessin ou de retouche photo
- Les valeurs binaires dans de nombreux langages de programmation
Sur le même modèle que précédemment, les valeurs des symboles utilisés sont des puissances de 16. Dans ce système, on utilise les 10 chiffres du systèmes décimal (de 0 à 9), suivis des premières lettres de l'alphabet latin (de A à F pour les valeurs de 10 à 15).
```admonish example title="Exemple"
- $\mathrm{3B} = 3_{|10}\times16^1 + 11_{|10}\times16^0 = 59_{|10}$
- $\mathrm{1CF} = 1_{|10}\times16^2 + 12_{|10}\times16^1 + 15_{|10}\times16^0 = 463_{|10}$
```
La convention pour écrire des nombres hexadécimaux est de les précéder par `0x` : `0x1CF`.
Cette écriture fonctionne en Python, qui interprètera votre valeur comme codée en hexadécimal si vous l'écrivez avec `0x`.
### Conversions
#### Binaire vers Hexadécimal
Pour convertir un nombre binaire en hexadécimal, c'est plus simple. Un nombre hexadécimal est facile à représenter avec 4 bits ($1111_{|2} = 15_{|10} = \mathrm{F}_{|16}$).
@ -207,7 +222,8 @@ Si votre nombre ne contient pas assez de bits pour faire un groupe de 4, rajoute
|14|E|1110
|15|F|1111
Exemple avec $110101_{|2}$:
```admonish example title="Exemple"
Avec $110101_{|2}$:
1. On n'a que 6 bits, il faut donc rajouter deux zéros à gauche pour faire deux paquets de 4.
$$\overbrace{00}^{\text{ajout}}110101$$
@ -215,16 +231,72 @@ $$\overbrace{00}^{\text{ajout}}110101$$
$$\overbrace{0011}^{3_{|16}}\overbrace{0101}^{5_{|16}}$$
3. Cela nous donne alors $110101_{|2} = 35_{|16}$
```
### Hexadécimal vers binaire
#### Hexadécimal vers binaire
Pour convertir un nombre hexadécimal vers binaire, il faut faire exactement pareil, en remplaçant la représentation hexadécimale du nombre par sa représentation binaire.
Ex: $\mathrm{6B}_{|16} = {\overbrace{0110}^{6_{|16}}\overbrace{1011}^{\mathrm{B}_{|16}}}_{|2}$
```admonish example title="Exemple"
$$\mathrm{6B}_{|16} = {\overbrace{0110}^{6_{|16}}\overbrace{1011}^{\mathrm{B}_{|16}}}_{|2}$$
```
#### Hexadécimal vers décimal
Pour calculer le nombre décimal à partir du nombre hexadécimal, il suffit de prendre la formule de la première partie appliquée à une base 16 : prenez chaque chiffre et multipliez-le par son poids.
```admonish warning title='Attention'
Le bit de poids faible a une puissance de 0 (16⁰ = 1) et non pas de 1 (16¹ = 16)
```
```admonish example title="Exemple"
Ainsi pour $\mathrm{6A}_{|16}$, cela revient à faire :
|Chiffres|6|A|
|-|-|-|
|Rang/Puissance|1|0|
|Poids|16|1|
|Valeur|96|10|
Et donc :
$$6\times16^1 + 10\times16^0 = 96 + 10 = 106$$
```
#### Décimal vers hexadécimal
##### Base intermédiaire
Cette méthode consiste à d'abord convertir un nombre en binaire, puis à convertir le nombre binaire en nombre hexadécimal.
```admonish example title="Exemple"
Le nombre $47_{|10}$.
On utilise la méthode des soustractions :
|32|16|8|4|2|1|
|--|--|-|-|-|-|
| 1| 0|1|1|1|1|
Puis on regroupe les bits en paquets de 4, en n'oubliant pas de compléter avec des zéros.
$${\overbrace{0010}^{2_{|16}}\overbrace{1111}^{\mathrm{F}_{|16}}}_{|2} = \mathrm{2F}_{|16}$$
```
##### Méthode des division successives
Cette méthode est similaire à celle des divisions successives pour la conversion d'un nombre décimal en binaire.
```admonish example title="Exemple"
Toujours avec le nombre $47_{|10}$
![divisions hexa](divisions_hexa.svg)
On obtient donc $47_{|10} = \mathrm{2F}_{|16}$
```
# Opérations logiques
TODO
# Annexes
### Tableau des puissances de 2

4
src/cours/CIEL1/02-reseau/td/_td02_correction.md
View file

@ -15,8 +15,8 @@
|-|-|-|-|-|
|112.34.65.3/24|255.255.255.0|112.34.65.255|112.34.65.0|254|
|192.168.17.43/16|255.255.0.0|192.168.255.255|192.168.0.0|65 534|
|10.3.10.1/21|255.255.248|10.3.15.255|10.3.8.0|2046|
|172.16.21.34/28|255.255.240.0|172.16.21.47|172.16.21.32|14|
|10.3.10.1/21|255.255.248.0|10.3.15.255|10.3.8.0|2046|
|172.16.21.34/28|255.255.255.240|172.16.21.47|172.16.21.32|14|
2. Donnez la notation CIDR des adresses suivantes
- 192.168.3.45 masque 255.255.255.0 -> 192.168.3.45/24

64
src/cours/CIEL1/02-reseau/td/td01-numeration.md
View file

@ -1,34 +1,66 @@
# TD Représentation des nombres
1. Dans les nombres suivants, indiquez le rang, le poids et la valeur de chaque chiffre.
- $52_{|10}$
- $675_{|10}$
- $1010_{|2}$
- $10011_{|2}$
1. Convertissez les nombres suivants en décimal
- $\mathrm{5B0F}_{|16}$
- `0x1001`
- $10011010_{|2}$
- $11001011_{|2}$
- $111101101100_{|2}$
- $101010101010_{|2}$
- $1100101111_{|2}$
- `1001b`
2. Convertissez les nombres suivants en binaire
- $251_{|10}$ (utilisez les deux méthodes)
- $3887_{|10}$ (utilisez les deux méthodes)
- $\mathrm{532}_{|16}$
- $\mathrm{5B0F}_{|16}$
2. Convertissez les nombres suivants en binaire (utilisez les deux méthodes à chaque fois)
- $17_{|10}$
- $251_{|10}$
- $3887_{|10}$
- $439_{|10}$
3. Convertissez les nombres suivants en hexadécimal
- $10011010_{|2}$
- $100110101_{|2}$
- $111 1001 1100 1011 1101 0001_{|2}$
4. Combien de nombres un octet permet-il de représenter ? Justifier.
4. Combien de nombres peut-on représenter avec
- 8 bits (un octet)
- 12 bits
- 16 bits
- 32 bits
- 128 bits
5. En admettant qu'un nombre entier naturel soit codé sur 32 bits, quelle est la valeur maximale que peut avoir un entier naturel ? À votre avis, dans un système informatique, que se passe-t-il si on augmente de 1 la valeur maximale d'un entier ?
7. Quelle est la capacité d'un disque dur de 1To
7. Quelle est la capacité d'un disque dur de 1To ?
- en Go
- en Mo
- en Gio
- en Mio
8. Mon ordinateur m'indique qu'un fichier fait 13 560 788 octets. Combien cela représente-t-il environ (1 chiffre après la virgule)
8. Mon ordinateur m'indique qu'un fichier fait 13 560 788 octets. Combien cela représente-t-il environ (1 chiffre après la virgule) ?
- en Kio
- en Mio
- en Ko
- en Mo
- en Mo
9. Convertissez les nombres suvants en décimal
- $\mathrm{12}_{|16}$
- $\mathrm{C3}_{|16}$
- $\mathrm{5B0F}_{|16}$
- $\mathrm{445B}_{|16}$
- $\mathrm{DE1D}_{|16}$
- $\mathrm{B64F}_{|16}$
- `0x1001`
10. Convertissez les nombres suivants en binaire
- $\mathrm{12}_{|16}$
- $\mathrm{C3}_{|16}$
- $\mathrm{532}_{|16}$
- $\mathrm{5B0F}_{|16}$
- $\mathrm{445B}_{|16}$
- $\mathrm{DE1D}_{|16}$
- $\mathrm{B64F}_{|16}$
- $\mathrm{F09A}_{|16}$
11. Convertissez les nombres suivants en hexadécimal
- $10011010_{|2}$
- $100110101_{|2}$
- $111 1001 1100 1011 1101 0001_{|2}$

1
src/cours/CIEL1/02-reseau/td/td02-adresse_IP.md Normal file
View file

@ -0,0 +1 @@
# TD2 - Adresse IP

97
src/cours/CIEL1/02-reseau/td/td02_adresse_IP.md
View file

@ -1,57 +1,64 @@
# TD - Adressage IP
1. Donnez le type des adresses suivantes
- 34 allée des peupliers 13400 Aubagne FRANCE
- A5:A1:9C:B6:9C:67
- 177.34.54.12
- A5:A1:9C:B6:9C:67
- 177.34.54.12
1. L'adresse 192.345.2.13 est-elle valide ? Justifiez
2. Donnez pour les adresses suivantes : le masque, l'identifiant de réseau, l'identifiant hôte, l'adresse de diffusion, l'adresse de réseau et la taille de la plage adressable:
- 112.34.65.3/24
- 192.168.17.43/16
- 10.3.10.1/21
- 172.16.21.34/28
2. Donnez la notation CIDR et l'adresse de réseau des adresses suivantes
- 192.168.3.45 masque 255.255.255.0
- 224.6.75.1 masque 255.255.240.0
- 10.0.75.1 masque 255.192.0.0
- 212.195.235.190 masque 192.0.0.0
- 39.113.117.250 masque 255.255.224.0
- 79.43.100.194 masque 255.128.0.0
2. Donnez la notation CIDR des adresses suivantes
- 192.168.3.45 masque 255.255.255.0
- 224.6.75.1 masque 255.255.240.0
- 10.0.75.1 masque 255.192.0.0
2. Donnez pour les adresses suivantes : le masque, l'identifiant de réseau, l'identifiant hôte, l'adresse de diffusion, l'adresse de réseau et la taille de la plage adressable:
- 112.34.65.3/24
- 192.168.17.43/16
- 10.3.10.1/21
- 172.16.21.34/28
- 133.203.141.89/12
- 195.132.93.162/31
- 85.55.32.207/23
- 126.50.215.199/18
3. Dites si les adresses suivantes sont publiques ou privées et si elles peuvent servir à adresser une machine
- 223.45.52.12
- 172.19.2.21
- 172.44.17.0
- 12.255.255.255
- 192.168.43.89
- 10.3.0.1
- 127.0.0.1
- 192.169.17.21
- 178.3.2.1
- 0.127.4.100
- 223.45.52.12
- 172.19.2.21
- 172.44.17.0
- 12.255.255.255
- 192.168.43.89
- 10.3.0.1
- 127.0.0.1
- 192.169.17.21
- 178.3.2.1
- 0.127.4.100
4. Une entreprise souhaite relier ses 80 machines dasn un réseau informatique. L'administrateur choisit le réseau 192.168.1.0/24
a. Donnez le masque de ce réseau
b. Donnez la première et la dernière adresse du réseau
c. Combien de machines peuvent être connectées en même temps sur ce réseau ?
d. Quelle est l'adresse de broadcast du réseau ?
e. Est-ce que ce réseau est un bon choix pour l'entreprise ? Justifiez
f. Dans quel cas doit-on utiliser l'adresse de broadcast ?
g. Si on souhaite découper le réseau en 8 sous-réseaux, quel sera le masque qui permettra ce découpage ?
h. Complétez le tableau ci-dessous
4. Une entreprise souhaite relier ses 80 machines dans un réseau informatique. L'administrateur choisit le réseau 192.168.1.0/24
|N°|Adresse de sous-réseau|1ere adresse|Dernière adresse|Adresse de broadcast|
|-|-|-|-|-|
|0|||||
|1|||||
|2|||||
|3|||||
|4|||||
|5|||||
|6|||||
|7|||||
1. Donnez le masque de ce réseau
1. Donnez la première et la dernière adresse du réseau
1. Combien de machines peuvent être connectées en même temps sur ce réseau ?
1. Quelle est l'adresse de broadcast du réseau ?
1. Est-ce que ce réseau est un bon choix pour l'entreprise ? Justifiez
1. Dans quel cas doit-on utiliser l'adresse de broadcast ?
1. Si on souhaite découper le réseau en 8 sous-réseaux, quel sera le masque qui permettra ce découpage ?
1. Complétez le tableau ci-dessous
i. Est-ce que les ordinateurs ayant les IP 192.168.1.120 et 192.168.1.130 peuvent communiquer entre eux ? Pourquoi ?
j. Combien y a-t-il d'adresses dans chaque sous-réseau
k. Combien y a-t-il d'adresses perdues avec ce découpage ?
l. Donnez la notation CIDR de la première machine appartenant au réseau n°4
|N°|Adresse de sous-réseau|1ere adresse|Dernière adresse|Adresse de broadcast|
|-|-|-|-|-|
|0|||||
|1|||||
|2|||||
|3|||||
|4|||||
|5|||||
|6|||||
|7|||||
1. Est-ce que les ordinateurs ayant les IP 192.168.1.120 et 192.168.1.130 peuvent communiquer entre eux ? Pourquoi ?
1. Combien y a-t-il d'adresses dans chaque sous-réseau
1. Combien y a-t-il d'adresses perdues avec ce découpage ?
1. Donnez la notation CIDR de la première machine appartenant au réseau n°4

6
src/cours/CIEL2/01-revisions-python/tp/tp1_bases.md
View file

@ -441,9 +441,9 @@ Nous allons maintenant créer une fonction par nous-mêmes à partir du code de
1. Modifiez la fonction pour retourner à la fois l'aire d'un carré et le périmètre d'un carré. Appelez la fonction, stockez les deux résultats dans deux variables
1. Expérimentez pour répondre aux questions suivantes. Donnez le code utilisé à chaque fois.
a. Que retourne une fonction qui utilise l'instruction `return` sans préciser de valeur ?
b. Que se passe-t-il si une instruction se trouve après l'instruction `return` dans votre fonction ?
c. Que retourne une fonction qui n'a pas d'instruction `return` ?
1. Que retourne une fonction qui utilise l'instruction `return` sans préciser de valeur ?
1. Que se passe-t-il si une instruction se trouve après l'instruction `return` dans votre fonction ?
1. Que retourne une fonction qui n'a pas d'instruction `return` ?
```
```admonish success title='À retenir'

6
src/cours/SUMMARY.md
View file

@ -1,14 +1,14 @@
# Summary
- [CIEL 1e année](./CIEL1/ciel1.md)
- [Représentation des nombres](./CIEL1/02-reseau/cours/numeration.md)
- [TD1 - Représentation des nombres](./CIEL1/02-reseau/td/td01-numeration.md)
- [TD2 - Adresse IP](./CIEL1/02-reseau/td/td02_adresse_IP.md)
- [Bases de l'algorithmique avec Python](./CIEL1/01-bases-python/algorithmique-python.md)
- [TP1 - Découverte de Python](./CIEL1/01-bases-python/tp/01_decouverte.md)
- [TP1 - Corrigé - Découverte de Python](./CIEL1/01-bases-python/tp/_01_decouverte.md)
- [TP2 - Fonctions](./CIEL1/01-bases-python/tp/02_fonctions.md)
- [TD1 - Bases de Python](./CIEL1/01-bases-python/td/td01-python.md)
- [TD2 - Python](./CIEL1/01-bases-python/td/td02.md)
- [L'adressage IP](./CIEL1/02-reseau/cours/adressage-ip.md)
- [Représentation des nombres](./CIEL1/02-reseau/cours/numeration.md)
- [TD1 - Représentation des nombres](./CIEL1/02-reseau/td/td01-numeration.md)
- [L'environnement de développement](./CIEL1/03-dev-env/dev-env.md)
- [Les conteneurs](./CIEL1/03-dev-env/conteneurs.md)
- [Git](./CIEL1/03-dev-env/git.md)

54
src/slides/representation_nombres.md
View file

@ -157,34 +157,7 @@ Capacité donnée : 512 Go = 512.10⁹ octets
-->
---
## La base 16, système hexadécimal
---
* Également très utilisé : Adresses MAC, IPv6, couleurs...
* Chaque symbole représente une puissances de 16
* Nombres de 0 à 9 + lettres de A à F
- $\mathrm{3B} = 3_{|10}\times16^1 + 11_{|10}\times16^0 = 59_{|10}$
* Convention : `0x` -> `0x1CF`
---
Exercice: Convertir en décimal
- 0x1CF
- 0x3B7
<!--
0x1CF = 463
0x3B7 = 951
-->
---
## Conversions
---
### Décimal vers binaire
### Conversion décimal vers binaire
- 2 méthodes :
- Soustractions successives
@ -274,9 +247,32 @@ Exercice: Convertir en binaire
111 = 0110 1111
-->
---
## La base 16, système hexadécimal
---
* Également très utilisé : Adresses MAC, IPv6, couleurs...
* Chaque symbole représente une puissances de 16
* Nombres de 0 à 9 + lettres de A à F
- $\mathrm{3B} = 3_{|10}\times16^1 + 11_{|10}\times16^0 = 59_{|10}$
* Convention : `0x` -> `0x1CF`
---
Exercice: Convertir en décimal
- 0x1CF
- 0x3B7
<!--
0x1CF = 463
0x3B7 = 951
-->
---
### Binaire vers hexadécimal
### Conversion binaire vers hexadécimal
- Regrouper les bits par 4
- Compléter si besoin avec des 0