{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les fonctions en Python — Première NSI\n",
    "\n",
    "## Objectifs de la séance\n",
    "- Comprendre ce qu'est une fonction et à quoi elle sert\n",
    "- Savoir écrire (définir) une fonction en Python\n",
    "- Comprendre la différence entre une fonction avec `return` et une fonction sans `return`\n",
    "- Savoir appeler une fonction\n",
    "- Être capable de transformer un programme existant en fonction\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Qu'est-ce qu'une fonction ?\n",
    "\n",
    "Une **fonction** est un bloc d'instructions regroupées sous un nom, que l'on peut réutiliser autant de fois que l'on veut, sans avoir à réécrire le code à chaque fois.\n",
    "\n",
    "On peut comparer une fonction à une **machine** : on lui donne une ou plusieurs entrées (les **paramètres**), elle effectue un traitement, et elle peut renvoyer un résultat (la **valeur de retour**).\n",
    "\n",
    "Utiliser des fonctions permet de :\n",
    "- éviter de dupliquer du code (on écrit une fois, on utilise partout) ;\n",
    "- rendre un programme plus lisible et mieux organisé ;\n",
    "- faciliter les corrections (une seule modification suffit).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Comment écrire (définir) une fonction en Python ?\n",
    "\n",
    "La syntaxe générale est la suivante :\n",
    "\n",
    "```python\n",
    "def nom_de_la_fonction(parametre1, parametre2):\n",
    "    # instructions de la fonction\n",
    "    return resultat\n",
    "```\n",
    "\n",
    "- `def` est le mot-clé qui annonce la définition d'une fonction ;\n",
    "- `nom_de_la_fonction` doit être explicite et suivre les mêmes règles que les noms de variables ;\n",
    "- entre parenthèses, on trouve les **paramètres** (les données que la fonction reçoit) — une fonction peut n'avoir aucun paramètre ;\n",
    "- le corps de la fonction est **indenté** (4 espaces) ;\n",
    "- `return` permet de renvoyer un résultat, mais une fonction n'est **pas obligée** d'en avoir un (voir partie 3).\n",
    "\n",
    "⚠️ Définir une fonction ne l'exécute pas ! Il faut ensuite l'**appeler** pour qu'elle s'exécute (voir partie 5).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exemple : une fonction sans paramètre et sans valeur de retour\n",
    "def dire_bonjour():\n",
    "    print(\"Bonjour tout le monde !\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Fonctions avec `return` et fonctions sans `return`\n",
    "\n",
    "On distingue deux grandes familles de fonctions :\n",
    "\n",
    "- **Les fonctions sans `return`** : elles effectuent une action (par exemple afficher quelque chose avec `print`) mais ne renvoient pas de résultat utilisable ensuite dans le programme. Si on essaie tout de même de récupérer leur résultat, Python renvoie la valeur spéciale `None`.\n",
    "- **Les fonctions avec `return`** : elles calculent une valeur et la **renvoient** à l'endroit où la fonction a été appelée. Ce résultat peut alors être stocké dans une variable, réutilisé dans un calcul, transmis à une autre fonction, etc.\n",
    "\n",
    "Comparons les deux sur un même exemple : le carré d'un nombre.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def afficher_carre(nombre):\n",
    "    \"\"\"Affiche le carré de nombre, mais ne renvoie rien.\"\"\"\n",
    "    print(nombre ** 2)\n",
    "\n",
    "def calculer_carre(nombre):\n",
    "    \"\"\"Renvoie le carré de nombre.\"\"\"\n",
    "    return nombre ** 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Différence à l'usage :\n",
    "afficher_carre(5)              # affiche 25, mais ce résultat n'est pas récupérable\n",
    "\n",
    "resultat = calculer_carre(5)   # le résultat est stocké dans une variable\n",
    "print(resultat * 2)            # on peut le réutiliser dans un calcul\n",
    "\n",
    "# Que se passe-t-il si on essaie de récupérer le résultat d'une fonction sans return ?\n",
    "valeur = afficher_carre(5)\n",
    "print(valeur)                  # affiche 25 (à cause du print dans la fonction), puis None\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "👉 **À retenir** : si le résultat d'une fonction doit être réutilisé plus loin dans le programme (dans un calcul, une comparaison, une autre fonction...), elle doit obligatoirement utiliser `return`. Si son seul but est d'afficher une information à l'écran, `print` suffit et `return` n'est pas nécessaire.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Exemples de fonctions déjà écrites\n",
    "\n",
    "Voici plusieurs exemples de fonctions avec paramètres et valeur de retour. Exécute chaque cellule pour les définir (tu ne verras rien s'afficher : c'est normal, on ne fait que les *définir* pour l'instant).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def perimetre_carre(cote):\n",
    "    \"\"\"Renvoie le périmètre d'un carré de côté 'cote'.\"\"\"\n",
    "    return 4 * cote\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def est_pair(nombre):\n",
    "    \"\"\"Renvoie True si 'nombre' est pair, False sinon.\"\"\"\n",
    "    return nombre % 2 == 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def maximum(a, b):\n",
    "    \"\"\"Renvoie le plus grand des deux nombres a et b.\"\"\"\n",
    "    if a > b:\n",
    "        return a\n",
    "    else:\n",
    "        return b\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Comment appeler une fonction ?\n",
    "\n",
    "Pour utiliser (exécuter) une fonction, on écrit son nom suivi de parenthèses contenant les **arguments** (les valeurs données aux paramètres).\n",
    "\n",
    "Si la fonction renvoie un résultat avec `return`, on peut :\n",
    "- l'afficher directement avec `print(...)` ;\n",
    "- ou le stocker dans une variable pour l'utiliser plus tard.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On appelle les fonctions définies précédemment\n",
    "dire_bonjour()\n",
    "\n",
    "print(perimetre_carre(5))\n",
    "\n",
    "resultat = est_pair(7)\n",
    "print(resultat)\n",
    "\n",
    "print(maximum(12, 8))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "⚠️ **Remarques importantes**\n",
    "- Une fonction doit être **définie avant** d'être appelée (Python lit le code de haut en bas).\n",
    "- Le nombre d'arguments donnés lors de l'appel doit correspondre au nombre de paramètres de la fonction.\n",
    "- Une variable créée à l'intérieur d'une fonction (variable **locale**) n'existe pas en dehors de celle-ci.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Exercices — Transformer un code en fonction\n",
    "\n",
    "Pour chaque exercice, un programme est donné : il fonctionne, mais uniquement pour des valeurs fixées à l'avance. Ton travail consiste à **transformer ce code en une fonction**, afin de pouvoir le réutiliser facilement avec n'importe quelles valeurs.\n",
    "\n",
    "Pour chaque exercice :\n",
    "1. Regarde le code de départ (il n'est pas à modifier, juste à comprendre).\n",
    "2. Écris une fonction qui fait le même travail, avec un ou plusieurs paramètres.\n",
    "3. Réfléchis si ta fonction doit utiliser `return` ou non.\n",
    "4. Teste ta fonction avec plusieurs valeurs différentes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 1 — Conversion Celsius vers Fahrenheit\n",
    "\n",
    "Voici un code qui convertit une température de 20°C en degrés Fahrenheit :\n",
    "\n",
    "```python\n",
    "temperature_celsius = 20\n",
    "temperature_fahrenheit = temperature_celsius * 9/5 + 32\n",
    "print(temperature_fahrenheit)\n",
    "```\n",
    "\n",
    "Écris une fonction `celsius_vers_fahrenheit(celsius)` qui **renvoie** la température en Fahrenheit, puis teste-la avec plusieurs valeurs (par exemple 0, 20, 37, 100).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écris ta fonction ici\n",
    "\n",
    "\n",
    "# Teste-la ensuite avec plusieurs valeurs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2 — Aire d'un rectangle\n",
    "\n",
    "```python\n",
    "longueur = 6\n",
    "largeur = 4\n",
    "aire = longueur * largeur\n",
    "print(aire)\n",
    "```\n",
    "\n",
    "Écris une fonction `aire_rectangle(longueur, largeur)` qui **renvoie** l'aire du rectangle, puis teste-la avec plusieurs couples de valeurs.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écris ta fonction ici\n",
    "\n",
    "\n",
    "# Teste-la ensuite avec plusieurs valeurs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 3 — Multiple de 3\n",
    "\n",
    "```python\n",
    "nombre = 15\n",
    "if nombre % 3 == 0:\n",
    "    print(\"multiple de 3\")\n",
    "else:\n",
    "    print(\"pas multiple de 3\")\n",
    "```\n",
    "\n",
    "Écris une fonction `est_multiple_de_3(nombre)` qui **renvoie** `True` si le nombre est multiple de 3, et `False` sinon (pas de `print` à l'intérieur de la fonction). Teste-la avec plusieurs valeurs.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écris ta fonction ici\n",
    "\n",
    "\n",
    "# Teste-la ensuite avec plusieurs valeurs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 4 — Moyenne de trois notes\n",
    "\n",
    "```python\n",
    "note1 = 12\n",
    "note2 = 15\n",
    "note3 = 9\n",
    "moyenne = (note1 + note2 + note3) / 3\n",
    "print(moyenne)\n",
    "```\n",
    "\n",
    "Écris une fonction `moyenne_trois_notes(n1, n2, n3)` qui **renvoie** la moyenne des trois notes, puis teste-la.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écris ta fonction ici\n",
    "\n",
    "\n",
    "# Teste-la ensuite avec plusieurs valeurs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 5 — Somme des nombres de 1 à n\n",
    "\n",
    "```python\n",
    "n = 10\n",
    "somme = 0\n",
    "for i in range(1, n + 1):\n",
    "    somme += i\n",
    "print(somme)\n",
    "```\n",
    "\n",
    "Écris une fonction `somme_n(n)` qui **renvoie** la somme des entiers de 1 à `n`, puis teste-la avec plusieurs valeurs de `n`.\n",
    "\n",
    "💡 Cette fonction doit-elle utiliser `return` ou non ? Pourquoi ?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écris ta fonction ici\n",
    "\n",
    "\n",
    "# Teste-la ensuite avec plusieurs valeurs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 6 — Afficher les diviseurs d'un entier\n",
    "\n",
    "```python\n",
    "n = 12\n",
    "for i in range(1, n + 1):\n",
    "    if n % i == 0:\n",
    "        print(i)\n",
    "```\n",
    "\n",
    "Écris une fonction `afficher_diviseurs(n)` qui **affiche** (avec `print`) tous les diviseurs de `n`, puis teste-la avec plusieurs valeurs de `n`.\n",
    "\n",
    "💡 Cette fonction doit-elle utiliser `return` ou non ? Pourquoi ?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écris ta fonction ici\n",
    "\n",
    "\n",
    "# Teste-la ensuite avec plusieurs valeurs\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}