Formation 18 décembre.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programme de la journée de formation du 18 décembre\n",
    "\n",
    "## Python\n",
    "\n",
    "- Python : Langage interprété\n",
    "- Distribution utilisée : Edupython\n",
    "- La console : Pour interagir avec le script"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test de python\n",
    "\n",
    "En console, tester :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque : `print()` est une fonction qui permet d'afficher en console le paramètre (entre parenthèses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables\n",
    "\n",
    "Memo :\n",
    "0. Affectation d’une valeur\n",
    "\n",
    "    `NomVariable = valeur`\n",
    "    \n",
    "1. Type int (entier)\n",
    "\n",
    "    `anneeEnCours = 2019`\n",
    "    \n",
    "2. Type float (décimal)\n",
    "\n",
    "    `vitesse = 77.75` **Attention, écriture américaine**\n",
    "    \n",
    "3. Type str (chaîne de caractères)\n",
    "\n",
    "    `monPrenom==\"Toto\"`\n",
    "    \n",
    "4. Type bool (booléen)\n",
    "\n",
    "    `finDePartie = False`\n",
    "    \n",
    "5. Type tuple (Ne sera pas vu)\n",
    "\n",
    "    `monTuple = (2019,77.75,\"Toto \",False)`\n",
    "    \n",
    "6. Type dict (dictionnaire) (Ne sera pas vu)\n",
    "\n",
    "    `monDico = {\"Pomme\" : 10, \"Poire\" : 5}`\n",
    "    \n",
    "7. Type list (liste)\n",
    "\n",
    "    `maListe = [2019,77.75,\"Toto\",False]`\n",
    "    \n",
    "## Principales opération mathématiques\n",
    "\n",
    "`a + b` : addition (2+5 = 7)\n",
    "\n",
    "`a - b` : soustraction (2-5 = -3)\n",
    "\n",
    "`a * b` : multiplication (2*5=10)\n",
    "\n",
    "`b/a` : division(5/2 = 2.5)\n",
    "\n",
    "`b//a` : division entière (5//2 = 2)\n",
    "\n",
    "`b%a` : modulo (reste de division entière)  (5%2 = 1)\n",
    "\n",
    "`b**a` : exposant (5**2 = 25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable : Application 1 - Calcul de l'énergie cinétique d'un corps\n",
    "\n",
    "L'énergie cinétique d'un corps dépend de sa vitesse et de sa masse selon la relation mathémtique : $$Ec = {1 \\over 2} \\times m \\times v^2$$\n",
    "\n",
    "Demandons à Python de réaliser cette application :\n",
    "1. Dans la zone script :\n",
    "    1. Définir les variables et affecter les valeurs \n",
    "    2. Calculer l'énergie cinétique\n",
    "    3. Demander l'affichage dans la console en utilisant la fonction ```print()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Corrigé à faire en groupe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque : Il existe des façons plus \"propres\" d'afficher des messages !\n",
    "Exemple : ``` \n",
    "print(f\"L'énergie cinétique est de {ec:.5} J\")\n",
    "```\n",
    "Cette méthode est appelée \"f-string\". Elle commence par un 'f', et les variables sont indiquées entre accolades. On peut choisir d'indiquer combien de nombres sont notés."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable : Exercice 1 : La force gravitationnelle  \n",
    "Calculer la force gravitationnelle exercée par la Terre sur un objet de masse m = 65 kg.\n",
    "L'objet est situé à une distance de 6 370 000 m du centre.\n",
    "\n",
    "On rappelle la relation : $$ F_{A/B} = G \\times {{m_A \\times m_B} \\over  {d_{AB^2}} }$$\n",
    "\n",
    "Avec $$G = 6,67 \\times 10^{−11} N.m^2.kg^{−2}$$\n",
    "et $$m_{Terre} = 5,97 \\times  10^{24} kg $$  \n",
    "\n",
    "Pour cela :\n",
    "1. Définir et affecter la valeur a chaque variable\n",
    "2. Calculer valeur de la force à partir des variables déclarées. (vous devez trouver environ 637 N)\n",
    "3. Afficher le résultat en console avec la fonction print(). Vous pouvez ajouter une phrase et devez ajouter l'unité (N)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Correction de l'exercice force gravitationnelle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les fonctions\n",
    "\n",
    "En pratique, on écrit du code dans des **fonctions**.\n",
    "* Réutilisable\n",
    "* Clarifie le code\n",
    "* Calculée uniquement lors de l'appel\n",
    "\n",
    "Se note de la façon :\n",
    "```python\n",
    "def nom_de_la_fonction(parametre):\n",
    "    ...CODE...\n",
    "```\n",
    "\n",
    "Exemple :\n",
    "```python\n",
    "def poids(m):\n",
    "    return m*9.81\n",
    "```\n",
    "\n",
    "Il existe déjà tout un tas de fonctions dans python ! Par exemple ```print()``` est une fonction !    \n",
    "**Astuce :** Lorsque vous interrogez une variable en console, python vous propose les fonctions qui peuvent s'appliquer à cet objet. De même lorsqu'une fonction est écrite, les paramètres requis et des informations sont données."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def poids(m):\n",
    "    return m*9.81"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut ensuite appeler la fonction en console OU dans le script :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "poids(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une fonction peut posséder plusieurs paramètres, exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def surface_rectangle(a,b):\n",
    "    return a*b\n",
    "\n",
    "## Appel de la fonction :\n",
    "surface_rectangle(5,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou aucun paramètre :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fonction_inutile():\n",
    "    return \"Cette fonction sert à rien !\"\n",
    "\n",
    "## Appel de la fonction\n",
    "fonction_inutile()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin, on peut définir une valeur par défaut pour les variables. Elles seront alors optionnelles lors de l'appel. Si lors de l'appel une autre valeur est indiquée, alors cette valeur prend le dessus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def surface_rectangle(a=5,b=2):\n",
    "    return a*b\n",
    "\n",
    "## Appel de la fonction :\n",
    "surface_rectangle(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fonction : Application 1 : Transformer le code energie cinétique en fonction\n",
    "\n",
    "Utilise le code pour l'énergie cinétique vu précédemment pour en faire une fonction prenant comme paramètre m et v. Par défaut la masse sera de 50 kg.  \n",
    "**Remarque** : Un paramètre optionnel suit forcément un paramètre obligatoire dans la définition d'une fonction. Donc ici la vitesse doit figurer avant la masse dans la définition de la fonction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Correction en groupe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fonction : Exercice 1 : Transformer le code force gravitationnelle en fonction\n",
    "\n",
    "Faire de même pour la force gravitationelle. Définir par défaut les valeurs de la constante gravitationnelle (G), de la masse de Terre et de la distance pour qu'elle soit égale au rayon de la Terre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##Correction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fonction : Exercice 2 :  Division Euclidienne\n",
    "Écrire une fonction div_euclid()  qui accepte deux arguments  n  et m , et renvoie le reste et le quotient de la division euclidienne de n  par m.\n",
    "\n",
    "Exemple, la division euclidienne de 10 par 3 doit retourner 3 (quotient) et 1 (reste)\n",
    "Remarque : Pour renvoyer deux valeurs, on utilise : ```return a,b```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Correction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les listes  \n",
    "Les listes sont des objets qui peuvent stocker plusieurs valeurs. Elles sont modifiables.\n",
    "On les utilise beaucoup, notamment pour construire des graphiques ou faire des séries de mesures.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mémo :\n",
    "```python\n",
    "#Création d'une liste vide\n",
    "maListe = []\n",
    ">>>maliste \n",
    "[]\n",
    "\n",
    "#Associer une liste à une variable\n",
    "a = 12\n",
    "maListe = [a]\n",
    ">>>maliste \n",
    "[12]\n",
    "\n",
    "#Ajouter un élément à la fin de la liste\n",
    "maListe.append(5)\n",
    ">>>maListe\n",
    "[12, 5] \n",
    "\n",
    "#Ajout d'un élément à une position donnée : (Rappel position 0 = 1er élément)\n",
    "maListe.insert(0,\"hello\")\n",
    ">>>maListe\n",
    "['hello',12, 5]\n",
    "\n",
    "#Lire une valeur contenu dans la liste :\n",
    ">>>maListe[1]\n",
    "12\n",
    "\n",
    "#On peut aussi accèder à la dernière valeur par \"-1\", celle d'avant par -2, ...\n",
    ">>>maListe[-1]\n",
    "5\n",
    "\n",
    "#On peut lire qu'une partie de la liste\n",
    "maListe[1:] #de l'indice 1 (cest à dire le 2nd élément) jusqu'à la fin\n",
    "maListe[:1] # du début jusqu'à l'indice 1 exclu\n",
    "\n",
    "\n",
    "#Remplacer une valeur contenu dans la liste :\n",
    "maListe[1] = \"On remplace le 12\"\n",
    ">>>maListe\n",
    "['hello', 'On remplace le 12', 5]\n",
    "\n",
    "#Taille d'une liste (= nombre d'élements qu'elle contient)\n",
    ">>>len(maListe)\n",
    "3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listes : Exercice 1 : Equation du nénuphar  \n",
    "\n",
    "Contexte : Dans un lac, le nombre de nenuphar double chaque jour. Une liste contient le nombre de nénuphars dans un lac chaque jour qui passe...\n",
    "\n",
    "On va répondre à cette commande étape par étape :\n",
    "1. Définir une variable ```nbNenuphar``` égal à 1, correspondant au nombre de nénuphar initialement présent.\n",
    "2. Créer une liste appelée ```listeNenuphar``` à partir du nombre de nénuphar initial.\n",
    "3. Créer une fonction ```fonctionNenuphar``` qui prend comme paramètre la liste, et qui retourne la liste du nombre de nénuphar avec un jour supplémentaire.\n",
    "\n",
    "Remarque : Cette fonction modifie directement la liste. Parfois c'est souhaitable, parfois non. On pourrait très bien retourner une nouvelle liste sans modifier la liste initiale.\n",
    "\n",
    "Au premier appel, vous obtiendrez donc ```[1]``` puis ```[1,2]``` puis ```[1,2,4]``` etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Correction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Structure conditionnelle  \n",
    "Les structures conditionnelles introduisent des conditions à l'execution d'un programme. L'informatique prend tout son sens.\n",
    "\n",
    "## Booléen\n",
    "\n",
    "1. ```True``` OU ```False```\n",
    "2. Comparaison par opérateurs de comparaison :\n",
    "    1. ```==``` (égal à)\n",
    "    2. ```!=``` (différent de)\n",
    "    3. ```>``` (strictement supérieur à)\n",
    "    4. ```>```= (supérieur ou égal à)\n",
    "    5. ```<``` (strictement inférieur à)\n",
    "    6. ```<=``` (inférieur ou égal à)\n",
    "3. Et opérateurs logique : ```AND```, ```OR```\n",
    "3. Et la structure ```IF```, ```ELSE``` et ```ELIF```  \n",
    "Exemple :   \n",
    "\n",
    "```python\n",
    "a = int(input(\"entrer un entier\"))\n",
    "\n",
    "if a > 3:     #Si a est strictement supérieur à 3, faire...\"\n",
    "    print(\"a est strictement supérieur à 3\")\n",
    "elif a <1 :    #Sinon, vérifier si a est inférieur à 1, et si oui faire...\"\n",
    "    print(\"a est strictement inférieur à 1\")\n",
    "else :         #Sinon, ...\n",
    "    print(\"a est compris dans l'interval [1;3] \")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boucles\n",
    "1. Boucle ```while``` pour boucler jusqu'à une condition.\n",
    "2. Boucle ```for``` pour faire répéter une opération un nombre connu de fois.\n",
    "\n",
    "## while\n",
    "```python\n",
    "while condition :\n",
    "    instruction\n",
    "```\n",
    "\n",
    "## for\n",
    "```python\n",
    "for element in sequence:\n",
    "    instruction\n",
    "``` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Structure conditionnelle / Boucle :  Exercice : Faire deviner un nombre aléatoire\n",
    "\n",
    "Je vous propose de réaliser un \"jeu\" : L'ordinateur va choisir un nombre aléatoire, et vous devrez faire des propositions. Il vous dira si son nombre et inférieur ou supérieur jusqu'à ce que vous le trouviez.  \n",
    "Le jeu sera contenu dans une fonction ```lancerPartie()``` qui prendra comme paramètre la \"taille du jeu\". Exemple : ```lancerPartie(1,100)``` pour un nombre compris entre 1 et 100.  \n",
    "\n",
    "Vous aurez besoin :   \n",
    "1. De générer un nombre aléatoire et pour cela de ce code :  \n",
    "```python  \n",
    "import random ## On importe un module externe pour ajouter des fonctions\n",
    "r = random.randint(1,100) ## On génére un entier entre 1 et 100, stocké dans la variable 'r'\n",
    "```\n",
    "2. Que le code vous demande une valeur, et pour cela du code :\n",
    "```python\n",
    "rep = int(input(\"Quelle valeur voulez-vous tester ?\"))\n",
    "```\n",
    "3. Le jeu devra \"boucler\" tant que la réponse n'est pas trouvée ! On peut par exemple définir une variable ```trouve = False``` et faire une boucle : tant que ```trouve == False```alors...\n",
    "\n",
    "4. Conseil : Commencez par des parties de votre code, par exemple en console, ou sans utiliser les paramètres. N'hésitez pas à afficher les variables avec ```print()``` ... et progressivement, remplacez pour arriver au code final.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Réponse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## range\n",
    "La fonction ```range()``` permet de créer des listes stockées en mémoire. C'est très utilisé combiné avec une boucle ```for``` pour répéter une opération ou parcourir des listes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Exemple création d'une table d'addition [FAIRE LA TRACE]\n",
    "def addition(n):\n",
    "    for i in range(10): ## On créer une liste de 0 à 9, et on fait le parcours\n",
    "        s = i + n\n",
    "        print(f\"{n}+{i} = {s}\")\n",
    "## Appel\n",
    "addition(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boucles : Exercice : Ecrire les tables de multiplication \n",
    "\n",
    "Vous devez réaliser une fonction ```multiplication(n)``` qui écrit les tables de multiplication pour un entier ```n``` donné.  \n",
    "Une fois réalisé, créez une fonction ```totalTable(nMax)``` qui écrit les tables de 1 à nMax !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Structure conditionnelle : Exercice 1 : Test de primalité\n",
    "\n",
    "Utilisé en cryptologie, les nombres premiers sont un \"classique\" de l'apprentissage d'un langage de programmation.\n",
    "Ici je vous propose de vérifier si un nombre est premier ou non.  \n",
    "\n",
    "Votre fonction ```estPremier(n)``` devra retourner \"Vrai\" (True) si le nombre est premier, et \"faux\" (False) sinon.  \n",
    "\n",
    "Rappel : Un nombre est premier s'il est divisible uniquement par 1 et lui-même.\n",
    "\n",
    "La méthode ici va être de tester tous les nombres compris entre 1 et n.(méthode simpliste).  \n",
    "Vous pouvez aussi tester de 1 à $\\sqrt n$ (facteur 0,5).  \n",
    "\n",
    "Remarque : Il pourra être utile d'arrondir un flottant à l'entier supérieur. Cette fonction est dans le module ```math``` et la fonction s'appelle ```ceil()``` (l'inverse, arrondi inférieur s'appelle ```floor```)\n",
    "```python\n",
    "import math\n",
    "math.ceil(...)\n",
    "```\n",
    "\n",
    "Il existe d'autres versions avec pre-test des nombres pour enlever par exemple les nombres pairs ... pour des nombres petits, ces options ne sont pas toujours interessantes.  \n",
    "\n",
    "Voici quelques nombres premiers pour tester votre fonction : 71 73 79 83 89 97"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Application physique de la journée :\n",
    "\n",
    "Premier bilan, je vous propose un exercice trouvé sur un parcours national magistère python : \n",
    "1. Prévoir ce que fais le programme ci-dessous. Puis l’exécuter.  \n",
    "\n",
    "```python\n",
    "\n",
    "#Conditions initiales:\n",
    "\n",
    "x = 0.\n",
    "y = 2.\n",
    "vx = 3.5\n",
    "vy = 0.\n",
    "ax = 0.\n",
    "ay = -9.81\n",
    "t = 0.\n",
    "\n",
    "#pas de temps\n",
    "\n",
    "dt = 0.001\n",
    "\n",
    "#Simulation\n",
    "\n",
    "while y > 0. :\n",
    "    x = x + vx * dt\n",
    "    y = y + vy * dt\n",
    "    vx = vx + ax * dt\n",
    "    vy = vy + ay * dt\n",
    "    t = t + dt\n",
    "\n",
    "print(\"La balle touche le sol à t =\", t, \"s et à la position x =\", x, \"m\")\n",
    "```\n",
    "\n",
    "2. Modifier ce programme pour simuler la chute d'une balle lâchée d'une hauteur de 2m sans vitesse initiale.\n",
    "3. Que peut-on dire des deux durées de chute obtenues ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Application physique 2 : Desintégration nucléaire spontanée\n",
    "\n",
    "Démarrons une activité différente : Pour le moment, on a surtout vu des exemples qui servent à appliquer des notions de programmation, mais la contextualisation physique était parfois tirée par les cheveux.\n",
    "Le but était de manipuler pour prendre en main, afin d'arriver sur des applications plus concrètes (prochains modules).\n",
    "\n",
    "Voyons maintenant un cas qui s'applique parfaitement en physique et peut présenter une bonne première application pour les élèves : Le cas de la désintégration spontanée.\n",
    "\n",
    "Le programme python va remplacer l'approche \"historique\" du lancé de dé pour expliquer l'aspect spontanée / non prédictible de la désintégration des noyaux instables.\n",
    "Par la suite, on pourra tracer des graphiques pour représenter les courbes de décroissance radioactive.\n",
    "\n",
    "### Idée générale \n",
    "Dans l'idée, on pourra définir une liste qui contient N éléments (les \"dés\" ou \"noyaux\"). On peut aussi le faire simplement via un nombre.\n",
    "On pourra également définir une fonction qui lancé le dé de manière aléatoire. Pour cela, on a besoin d'un module \"random\"\n",
    "On pourra utiliser une fonction qui va effectuer un lancé pour tous les éléments d'une liste, et enlever les dès qui ont fait \"6\" par exemple. On verra donc la population diminuer.\n",
    "On pourra stocker le nombre d’éléments (= la population) dans une liste pour avoir le suivi.\n",
    "Enfin, l'idée est de pouvoir proposer cette activité aux élèves : On proposera donc des activités à réaliser autour du code : code à compléter ? à comprendre ? à poursuivre ?\n",
    "\n",
    "### Générer une liste de N éléments\n",
    "Dans python, on peut concaténer des listes (les réunir)\n",
    "```python\n",
    "a = [\"a\",\"b\",\"c\"]\n",
    "b = [\"d\",\"e\",\"f\"]\n",
    "c = a + b\n",
    ">>> c\n",
    "['a', 'b', 'c', 'd', 'e', 'f']\n",
    "```\n",
    "\n",
    "On peut donc si on veut N éléments faire N addition :\n",
    "```python \n",
    "liste = [1] + [2] + ... + [N]\n",
    ">>> liste\n",
    " [1,2,...,N]\n",
    "```\n",
    "\n",
    "Ce qui correspond à multiplier un élément N fois !\n",
    "\n",
    "```python \n",
    "liste = N * [\"élément\"]\n",
    "#exemple \n",
    "liste = 4 * [\"dé\"]\n",
    ">>> liste\n",
    "['dé', 'dé', 'dé', 'dé']\n",
    "```\n",
    "Pour le cas de désintégration, le contenu de la variable importe peu, c'est leur nombre qui nous intéresse. On pourra très bien avoir comme ça 100 000 noyaux dans une liste\n",
    "\n",
    "### Random\n",
    "Pour générer un nombre aléatoire, on a besoin d'une fonction qui n'est pas disponible nativement, mais qui est dans un module externe. Ce point sera abordé plus en détail dans le prochain module de la formation.\n",
    "Pour générer un entier aléatoire (le cas du lancé de dé).\n",
    "Votre programme doit faire appel au module ```random```. On place au début du code (par convention) la ligne suivante :\n",
    "```python  \n",
    "import random # Les fonctions contenues dans ce module sont maintenant dispo !\n",
    "```\n",
    "On utilise la fonction ```randint(début,fin)``` pour générer un entier. On l'appelle en spécifiant qu'elle est contenu dans le module random ainsi : ```random.randint(debut,fin)``` :\n",
    "\n",
    "```python  \n",
    "import random\n",
    ">>> random.randint(0,6)\n",
    "2\n",
    ">>> random.randint(0,6)\n",
    "0\n",
    ">>> random.randint(0,6)\n",
    "6\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}