1nsi_7_random.ipynb

{
 "metadata": {
  "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.3-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python37364bit201329ed7ee849b4a43ad7bb610f5989",
   "display_name": "Python 3.7.3 64-bit"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Utilisation de modules : le module random\n",
    "\n",
    "Le mot anglais **random** peut se traduire en français par *aléatoire*\n",
    "\n",
    "Il est très souvent utile d’avoir recours à l’aléatoire en informatique, par exemple dans les jeux pour éviter que la partie ne soit toujours la même. \n",
    "\n",
    "Le module Python **random** dispose de fonctions permettant de réaliser des tirages aléatoires ou des mélanges de séquences.\n",
    "\n",
    "La documentation complète se trouve ici : https://docs.python.org/fr/3.7/library/random.html#module-random \n",
    "\n",
    "## 1- Présentation de quelques fonctions du module random :\n",
    "\n",
    "Ci-dessous, quelques unes des fonctions les plus souvent rencontrées :\n",
    "\n",
    "![tableau_random.png](images/tableau_random.png)\n",
    "\n",
    "Quelques exemples d'utilisation :\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exécuter cette cellule pour importer le module random. Il sera alors disponible pour toutes les cellules suivantes :\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# le lancer de dé : il faut tirer un entier entre 1 et 6. \n",
    "# on utilise alors la fonction randint(a, b) : la compléter\n",
    "face = random.randint(???, ???)\n",
    "print('face : ', face)\n",
    "# (on pourra relancer plusieurs fois l'exécution de cette cellule pour constater l'aspect aléatoire du résultat et vérifier que la face du dé est toujours comprise entre 1 et 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tirage aléatoire d'un nombre impair compris entre 1 et 9\n",
    "# pour ce tirage plus compliqué on utilise la fonction randrange(start, stop, step)\n",
    "# Remarque : revoir si nécessaire la fonction range() de Python\n",
    "nb_impair = random.randrange(???,???,???)\n",
    "print(nb_impair)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code pour tirer un nombre pair entre 0 et 100 :\n",
    "nb_pair = random.randrange(???, ???, ???)\n",
    "print(nb_pair)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tirage aléatoire d'un élement dans une liste\n",
    "# on utilise la fonction choice(seq) :\n",
    "animaux = ['chien', 'chat', 'oiseau', 'poisson', 'insecte']     # une liste de mots\n",
    "tirage = random.???\n",
    "print(tirage)"
   ]
  },
  {
   "source": [
    "On distingue deux types de tirages :\n",
    "  - avec remise : l’objet tiré est remis pour un prochain tirage. Il peut donc de nouveau être tiré\n",
    "  - sans remise : l’objet tiré n’est pas remis pour un prochain tirage. Il ne peut être tiré qu’une seule fois.\n",
    "Au Loto, une boule tirée n'est pas remise en jeu : elle ne peut sortir qu'une seule fois. C'est donc un tirage sans remise.\n",
    "\n",
    "Quel type de tirage génère choice(seq) ? (Ecrire ci-dessous le code qui permet de le déterminer)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code pour tester si le tirage est avec ou sans remise\n",
    "# on relance plusieurs fois le tirage et on regarde si un même élément de la liste est tiré plusieurs fois\n",
    "# auquel cas le tirage se fait avec remise:\n",
    "animaux = ['chien', 'chat', 'oiseau', 'poisson', 'insecte']     # une liste de mots\n",
    "???\n",
    "...\n",
    "???\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code pour mélanger aléatoirement les éléments d'une liste.\n",
    "# on utilise la fonction shuffle(seq) :\n",
    "animaux = ['chien', 'chat', 'oiseau', 'poisson', 'insecte']     # une liste de mots\n",
    "print('liste avant application de shuffle : ',animaux, '\\n')\n",
    "# mélanger la liste :\n",
    "random.shuffle(animaux)\n",
    "# afficher la liste après mélange :\n",
    "print('liste après application de shuffle : ',???)"
   ]
  },
  {
   "source": [
    "**Remarque importante** : la liste initiale se trouve *modifiée* par l'application de la fonction shuffle()\n",
    "\n",
    "Toutes les fonctions précédentes *piochent* un élément dans une séquence : un entier dans une séquence d'entiers ou un élément dans une liste.\n",
    "\n",
    "Il est parfois utile de travailler sur des variables non plus *dicrètes* comme précédemment mais *continues*.\n",
    "\n",
    "On dispose alors de la fonction random() :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test de la fonction random() :\n",
    "for _ in range(10):\n",
    "    print(random.random())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pour obtenir une valeur réelle aléatoire entre 0 et 100:\n",
    "print(100*random.random())"
   ]
  },
  {
   "source": [
    "...et si on a besoin d'une valeur réelle aléatoire n comprise entre deux valeurs quelconques a et b, un peu de mathématiques sont nécessaires :\n",
    "\n",
    "**n = a + (b - a)*random()**\n",
    "\n",
    "en effet :\n",
    "  - random() donnant un résultat entre 0.0 et 1.0, alors (b - a)*random() donne un résultat entre 0 et (b - a)\n",
    "  - avec l'ajout de a on obtient alors un résultat :\n",
    "    **a + 0 <= n <= a + (b - a)*1.0*** c'est à dire\n",
    "    \n",
    "    **a + 0 <= n <= a + b - a** soit au final :\n",
    "\n",
    "   **a <= n <= b**\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exemple : écrire le code pour obtenir une valeur réelle aléatoire comprise entre 10.5 et 40.7:\n",
    "a = ???\n",
    "b = ???\n",
    "n = ???\n",
    "print(n)"
   ]
  },
  {
   "source": [
    "...Maintenant que l'on sait faire ce petit travail, dévoilons une fonction du module random qui fait exactement ce travail :\n",
    "\n",
    "**uniform(a, b)**"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# utilisation de la fonction uniform(a, b) pour obtenir une valeur réelle aléatoire comprise entre 10.5 et 40.7 :\n",
    "n = random.uniform(???)\n",
    "print(n)"
   ]
  },
  {
   "source": [
    "## 2- Première mise en situation : un jeu de dés\n",
    "\n",
    "### 2.1- Affichage d'une face d'un dé\n",
    "\n",
    "On souhaite créer une fonction **afficher_de(valeur)** qui ne renvoie rien mais qui exécute les instructions nécessaires à l'affichage d'une face de dé correspondant au paramètre **valeur** fourni à la fonction.\n",
    "Exemple de \"graphisme\" possible :\n",
    "\n",
    "![faces_des.png](images/faces_des.png)\n",
    "\n",
    "Ecrire ci-dessous le code nécessaire :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def afficher_de(valeur):\n",
    "    \"\"\" fonction (procédure) qui affiche la face d'un dé correspondant à 'valeur'\n",
    "    :param valeur: (int) une valeur comprise entre 1 et 6\n",
    "    \"\"\"\n",
    "    ???\n",
    "    ...\n",
    "    ???\n",
    "\n",
    "# test de la fonction : afficher les 6 faces du dé\n",
    "for i in range(???):\n",
    "    afficher_de(???)\n",
    "    print('')"
   ]
  },
  {
   "source": [
    "### 2.2- Lancer de dé et affichage :\n",
    "\n",
    "Ecrire une fonction **lancer_de()** qui simule un lancer de dé puis l'associer à la fonction d'affichage réalisée ci-dessus"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lancer_de():\n",
    "    \"\"\" fonction qui simule un lancer de dé\n",
    "    :return: (int) entier aléatoire entre 1 et 6\n",
    "    \"\"\"\n",
    "    return random.???\n",
    "\n",
    "# composition des deux fonctions :\n",
    "???"
   ]
  },
  {
   "source": [
    "### 2.3- Un jeu de dés\n",
    "\n",
    "Ecrire un programme permettant le lancer virtuel de 3 dés. Ce code utilisera les deux fonctions écrites ci-avant :"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code du jeu de dés:\n",
    "???\n",
    "...\n",
    "???"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# à tester, lire et comprendre :\n",
    "# code alternatif utilisant une liste pour définir les 6 faces du dé :\n",
    "faces = ('|-----|\\n|     |\\n|  o  |\\n|     |\\n|-----|\\n',  # face 0\n",
    "         '|-----|\\n|    o|\\n|     |\\n|o    |\\n|-----|\\n',  # face 1\n",
    "         '|-----|\\n|    o|\\n|  o  |\\n|o    |\\n|-----|\\n', \n",
    "         '|-----|\\n|o   o|\\n|     |\\n|o   o|\\n|-----|\\n', \n",
    "         '|-----|\\n|o   o|\\n|  o  |\\n|o   o|\\n|-----|\\n', \n",
    "         '|-----|\\n|o   o|\\n|o   o|\\n|o   o|\\n|-----|\\n')   # face 6\n",
    "\n",
    "def lancer_de_V2():\n",
    "    return faces[random.randint(0,5)]      # expliquer ce que fait cette ligne de code !\n",
    "\n",
    "print(lancer_de_V2())"
   ]
  },
  {
   "source": [
    "## 3- Deuxième mise en situation : initialisation d'un plateau de jeu\n",
    "\n",
    "On a un plateau de jeu constitué de cases, chacune pouvant être : de la mer (' '), une ile ('I') ou un pirate ('P').\n",
    "Pour que le jeu démarre de façon différente à chaque fois, on veut que les cases soient initialisées de façon aléatoire avec pour chacune d'elles : \n",
    "  - 5 % de chance d'être une ile\n",
    "  - 10% de chance d'être un pirate\n",
    "  - et donc 85% de chance d'être de la mer\n",
    "\n",
    "La fonction *init_plateau()* réalise cette initialisation :\n",
    "  - dans un premier temps on crée *une liste de listes qui représente l'ensemble du plateau* avec toutes les cases qui sont de type 'mer'\n",
    "  - puis pour chaque case on fait un tirage au sort avec random() : cela donne un nombre réel entre 0.0 et 1.0\n",
    "    - si ce nombre est inférieur à 0.05 (0.05 = les 5%) alors la case devient ile ('I')\n",
    "    - si ce nombre est inférieur à 0,15 (donc en fait compris entre 0.05 et 0.15 soit un écart de 0.10 correspondant au 10%) alors la case devient pirate ('P')\n",
    "    - (au delà de 0.15 et jusque 1.0, ce qui fait un écart de 0.85, soit les 85%, la case reste mer (' '))\n",
    "\n",
    "La fonction *affiche(mat)* est une fonction déjà rencontrée pour réaliser un affichage matriciel : elle permet un affichage sommaire du plateau de jeu.\n",
    "\n",
    "Compléter le code des deux fonctions suivantes :\n",
    "\n",
    "  - une fonction *place_bateau(plateau, dim)* qui positionne de façon aléatoire le bateau du joueur sur une **case de type mer** du plateau. La case bateau sera notée 'B' sur le plateau de jeu\n",
    "  \n",
    "  - une fonction *stat(plateau)* qui renvoie un tuple constitué du *nombre d'iles* suivi du *nombre de pirates* présents sur le plateau.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import random \n",
    "\n",
    "def init_plateau(dim):\n",
    "    \"\"\"fonction qui initialise le plateau de jeu\n",
    "    :param dim: (tuple) (int, int) ('longueur' , 'largeur') du plateau\n",
    "    :return: (list) liste de liste   \n",
    "    \"\"\"\n",
    "    plateau = [[' ' for j in range(dim[0])] for i in range(dim[1])]\n",
    "    for i in range(dim[1]):\n",
    "        for j in range(dim[0]):\n",
    "            # alea : nombre aléatoire entre 0.0 et 1.0 :\n",
    "            alea = ???\n",
    "            # chaque case a 5% de chance d'être une ile ('I'), 10% d'être un bateau pirate ('P')\n",
    "            # ou 85% de rester une case de mer (notée ' ') :\n",
    "            if alea <= ???:\n",
    "                plateau[i][j] = ???\n",
    "            elif alea <= ???:\n",
    "                plateau[i][j] = ???\n",
    "    return plateau \n",
    "\n",
    "def affiche(mat):\n",
    "    \"\"\" \n",
    "    affiche sous forme matricielle une liste de liste\n",
    "    :param mat: (list) : la liste de listes à afficher\n",
    "    \"\"\"   \n",
    "    for i in range(len(mat)):\n",
    "        for j in range(len(mat[0])):\n",
    "            print( ':', mat[i][j], ' ' ,end='')\n",
    "        print(':')\n",
    "    print(' ')\n",
    "\n",
    "def place_bateau(plateau, dim):\n",
    "    \"\"\"\n",
    "    place de façon aléatoire le bateau du joueur sur une case mer\n",
    "    :param plateau: (list) le plateau de jeu\n",
    "    :param dim: (tuple) (int, int) ('longueur' , 'largeur') du plateau\n",
    "    \"\"\"\n",
    "    # on tire de façon aléatoire une valeur de i et une de valeur de j (contenues dans les dimensions)\n",
    "    # du plateau. \n",
    "    trouve = False\n",
    "    while trouve != True:\n",
    "        i = ???\n",
    "        j = ???\n",
    "        # si la case(i, j) est de type mer alors on la remplace en bateau:\n",
    "        if plateau[i][j] == ???:\n",
    "            plateau[i][j] = ???\n",
    "            trouve = True\n",
    "\n",
    "def stat(plateau):\n",
    "    \"\"\" compte et renvoie le nombre d'iles et de pirates sur le plateau de jeu\n",
    "    :param plateau: (list) le plateau de jeu\n",
    "    :return: (tuple) (nbre d'iles, nbre de pirates)\n",
    "    \"\"\"\n",
    "    nb_iles = 0\n",
    "    nb_pirates = 0\n",
    "    \n",
    "    # code à compléter :\n",
    "    ???\n",
    "    ...\n",
    "    ???\n",
    "    return nb_iles, nb_pirates\n",
    "\n",
    "dimensions = (10,10)\n",
    "jeu = init_plateau(dimensions)\n",
    "# décommenter la ligne suivante lorsque la fonction place_bateau() est prête :\n",
    "#place_bateau(jeu, dimensions)\n",
    "affiche(jeu)\n",
    "# Décommenter et compléter la ligne suivante lorsque la fonction stat() est prête :\n",
    "#print(\"\\n nombre d'iles = \", ??? , ' ; nombre de pirates = ', ???)"
   ]
  }
 ]
}