---
jupytext:
text_representation:
extension: .md
format_name: myst
format_version: 0.13
kernelspec:
display_name: Python 3 (ipykernel)
language: python
name: python3
learning:
objectives:
understand: [expression, "op\xE9ration", valeur, type, "expression bool\xE9enne",
syntaxe, "s\xE9mantique"]
apply: [expression, "op\xE9ration", type, "expression bool\xE9enne", condition,
"calcul arithm\xE9tique"]
---
+++ {"nbgrader": {"grade": false, "grade_id": "cell-b78562ee2ff6d72c", "locked": true, "schema_version": 3, "solution": false}}
# Valeurs et types
Dans cette feuille, nous allons utiliser Jupyter comme une calculatrice et introduire
quelques concepts sous-jacents : valeurs, opérations, expressions, types.
+++ {"nbgrader": {"grade": false, "grade_id": "cell-33660fa4ef5903e4", "locked": true, "schema_version": 3, "solution": false}}
## Expressions et premiers calculs
+++ {"nbgrader": {"grade": false, "grade_id": "cell-462bbcdd31ead4b6", "locked": true, "schema_version": 3, "solution": false, "task": false}}
1. Cliquez sur la cellule suivante puis exécutez-la en appuyant sur les touches
Maj+Entrée :
```{code-cell} ipython3
1 + 1
```
+++ {"nbgrader": {"grade": false, "grade_id": "cell-291a3535b726abef", "locked": true, "schema_version": 3, "solution": false}}
Techniquement parlant, votre navigateur web a envoyé le contenu de l'**expression** `1+1`
de la cellule à un {definiendum}`noyau` (*kernel* en anglais) qui l'a
{definiendum}`exécutée `, avant de renvoyer le résultat à afficher. Le noyau
que nous utilisons (`Python3`) permet de travailler en `Python`. Il existe des noyaux
pour beaucoup d'autres langages de programmation.
+++ {"nbgrader": {"grade": false, "grade_id": "cell-012883709b9945bd", "locked": true, "schema_version": 3, "solution": false, "task": false}}
%:::{admonition} Définition : Programmes
%{definiendum}`Programme ` : séquence d'instructions qui
%spécifie étape par étape les opérations à effectuer pour obtenir à
%partir des {definiendum}`entrées` un résultat (la
%{definiendum}`sortie`). Exemble : les séquences d'instructions que vous avez vues dans Laby.
%:::
(valeur)=
(operation)=
(expression)=
:::{admonition} Définition : Expressions, valeurs et opérations
Une {definiendum}`expression` est une combinaison de {definiendum}`valeurs ` par
des {definiendum}`opérations ` donnant une nouvelle valeur.
:::
:::{admonition} Exemple
L'expression `3 * (1 + 3) + (1 + 4) * (2 + 4)` vaut `42`.
:::
+++ {"nbgrader": {"grade": false, "grade_id": "cell-c9adf105ff60cbf6", "locked": true, "schema_version": 3, "solution": false, "task": false}}
1. Exécutez la cellule suivante pour calculer la valeur de l'expression :
```{code-cell} ipython3
3 * (1 + 3) + (1 + 4) * (2 + 4)
```
+++ {"nbgrader": {"grade": false, "grade_id": "cell-c7495bbedb1de8c7", "locked": true, "schema_version": 3, "solution": false}}
2. Modifiez l'expression dans la cellule précédente et exécutez-la de nouveau.
+++ {"nbgrader": {"grade": false, "grade_id": "cell-12b1679926b1768d", "locked": true, "schema_version": 3, "solution": false}}
3. Utilisez la cellule suivante pour calculer la surface d'un rectangle de largeur 25 et
de longueur 37 :
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-b645bc465bd310ae
locked: false
schema_version: 3
solution: true
ordo_failure: "R\xE9ponse incorrecte; essayes encore!"
ordo_solution:
text/plain: '925
type: int'
ordo_success: "Bonne r\xE9ponse!"
---
### BEGIN SOLUTION
25 * 37
### END SOLUTION
```
+++ {"nbgrader": {"grade": false, "grade_id": "cell-8718f64031792892", "locked": true, "schema_version": 3, "solution": false, "task": false}}
## Notion de type
+++ {"nbgrader": {"grade": false, "grade_id": "cell-68921a02a7525551", "locked": true, "schema_version": 3, "solution": false, "task": false}}
Une valeur peut représenter des données de natures très différentes, comme un nombre
entier, un nombre réel, un booléen, mais aussi un texte, un relevés de notes, une images,
une musique, etc.
(type)=
:::{admonition} Définition : Types
En Python, chaque {symref}`valeur` a un {definiendum}`type` qui décrit sa nature. Ce type
spécifie en outre :
- La **structure de données** : comment la valeur est représentée en mémoire.
- La **sémantique** des opérations.
:::
+++
Les types en programmation sont essentiels car ils permettent aux ordinateurs de
déterminer la nature des informations qu'ils doivent traiter, stocker ou manipuler. Ils
définissent les propriétés et les opérations possibles sur les données représentées, et
indiquent commment ces données sont stockées en mémoire.
Les types imposent des contraintes qui contribuent à renforcer l'exactitude des données.
De plus, les types sont utiles aux développeurs pour raisonner sur la structure des
logiciels.
+++ {"nbgrader": {"grade": false, "grade_id": "cell-8eeb079c99a4c501", "locked": true, "schema_version": 3, "solution": false, "task": false}}
(types_de_base)=
:::{admonition} Définition : Types de base
Les types de base en Python sont :
(entier)=
- Les {definiendum}`entiers ` (type `int` pour *integer*)\
Exemples : 1, 42, -32765
(reel)=
- les {definiendum}`réels ` (type `float`)\
Exemples : 10.43, 1.0324432e22
(str)=
(chaine_de_caracteres)=
- les {definiendum}`chaînes de caractères ` (type `str` pour
*string*), entre guillemets ou apostrophes :\
Exemples : "bonjour", 'Alice aime Bob'
(booleen)=
- les {definiendum}`booléens ` (type `bool` pour *boolean*)\
Exemples : `True` (vrai), `False` (faux)
(type_ordinal)=
Les entiers, les caractères et les booléens forment les
{definiendum}`types ordinaux `.
:::
+++ {"nbgrader": {"grade": false, "grade_id": "cell-d96e1f5d4db028d3", "locked": true, "schema_version": 3, "solution": false, "task": false}}
:::{admonition} Exemple
La fonction `type` permet d'obtenir le type d'une valeur, comme dans les exemples
suivants :
:::
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-50d19cc1e41bfd8b
locked: true
schema_version: 3
solution: false
task: false
---
type("Jean")
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-16f278ec4addfeae
locked: true
schema_version: 3
solution: false
task: false
---
type(23)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-af37d7d3bd4a2090
locked: true
schema_version: 3
solution: false
task: false
---
type(1.70)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-16f278ec4addfeaf
locked: true
schema_version: 3
solution: false
task: false
---
type(23.)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-6ba3fe233acf76a3
locked: true
schema_version: 3
solution: false
task: false
---
type(True)
```
+++ {"nbgrader": {"grade": false, "grade_id": "cell-cc1e913f78a495b0", "locked": true, "schema_version": 3, "solution": false, "task": false}}
(operations_sur_les_entiers)=
:::{admonition} Opérations arithmétiques sur les entiers
| Opération | Exemple | Résultat |
| ---------------------------- | -------- | -------- |
| opposé | `-(-5)` | 5 |
| addition | `17 + 5` | 22 |
| soustraction | `17 - 5` | 12 |
| multiplication | `17 * 5` | 85 |
| puissance | `2 ** 3` | 8 |
| division entière | `17 / 5` | 3 |
| reste de la division entière | `17 % 5` | 2 |
:::
+++ {"nbgrader": {"grade": false, "grade_id": "cell-7c72028bf998c9e5", "locked": true, "schema_version": 3, "solution": false}}
:::{admonition} Exercice
Les cellules suivantes vous présentent des exemples de calculs. Exécutez-les en observant
bien la valeur du résultat ainsi que son type.
:::
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-678ae0462813d831
locked: true
schema_version: 3
solution: false
task: false
---
3 * (1 + 3) + (1 + 4) * (2 + 4)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-74a041c9c4f126bc
locked: true
schema_version: 3
solution: false
task: false
---
type(3 * (1 + 3) + (1 + 4) * (2 + 4))
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-8c8f01689a82794b
locked: true
schema_version: 3
solution: false
task: false
---
42 / 2
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-93d3bedeff441b84
locked: true
schema_version: 3
solution: false
task: false
---
type(42 / 2)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-9678ffe15c270b81
locked: true
schema_version: 3
solution: false
task: false
---
42 / 5
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-8dae6fe1fc7dc3b1
locked: true
schema_version: 3
solution: false
task: false
---
type(42 / 5)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-15172444994cbdff
locked: true
schema_version: 3
solution: false
task: false
---
42. / 5
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-9c9a7d84ece52432
locked: true
schema_version: 3
solution: false
task: false
---
type(42. / 5)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-7009aedea5b1e925
locked: true
schema_version: 3
solution: false
task: false
---
42 % 5
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-37d3a63933e17b31
locked: true
schema_version: 3
solution: false
task: false
---
type(42 % 5)
```
+++ {"nbgrader": {"grade": false, "grade_id": "cell-bfff9da761d923d4", "locked": true, "schema_version": 3, "solution": false, "task": false}}
:::{tip} Note
Pour éviter de fausses manœuvres, nous configurons de nombreuses cellules, telles celles
ci-dessous, pour qu'elles soient non modifiables. Pour faire vos propres expérimentations
ou pour prendre des notes personnelles, vous pouvez à tout moment insérer de nouvelles
cellules. Insérez maintenant une cellule ci-dessous en utilisant le bouton `+` sous les
onglets. Dans la barre d'outil de cette feuille, sélectionnez `Markdown` à la place de
`Code` pour en faire une cellule de texte.
:::
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-7c66e2817d57b95c
locked: true
schema_version: 3
solution: false
task: false
---
1 + 1.
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-3392575409dafcda
locked: true
schema_version: 3
solution: false
task: false
---
type(1 + 1.)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-33bc66dde9266641
locked: true
schema_version: 3
solution: false
task: false
---
42 == 6*7
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-c7cea4fa9d1d8f0e
locked: true
schema_version: 3
solution: false
task: false
---
type(42 == 6*7)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-3163364eab44d8d7
locked: true
schema_version: 3
solution: false
task: false
---
41 == 2*21
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-39365a288110d1a7
locked: true
schema_version: 3
solution: false
task: false
---
type(41 == 2*21)
```
+++ {"nbgrader": {"grade": false, "grade_id": "cell-9b674af1d7f2a56f", "locked": true, "schema_version": 3, "solution": false, "task": false}}
## Expressions booléennes
:::{admonition} Remarque
Dans les dernières cellules précédentes, nous avons **testé** l'égalité entre deux
valeurs. Le résultat était selon le cas «vrai» ou «faux», donc de type `bool`. C'est un
exemple d'{symref}`expression booléenne`.
Notez l'utilisation d'un **double égal** `==` pour le test d'égalité. Nous verrons
bientôt la signification en Python du **simple égal** `=`.
:::
+++ {"nbgrader": {"grade": false, "grade_id": "cell-6d282bf8cd4c3d6c", "locked": true, "schema_version": 3, "solution": false, "task": false}}
(expression_booleenne)=
:::{admonition} Définition : Expressions booléennes (conditions)
Une {definiendum}`expression booléenne` est une {symref}`expression` dont la valeur est
«vrai» ou «faux» (type : {symref}`bool`).
(condition)=
Une {symref}`expression booléenne` est aussi appelée une {definiendum}`condition`.
:::
+++
**Exemples :**
```{code-cell} ipython3
True
```
```{code-cell} ipython3
False
```
- `regarde() == Vide`
- `x > 3.14`
- `2 <= n and n <= 5`
+++
(operations_booleennes_usuelles)=
:::{admonition} Opérations booléennes usuelles
| Opération | Exemple | Résultat |
| ------------------- | :---------------: | -------- |
| comparaison | `3 <= 5` | `True` |
| comparaison stricte | `3 < 5` | `True` |
| comparaison stricte | `3 > 5` | `False` |
| égalité | `3 == 5` | `False` |
| inégalité | `3 != 5` | `True` |
| négation logique | `not 3 <= 5` | `False` |
| et | `3 < 5 and 3 > 5` | `False` |
| ou inclusif | `3 < 5 or 3 > 5` | `True` |
:::
% TODO: donner les détails de l'évaluation paresseuse en «pour aller
% plus loin»
% :::{tip} Rappel : les opérateurs booléens.
% :class: dropdown
%
% Un test doit avoir une valeur booléenne. Cette valeur peut être le
% résultat :
%
% D'une comparaison arithmétique entre deux valeurs numériques `a` et `b` :
% - l'égalité dont la syntaxe en Python est `a == b`
% - la différence dont la syntaxe en Python est `a != b`
% - l'inégalité dont la syntaxe en Python est `a < b` ou `a > b` ou `a <= b` ou `a >= b`
%
%
% D'une opération logique entre deux valeurs booléennes `x` ou `y` :
% - la négation logique dont dont la syntaxe en Python est `not
% x`. Evalué à la valeur booléenne opposée de X.
% - le «ou inclusif» dont la syntaxe en Python est `x or y`. Si X est
% évalué à True, alors l'expression est True et Y n'est pas
% évalué. Sinon, l'expression est évaluée à la valeur booléenne de Y.
% - le «et» dont la syntaxe en Python est `x and y`. Si X est évalué à
% False, alors l'expression est False et Y n'est pas évalué. Sinon,
% l'expression est évaluée à la valeur booléenne de Y.
%
%
% :::
+++
:::{admonition} Exercice
Pour chacune des cellules suivantes, déterminez **de tête** la valeur de l'expression
booléenne, puis vérifiez la en exécutant la cellule.
:::
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-d4b738450011dd37
locked: true
schema_version: 3
solution: false
task: false
---
1 < 2
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-3e5e3a25f145a973
locked: true
schema_version: 3
solution: false
task: false
---
2 > 3
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-606159825dc54bf9
locked: true
schema_version: 3
solution: false
task: false
---
1 < 2 and 2 > 3
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-783a55b0abd2377f
locked: true
schema_version: 3
solution: false
task: false
---
1 < 2 or 2 > 3
```
+++ {"nbgrader": {"grade": false, "grade_id": "cell-884721498ad284a1", "locked": true, "schema_version": 3, "solution": false}}
## Entraînement
:::{admonition} Exercice
Pour chacune des expressions suivantes, déterminez **de tête** le type et la valeur du
résultat, et donnez votre réponse à l'endroit indiqué dans la cellule de texte sous la
forme `type`, `valeur`; puis vérifiez en exécutant les cellules.
:::
+++ {"nbgrader": {"grade": true, "grade_id": "cell-a8d152d15809265f", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
1. Type : int, bool, ou float ? Valeur : 7, 9, 11, ou 21 ?
BEGIN SOLUTION
int, 11
END SOLUTION
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-0f3ff9e9e4c33f41
locked: true
schema_version: 3
solution: false
---
3 * 2 + 5
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-964203c8c7010bbb
locked: true
schema_version: 3
solution: false
task: false
---
type(3 * 2 + 5)
```
+++ {"nbgrader": {"grade": true, "grade_id": "cell-b866905e681f44cb", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
2. Type : int, bool, ou float ? Valeur : 12 ou 12.5 ?
BEGIN SOLUTION
int, 12
END SOLUTION
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-127febc577edfc08
locked: true
schema_version: 3
solution: false
---
25 / 2
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-29a4053669cdb7b7
locked: true
schema_version: 3
solution: false
task: false
---
type(25 / 2)
```
+++ {"nbgrader": {"grade": true, "grade_id": "cell-899fabbcd7ecd371", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
3. Type : int, bool, ou float ? Valeur : 6, 7, 6.0000, ou 7.0000?
BEGIN SOLUTION
int, 7.0000
END SOLUTION
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-286c54ae7e34701d
locked: true
schema_version: 3
solution: false
---
3.5*2
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-c5203f9cc3b222df
locked: true
schema_version: 3
solution: false
task: false
---
type(3.5*2)
```
+++ {"nbgrader": {"grade": true, "grade_id": "cell-fe0c64ef514d2b0f", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
4. Type: int, bool, ou float ? Valeur : 5, 4, ou 4.66667 ?
BEGIN SOLUTION
double, 4.66667
END SOLUTION
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-b52c330c011b1b89
locked: true
schema_version: 3
solution: false
task: false
---
14. / 3
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-64da8ca9ecdc5a81
locked: true
schema_version: 3
solution: false
task: false
---
type(14. / 3)
```
+++ {"nbgrader": {"grade": true, "grade_id": "cell-b1b2d0d4b7baa06e", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
5. Type : int, bool, ou float ? Valeur : 3,7,21, true, ou false ?
BEGIN SOLUTION
bool, true
END SOLUTION
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-67ced375854c7fb3
locked: true
schema_version: 3
solution: false
task: false
---
3*7 == 21
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-d5f4fb413b02fdae
locked: true
schema_version: 3
solution: false
task: false
---
type(3*7 == 21)
```
+++ {"nbgrader": {"grade": true, "grade_id": "cell-59ff90739ae5b7b2", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
6. Type : int, bool, double ? Valeur : 21, 25, true, false ?
BEGIN SOLUTION
bool, true
END SOLUTION
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-959d3023456a140e
locked: true
schema_version: 3
solution: false
task: false
---
(3*7 == 21) and (4.2 > 5.3 or 4*4 == 8*2)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-33a414e5efa6381f
locked: true
schema_version: 3
solution: false
task: false
---
type((3*7 == 21) and (4.2 > 5.3 or 4*4 == 8*2))
```
+++ {"nbgrader": {"grade": true, "grade_id": "cell-2bf659cbac5d597a", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
7. Type : int, bool, double ? Valeur : 1, 0, true, false ?
BEGIN SOLUTION
bool, false
END SOLUTION
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-f47f3ad36d564ee3
locked: true
schema_version: 3
solution: false
task: false
---
True and False
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-88f42bb44d2cb920
locked: true
schema_version: 3
solution: false
task: false
---
type(True and False)
```
+++ {"nbgrader": {"grade": true, "grade_id": "cell-e5856c338c095691", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
8. Type : int, bool, double ? Valeur : 1, 0, True, False ?
BEGIN SOLUTION
bool, false
END SOLUTION
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-e0555c4a9b71b38e
locked: true
schema_version: 3
solution: false
task: false
---
True or False
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-d2561734ab18e064
locked: true
schema_version: 3
solution: false
task: false
---
type(True or False)
```
+++ {"nbgrader": {"grade": true, "grade_id": "cell-89f6e927581416a9", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
9. Type : int, bool, double ? Valeur : 1, 0, true, false ?
BEGIN SOLUTION
bool, True
END SOLUTION
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-b578732ac62c6681
locked: true
schema_version: 3
solution: false
task: false
---
(False and False) or True
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-8c42d5b0abb1780a
locked: true
schema_version: 3
solution: false
task: false
---
type((False and False) or True)
```
+++ {"nbgrader": {"grade": true, "grade_id": "cell-447af0863372964d", "locked": false, "points": 2, "schema_version": 3, "solution": true}}
10. Type : int, bool, double ? Valeur : 1, 0, True, False ?
BEGIN SOLUTION
bool, False
END SOLUTION
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-64d5df8a0de7fed9
locked: true
schema_version: 3
solution: false
task: false
---
False and (False or True)
```
```{code-cell} ipython3
---
nbgrader:
grade: false
grade_id: cell-feeed5b64dd10bf4
locked: true
schema_version: 3
solution: false
task: false
---
type(False and (False or True))
```
+++ {"nbgrader": {"grade": false, "grade_id": "cell-6e834cd22ecc144b", "locked": true, "schema_version": 3, "solution": false}}
## Conclusion
Bravo, vous avez terminé cette première feuille où nous avons exploré les
[expressions](#expression), [opérations](#operation), [valeurs](#valeur) et
[types](#type). Nous avons également vu les [types de base](#types_de_base) : int,
string, etc.
Nous avons notamment vu que Python détermine le type d'une valeur littérale en fonction
de sa **syntaxe**; ainsi `42` est de type entier (`int`), tandis que `42.` ou `42.0` est
de type réel (`float`). Nous avons aussi vu que le type d'une valeur détermine la
**sémantique** des opérations que l'on applique dessus : ainsi `17 / 5` calcule la
division euclidienne des deux entiers, tandis que `17. / 5` calcule leur division comme
nombres réels.
::::{admonition} Aparté : *syntaxe*, *sémantique* et *algorithme*
:class: hint
Ces trois notions – syntaxe, sémantique et algorithme – sont essentielles pour bien
spécifier et comprendre le comportement d'un programme. Elles permettent d'exprimer
précisément comment un programme doit être écrit, ce qu'il est censé accomplir et de
quelle manière il atteint son objectif. En maîtrisant ces concepts, on peut écrire du
code plus correct, compréhensible et maintenable, ce qui est fondamental pour tout
développement informatique.
(syntaxe_informel)=
- {definiendum}`Syntaxe` : comment cela s'écrit
(semantique_informel)=
- {definiendum}`Sémantique` : ce que cela fait
(algorithme_informel)=
- {definiendum}`Algorithme` : comment c'est fait
:::{admonition} Exemple
- Syntaxe : 17 / 5
- Sémantique : calcule la division entière de 17 par 5
- Algorithme : division euclidienne
:::
::::
Dans la feuille suivante, vous aborderez quelques fonctions mathématiques préexistantes
en python.