{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listes, `append` et simulations aléatoires\n",
    "\n",
    "**Au programme**\n",
    "- **Activité 0** : découvrir les listes, puis l'instruction `append` pour construire une liste.\n",
    "- **Exercice : simuler un tirage dans une urne.\n",
    "- **Exercice : la méthode de Monte-Carlo.\n",
    "\n",
    "> Pour exécuter une cellule : `Maj + Entrée`. Exécute les cellules **dans l'ordre**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Activité 0 : découvrir les listes et `append`\n",
    "\n",
    "### A. Découvrir les listes\n",
    "\n",
    "Jusqu'ici, une variable contient **une seule valeur**. Pour ranger **plusieurs valeurs** (les notes d'une classe, les résultats de plusieurs lancers…), Python propose les **listes**.\n",
    "\n",
    "Une liste s'écrit entre **crochets**, les éléments étant séparés par des **virgules**. Exécute la cellule suivante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "notes = [12, 15, 9, 14]\n",
    "print(notes)\n",
    "print(type(notes))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Les indices\n",
    "\n",
    "Chaque élément occupe une place repérée par un **indice**. **Attention : la numérotation commence à 0.**\n",
    "\n",
    "| indice | 0 | 1 | 2 | 3 |\n",
    "|:---:|:---:|:---:|:---:|:---:|\n",
    "| valeur | 12 | 15 | 9 | 14 |\n",
    "\n",
    "On accède à un élément avec `liste[indice]`, et on obtient le nombre d'éléments avec `len(liste)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(notes[0])\n",
    "print(notes[2])\n",
    "print(len(notes))\n",
    "print(notes[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questions**\n",
    "1. Que valent `notes[0]` et `notes[2]` ? Quel est l'indice du dernier élément de `notes` ?\n",
    "2. Que renvoie `len(notes)` ? Quel lien y a-t-il entre `len(notes)` et l'indice du dernier élément ?\n",
    "3. Que renvoie `notes[-1]` ?\n",
    "4. Retire le `#` devant la ligne ci-dessous, puis exécute la cellule. Lis attentivement le message d'erreur : que signifie-t-il ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(notes[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse :** *(double-cliquer pour écrire ta réponse)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Modifier un élément, parcourir une liste\n",
    "\n",
    "On peut remplacer un élément en lui affectant une nouvelle valeur, et on peut **parcourir** une liste avec une boucle `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "notes[1] = 16\n",
    "print(notes)\n",
    "\n",
    "for n in notes:\n",
    "    print(\"une note :\", n)\n",
    "\n",
    "for i in range(len(notes)):\n",
    "    print(\"indice\", i, \": note\", notes[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Quel élément a été modifié par `notes[1] = 16` ? Que contient maintenant `notes` ?\n",
    "6. Dans la première boucle, que représente `n` ? Dans la seconde, que représente `i` ? Quelle différence voit-on dans l'affichage ?\n",
    "\n",
    "Python sait aussi calculer directement certaines grandeurs utiles en statistiques :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sum(notes))   # somme des éléments\n",
    "print(max(notes))   # plus grand élément\n",
    "print(min(notes))   # plus petit élément"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse :** *(double-cliquer pour écrire ta réponse)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. **À toi :** avec la liste ci-dessous, calcule la moyenne des notes en utilisant `sum` et `len`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "notes = [12, 15, 9, 14]\n",
    "moyenne = ...\n",
    "print(moyenne)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Des listes de mots\n",
    "\n",
    "Une liste peut aussi contenir des **mots** (chaînes de caractères, écrites entre guillemets)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tirage = [\"bleu\", \"vert\"]\n",
    "print(tirage)\n",
    "print(tirage[0])\n",
    "print(len(tirage))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problème** : écrire à la main toutes les valeurs d'une liste devient impossible si elle en contient 1000 ! Il faut pouvoir **construire une liste automatiquement**. C'est l'objet de la suite."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### B. Ajouter un élément avec `append`\n",
    "\n",
    "Une liste peut être **vide** : `[]`. Observe ce qui se passe dans la cellule suivante.\n",
    "\n",
    "**Avant d'exécuter, prévois** ce qui sera affiché à chaque `print`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = []\n",
    "print(L)\n",
    "L.append(4)\n",
    "print(L)\n",
    "L.append(7)\n",
    "print(L)\n",
    "L.append(4)\n",
    "print(L)\n",
    "print(len(L))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 9**. Que fait l'instruction `L.append(x)` ? À quel endroit de la liste l'élément est-il ajouté ?\n",
    "\n",
    "**Question 10**. Après les trois `append`, que valent `L[0]`, `L[1]` et `L[2]` ? Vérifie en les affichant.\n",
    "\n",
    "**Question 11**. Peut-on ajouter plusieurs fois la même valeur dans une liste ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Teste et vérifie tes réponses ici en python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse :** *(double-cliquer pour écrire ta réponse)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`append` fonctionne aussi avec des mots, et on peut partir d'une liste vide pour la remplir petit à petit :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resultats = []\n",
    "resultats.append(\"pile\")\n",
    "resultats.append(\"face\")\n",
    "print(resultats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C. `append` dans une boucle\n",
    "\n",
    "Quand on doit ajouter beaucoup d'éléments, on utilise une boucle `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carres = []\n",
    "for i in range(1, 6):\n",
    "    carres.append(i * i)\n",
    "print(carres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questions**\n",
    "12. Que contient la liste `carres` à la fin ? Que vaut `i` à chaque tour de boucle ?\n",
    "13. **À toi :** complète la cellule pour obtenir la liste des 10 premiers multiples de 3 : `[3, 6, 9, ..., 30]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multiples = []\n",
    "for i in range(1, 11):\n",
    "    multiples.append(...)\n",
    "print(multiples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse :** *(double-cliquer pour écrire ta réponse)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### D. `append` et hasard\n",
    "\n",
    "La fonction `randint(a, b)` renvoie un entier **au hasard** entre `a` et `b` (inclus). Exécute plusieurs fois la cellule suivante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "des = []\n",
    "for i in range(10):\n",
    "    des.append(randint(1, 6))\n",
    "print(des)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 14**. Pourquoi le résultat change-t-il à chaque exécution ? Combien d'éléments contient la liste `des` ?\n",
    "\n",
    "**Question 15**. Écris une fonction `pile_ou_face()` qui simule **3 lancers** d'une pièce équilibrée et renvoie la liste des résultats, par exemple `['pile', 'face', 'face']`.\n",
    "\n",
    "   *Indice :* `randint(0, 1)` renvoie 0 ou 1 avec la même probabilité. Utilise `if` pour décider entre `\"pile\"` et `\"face\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pile_ou_face():\n",
    "    lancers = []\n",
    "    for i in range(3):\n",
    "        if ...:\n",
    "            lancers.append(\"pile\")\n",
    "        else:\n",
    "            ...\n",
    "    return lancers\n",
    "\n",
    "print(pile_ou_face())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse :** *(double-cliquer pour écrire ta réponse)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bilan.** Pour construire une liste au fur et à mesure : on la crée vide avec `[]`, puis on ajoute les éléments avec `liste.append(élément)`, souvent dans une boucle `for`.\n",
    "\n",
    "Tu peux maintenant passer aux exercices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Exercice : Simuler un tirage dans une urne\n",
    "\n",
    "Une urne contient **8 bulletins verts** et **6 bulletins bleus**.\n",
    "\n",
    "Camil a écrit la fonction `Urne` en Python ci-dessous. Exécute la cellule, puis appelle plusieurs fois `Urne()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "def Urne():\n",
    "    tirage = []\n",
    "    for i in range(2):\n",
    "        if randint(1, 14) <= 6:\n",
    "            tirage.append(\"bleu\")\n",
    "        else:\n",
    "            tirage.append(\"vert\")\n",
    "    return tirage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Urne())\n",
    "print(Urne())\n",
    "print(Urne())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Que renvoie cette fonction ?\n",
    "2. Cette fonction simule-t-elle un tirage **avec remise** ou **sans remise** ? Justifier.\n",
    "3. Quelle est la probabilité que cette fonction renvoie le couple `['bleu', 'bleu']` ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse :** *(double-cliquer pour écrire ta réponse)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pour vérifier la question 3 par simulation** : exécute la cellule suivante (elle répète l'expérience 10 000 fois) et compare avec ta réponse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 10000\n",
    "compteur = 0\n",
    "for k in range(N):\n",
    "    if Urne() == [\"bleu\", \"bleu\"]:\n",
    "        compteur = compteur + 1\n",
    "print(compteur / N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Modifier la fonction pour qu'elle renvoie le **nombre de bulletins bleus** obtenus lors de **deux tirages sans remise** de l'urne.\n",
    "\n",
    "   *Indice :* après avoir tiré un bulletin, l'urne ne contient plus le même nombre de bulletins. Utilise deux variables `verts` et `bleus` pour suivre le contenu de l'urne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Urne2():\n",
    "    verts = 8\n",
    "    bleus = 6\n",
    "    nb_bleus = 0\n",
    "    for i in range(2):\n",
    "        if randint(1, verts + bleus) <= bleus:\n",
    "            # on a tiré un bleu : que faut-il modifier ?\n",
    "            ...\n",
    "        else:\n",
    "            # on a tiré un vert : que faut-il modifier ?\n",
    "            ...\n",
    "    return nb_bleus\n",
    "\n",
    "print(Urne2())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pour aller plus loin.** Estime par simulation la probabilité d'obtenir 2 bulletins bleus sans remise, puis compare avec le calcul $\\dfrac{6}{14}\\times\\dfrac{5}{13}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 10000\n",
    "compteur = 0\n",
    "for k in range(N):\n",
    "    if ... == 2:\n",
    "        compteur = compteur + 1\n",
    "print(compteur / N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Exercice : Méthode de Monte-Carlo\n",
    "\n",
    "On a représenté un carré OABC et la parabole d'équation $y = x^2$. On se propose de donner une valeur approchée de l'aire du domaine $D$ délimité par l'axe des abscisses, la droite d'équation $x = 1$ et la parabole, en utilisant la **loi des grands nombres**.\n",
    "\n",
    "Exécute la cellule suivante : elle place 150 points au hasard dans le carré (en **bleu** ceux qui sont dans $D$, en **rouge** les autres)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from random import random      # random() renvoie un réel au hasard dans [0 ; 1[\n",
    "\n",
    "# Points bleus (dans D) et points rouges (hors de D)\n",
    "xb, yb = [], []\n",
    "xr, yr = [], []\n",
    "for i in range(150):\n",
    "    x = random()\n",
    "    y = random()\n",
    "    if y <= x**2:\n",
    "        xb.append(x)\n",
    "        yb.append(y)\n",
    "    else:\n",
    "        xr.append(x)\n",
    "        yr.append(y)\n",
    "\n",
    "# Courbe de la parabole\n",
    "xc, yc = [], []\n",
    "for i in range(101):\n",
    "    xc.append(i / 100)\n",
    "    yc.append((i / 100)**2)\n",
    "\n",
    "plt.figure(figsize=(5, 5))\n",
    "plt.scatter(xb, yb, color=\"blue\", s=10)\n",
    "plt.scatter(xr, yr, color=\"red\", s=10)\n",
    "plt.plot(xc, yc, color=\"black\")\n",
    "plt.plot([0, 1, 1, 0, 0], [0, 0, 1, 1, 0], color=\"black\")\n",
    "plt.text(-0.06, -0.06, \"O\"); plt.text(1.02, -0.06, \"A\")\n",
    "plt.text(1.02, 1.02, \"B\");   plt.text(-0.06, 1.02, \"C\")\n",
    "plt.axis(\"equal\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 1\n",
    "\n",
    "On choisit au hasard un point dans le carré OABC et on regarde s'il est dans le domaine $D$.\n",
    "\n",
    "La probabilité qu'il se trouve dans le domaine $D$ est : $p = \\dfrac{\\text{aire de } D}{\\text{aire de OABC}}$.\n",
    "\n",
    "**a)** Quelles conditions vérifient les coordonnées $(x\\,;\\,y)$ d'un point M situé :\n",
    "- dans OABC ;\n",
    "- dans le domaine $D$ ?\n",
    "\n",
    "**b)** Quelle est l'aire de OABC ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse :** *(double-cliquer pour écrire ta réponse)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2\n",
    "\n",
    "**a)** Compléter l'algorithme ci-dessous simulant 1000 fois l'expérience aléatoire, puis le traduire en Python.\n",
    "\n",
    "```\n",
    "c ← ...\n",
    "Pour k allant de 1 à …\n",
    "    x ← un nombre réel compris entre …\n",
    "    y ← un nombre réel compris entre …\n",
    "    Si …   alors c ← c + 1\n",
    "    Fin Si\n",
    "Fin Pour\n",
    "p ← ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Algorithme complété** *(double-cliquer pour écrire)* :\n",
    "\n",
    "```\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import random\n",
    "\n",
    "c = ...\n",
    "for k in range(...):\n",
    "    x = random()\n",
    "    y = ...\n",
    "    if ...:\n",
    "        c = c + 1\n",
    "p = ...\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**b)** Justifier qu'en exécutant ce programme, on obtient une valeur approchée de l'aire de $D$.\n",
    "\n",
    "**c)** Comment obtenir une meilleure approximation ? Teste ta idée dans la cellule suivante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Teste ici ta proposition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse :** *(double-cliquer pour écrire ta réponse)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3\n",
    "\n",
    "On considère le quart de disque, noté $D'$, de centre O et de rayon 1, situé dans le carré OABC. On choisit à nouveau au hasard un point dans le carré OABC et on regarde s'il est dans le domaine $D'$.\n",
    "\n",
    "**a)** Quelle est la probabilité que le point soit dans $D'$ ?\n",
    "\n",
    "**b)** Quelle condition la longueur OM doit-elle vérifier pour que le point M soit dans $D'$ ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse :** *(double-cliquer pour écrire ta réponse)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**c)** On simule 1000 fois l'expérience aléatoire. Écrire en Python un programme permettant d'obtenir une valeur approchée de $\\pi$.\n",
    "\n",
    "*Indice :* si $p \\approx \\dfrac{\\pi}{4}$, alors $\\pi \\approx \\ldots$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import random\n",
    "\n",
    "# Ton programme ici"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}