---
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: [fonction, appel de fonction, type]
  prerequisites:
    apply: [expression, "op\xE9ration"]
---

+++ {"nbgrader": {"grade": false, "grade_id": "cell-de476e0d8337c0db", "locked": true, "schema_version": 3, "solution": false}}

# Fonctions mathématiques

% TODO:
% - paragraphe d'introduction
% - faire le lien avec les exercices Laby; notamment au moment où on parle de modularité
% - plus d'exercices d'entraînement; dont avec Laby?
% - le laius sur la modularité est possiblement redondant avec le cours sur les fonctions

+++ {"nbgrader": {"grade": false, "grade_id": "cell-4963f1ad5a9b8904", "locked": true, "schema_version": 3, "solution": false, "task": false}}

Dans la feuille précédente, nous avons vu des opérations arithmétiques ; on peut utiliser
des fonctions mathématiques plus complexes préexistantes en python.

Pour y avoir accès, on commence par importer le module `math` : il s'agit d'un fichier
Python qui contient du code réutilisable, nous y reviendrons par la suite.

```{code-cell} ipython3
import math
```

Voici quelques exemples d'appels de fonctions, que vous pouvez tester en modifiant les
valeurs entre parenthèses.

La fonction racine carrée :

```{code-cell} ipython3
math.sqrt(4)
```

La fonction exponentielle :

```{code-cell} ipython3
math.exp(2)
```

Les fonctions trigonométriques (en radians) :

```{code-cell} ipython3
math.sin(3.14)
```

```{code-cell} ipython3
math.cos(0)
```

La fonction puissance, on note que l'ordre des valeurs entre parenthèses a de
l'importance :

```{code-cell} ipython3
math.pow(5, 2)
```

```{code-cell} ipython3
math.pow(2, 5)
```

La fonction factorielle, qui ne fonctionne que lorsqu'on lui donne un entier :

```{code-cell} ipython3
math.factorial(3)
```

+++ {"nbgrader": {"grade": false, "grade_id": "cell-651b9f10ca7797ab", "locked": true, "schema_version": 3, "solution": false, "task": false}}

## Conclusion

+++ {"nbgrader": {"grade": false, "grade_id": "cell-651b9f10ca7797ac", "locked": true, "schema_version": 3, "solution": false, "task": false}}

On remarque plusieurs choses importantes :

- La présence de `import math` au début : c’est nécessaire pour utiliser le module des
  fonctions mathématiques préexistantes.

- Ces fonctions (comme `math.cos`, `math.sqrt`, `math.pow`, etc.) sont déjà programmées :
  on sait ce qu’elles calculent, mais pas comment elles le font. Et c’est normal : on n’a
  pas besoin de savoir comment elles sont implémentées pour les utiliser efficacement !

- Il faut faire attention à l’ordre des valeurs entre les parenthèses : par exemple dans
  `math.pow(x, y)`, on calcule `x` puissance `y`...

- ...et aussi au type de ces valeurs : certaines fonctions exigent un nombre flottant
  (float) ou un entier (int), et le bon type est important pour éviter des erreurs.

Nous verrons par la suite comment écrire nos propres fonctions.