Améliorations et relectures
This commit is contained in:
parent
0d2d74454f
commit
878b016119
12 changed files with 312 additions and 201 deletions
|
|
@ -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>↑</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>↑</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|
|
||||
|
||||
|
|
|
|||
|
|
@ -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|
|
||||
|
|
@ -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.
|
||||
```
|
||||
Loading…
Add table
Add a link
Reference in a new issue