{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Révisions python - écrire ses programmes (1)"
   ],
   "id": "e6979a61"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tests et fonctions"
   ],
   "id": "0067569f"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 1\n",
    "\n",
    "Écrire une fonction `est_pair(n)` qui renvoie `True` si l'entier `n` est pair,\n",
    "`False` sinon.\n",
    "\n",
    "```python\n",
    "est_pair(4)  # renvoie True\n",
    "est_pair(7)  # renvoie False\n",
    "```"
   ],
   "id": "61529d7c"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "42e82cf0"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert est_pair(4) == True\n",
    "assert est_pair(7) == False\n",
    "assert est_pair(0) == True\n",
    "assert est_pair(-3) == False\n",
    "print(\"Tests OK\")"
   ],
   "id": "693ec110"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 2\n",
    "\n",
    "Écrire une fonction `mention(note)` qui renvoie `\"TB\"` (16 et plus), `\"B\"` (14\n",
    "et plus), `\"AB\"` (12 et plus), `\"passable\"` (10 et plus) ou `\"recalé\"`.\n",
    "\n",
    "```python\n",
    "mention(15)   # renvoie 'B'\n",
    "mention(9.5)  # renvoie 'recalé'\n",
    "```"
   ],
   "id": "863a4e1c"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "a22a0859"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert mention(18) == \"TB\"\n",
    "assert mention(16) == \"TB\"\n",
    "assert mention(15) == \"B\"\n",
    "assert mention(12) == \"AB\"\n",
    "assert mention(10) == \"passable\"\n",
    "assert mention(9.5) == \"recalé\"\n",
    "print(\"Tests OK\")"
   ],
   "id": "62a0629c"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 3\n",
    "\n",
    "Écrire une fonction `prix_billet(age, etudiant=False)` qui renvoie le prix d'un\n",
    "billet de cinéma :\n",
    "\n",
    "- moins de 12 ans : 5 €\n",
    "- étudiant, ou 65 ans et plus : 8 €\n",
    "- sinon : 12 €\n",
    "\n",
    "```python\n",
    "prix_billet(30)                     # renvoie 12\n",
    "prix_billet(20, True)               # renvoie 8\n",
    "prix_billet(etudiant=True, age=10)  # renvoie 5\n",
    "```"
   ],
   "id": "c6b40f9c"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "a9cf881d"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert prix_billet(30) == 12\n",
    "assert prix_billet(20, True) == 8\n",
    "assert prix_billet(70) == 8\n",
    "assert prix_billet(8) == 5\n",
    "assert prix_billet(etudiant=True, age=10) == 5\n",
    "print(\"Tests OK\")"
   ],
   "id": "41e7177b"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boucles `while`"
   ],
   "id": "47328553"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 4\n",
    "\n",
    "Écrire une fonction `somme_jusqu_a(n)` qui renvoie $1 + 2 + ... + n$, avec une\n",
    "boucle `while`.\n",
    "\n",
    "```python\n",
    "somme_jusqu_a(4)  # renvoie 10\n",
    "```"
   ],
   "id": "4478d8e5"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "8e71c395"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert somme_jusqu_a(4) == 10\n",
    "assert somme_jusqu_a(1) == 1\n",
    "assert somme_jusqu_a(0) == 0\n",
    "assert somme_jusqu_a(100) == 5050\n",
    "print(\"Tests OK\")"
   ],
   "id": "9ff0183c"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 5\n",
    "\n",
    "Écrire une fonction `nb_chiffres(n)` qui renvoie le nombre de chiffres de\n",
    "l'entier positif `n`, sans le convertir en chaîne.\n",
    "\n",
    "Indice : `n // 10` enlève le dernier chiffre.\n",
    "\n",
    "```python\n",
    "nb_chiffres(2026)  # renvoie 4\n",
    "nb_chiffres(7)     # renvoie 1\n",
    "```"
   ],
   "id": "2a1a12d3"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "1ebfb795"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert nb_chiffres(2026) == 4\n",
    "assert nb_chiffres(7) == 1\n",
    "assert nb_chiffres(0) == 1\n",
    "assert nb_chiffres(10) == 2\n",
    "assert nb_chiffres(99999) == 5\n",
    "print(\"Tests OK\")"
   ],
   "id": "0e27605e"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 6\n",
    "\n",
    "Écrire une fonction `premier_depassement(t, seuil)` qui renvoie l'**indice** du\n",
    "premier élément de `t` strictement supérieur à `seuil`, ou `None` s'il n'y en a\n",
    "pas. Utiliser une boucle `while`, qui s'arrête dès qu'on a trouvé.\n",
    "\n",
    "```python\n",
    "premier_depassement([3, 8, 12, 20], 10)  # renvoie 2\n",
    "premier_depassement([3, 8], 10)          # renvoie None\n",
    "```"
   ],
   "id": "7ad2dbf3"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "0d08f305"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert premier_depassement([3, 8, 12, 20], 10) == 2\n",
    "assert premier_depassement([15, 8], 10) == 0\n",
    "assert premier_depassement([3, 8], 10) == None\n",
    "assert premier_depassement([], 10) == None\n",
    "print(\"Tests OK\")"
   ],
   "id": "cbdf004c"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boucles `for` et listes"
   ],
   "id": "162ab60d"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 7\n",
    "\n",
    "Écrire une fonction `compte(t, x)` qui renvoie le nombre de fois où `x` apparaît\n",
    "dans la liste `t` (sans utiliser `t.count`).\n",
    "\n",
    "```python\n",
    "compte([1, 3, 1, 2, 1], 1)  # renvoie 3\n",
    "```"
   ],
   "id": "f2f4b607"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "c7a3cd0f"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert compte([1, 3, 1, 2, 1], 1) == 3\n",
    "assert compte([1, 3, 1, 2, 1], 5) == 0\n",
    "assert compte([], 1) == 0\n",
    "assert compte([\"a\", \"b\", \"a\"], \"a\") == 2\n",
    "print(\"Tests OK\")"
   ],
   "id": "0c69af2d"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 8\n",
    "\n",
    "Écrire une fonction `moyenne(notes)` qui renvoie la moyenne des nombres de la\n",
    "liste `notes` (sans `sum`), ou `None` si la liste est vide.\n",
    "\n",
    "```python\n",
    "moyenne([12, 8, 16])  # renvoie 12.0\n",
    "moyenne([])           # renvoie None\n",
    "```"
   ],
   "id": "42f401a5"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "35f8856f"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert moyenne([12, 8, 16]) == 12.0\n",
    "assert moyenne([15]) == 15\n",
    "assert moyenne([10, 11]) == 10.5\n",
    "assert moyenne([]) == None\n",
    "print(\"Tests OK\")"
   ],
   "id": "bbfd992e"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 9\n",
    "\n",
    "Écrire une fonction `pairs(t)` qui renvoie une **nouvelle** liste contenant\n",
    "uniquement les nombres pairs de `t`, dans le même ordre.\n",
    "\n",
    "```python\n",
    "pairs([1, 4, 7, 8, 10])  # renvoie [4, 8, 10]\n",
    "```"
   ],
   "id": "8a007ade"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "7d818084"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "t = [1, 4, 7, 8, 10]\n",
    "assert pairs(t) == [4, 8, 10]\n",
    "assert t == [1, 4, 7, 8, 10]  # t n'a pas été modifiée\n",
    "assert pairs([1, 3]) == []\n",
    "assert pairs([]) == []\n",
    "print(\"Tests OK\")"
   ],
   "id": "2f62caf8"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 10\n",
    "\n",
    "Écrire une fonction `position_max(t)` qui renvoie le couple `(maximum, indice)`\n",
    "du plus grand élément de la liste **non vide** `t`. En cas d'égalité, on garde\n",
    "le premier. Utiliser `enumerate`.\n",
    "\n",
    "```python\n",
    "position_max([1, 5, 6, 9, 1, 9])  # renvoie (9, 3)\n",
    "```"
   ],
   "id": "b32eeeda"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "b4a556a1"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert position_max([1, 5, 6, 9, 1, 9]) == (9, 3)\n",
    "assert position_max([7]) == (7, 0)\n",
    "assert position_max([-4, -2, -8]) == (-2, 1)\n",
    "print(\"Tests OK\")"
   ],
   "id": "fee10a74"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 11\n",
    "\n",
    "Écrire une fonction `compte_voyelles(texte)` qui renvoie le nombre de voyelles\n",
    "(`aeiouy`) de la chaîne `texte`, écrite en minuscules.\n",
    "\n",
    "Rappel : on peut parcourir une chaîne avec `for`, comme une liste.\n",
    "\n",
    "```python\n",
    "compte_voyelles(\"bonjour\")  # renvoie 3\n",
    "```"
   ],
   "id": "5d6694f8"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "b3cb612d"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert compte_voyelles(\"bonjour\") == 3\n",
    "assert compte_voyelles(\"python\") == 2\n",
    "assert compte_voyelles(\"brr\") == 0\n",
    "assert compte_voyelles(\"\") == 0\n",
    "print(\"Tests OK\")"
   ],
   "id": "6b6e3878"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionnaires"
   ],
   "id": "1899470b"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 12\n",
    "\n",
    "Écrire une fonction `total_stock(stock)` qui renvoie le nombre total d'articles\n",
    "d'un dictionnaire de type `{produit: quantité}`.\n",
    "\n",
    "```python\n",
    "total_stock({\"vis\": 40, \"clou\": 0, \"boulon\": 12})  # renvoie 52\n",
    "```"
   ],
   "id": "dfc1b253"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "a606c325"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert total_stock({\"vis\": 40, \"clou\": 0, \"boulon\": 12}) == 52\n",
    "assert total_stock({\"vis\": 3}) == 3\n",
    "assert total_stock({}) == 0\n",
    "print(\"Tests OK\")"
   ],
   "id": "f538c7aa"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 13\n",
    "\n",
    "Écrire une fonction `ruptures(stock)` qui renvoie la liste des produits dont la\n",
    "quantité est nulle.\n",
    "\n",
    "```python\n",
    "ruptures({\"vis\": 40, \"clou\": 0, \"boulon\": 12, \"ecrou\": 0})  # renvoie ['clou', 'ecrou']\n",
    "```"
   ],
   "id": "76060128"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "60c9476c"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert ruptures({\"vis\": 40, \"clou\": 0, \"boulon\": 12, \"ecrou\": 0}) == [\"clou\", \"ecrou\"]\n",
    "assert ruptures({\"vis\": 40}) == []\n",
    "assert ruptures({}) == []\n",
    "print(\"Tests OK\")"
   ],
   "id": "a0cc3ea8"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 14\n",
    "\n",
    "Écrire une fonction `occurrences(t)` qui renvoie un dictionnaire donnant, pour\n",
    "chaque élément de la liste `t`, son nombre d'apparitions.\n",
    "\n",
    "```python\n",
    "occurrences([\"a\", \"b\", \"a\", \"c\", \"a\"])  # renvoie {'a': 3, 'b': 1, 'c': 1}\n",
    "```"
   ],
   "id": "8b793c69"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "0ccd6ce6"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert occurrences([\"a\", \"b\", \"a\", \"c\", \"a\"]) == {\"a\": 3, \"b\": 1, \"c\": 1}\n",
    "assert occurrences([2, 2, 2]) == {2: 3}\n",
    "assert occurrences([]) == {}\n",
    "print(\"Tests OK\")"
   ],
   "id": "1fdd9759"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice 15\n",
    "\n",
    "Écrire une fonction `meilleur(notes)` qui prend un dictionnaire de type\n",
    "`{prénom: note}` et renvoie le prénom qui a la meilleure note (le premier en cas\n",
    "d'égalité), ou `None` si le dictionnaire est vide.\n",
    "\n",
    "```python\n",
    "meilleur({\"lea\": 14, \"tom\": 17, \"ana\": 11})  # renvoie 'tom'\n",
    "```"
   ],
   "id": "9874f785"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Votre code\n"
   ],
   "id": "3e214c59"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests\n",
    "assert meilleur({\"lea\": 14, \"tom\": 17, \"ana\": 11}) == \"tom\"\n",
    "assert meilleur({\"lea\": 14}) == \"lea\"\n",
    "assert meilleur({\"lea\": 15, \"tom\": 15}) == \"lea\"\n",
    "assert meilleur({\"lea\": -1, \"tom\": -3}) == \"lea\"\n",
    "assert meilleur({}) == None\n",
    "print(\"Tests OK\")"
   ],
   "id": "2de43fb0"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}