exercices_cours.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Exercices du cours (Bonus +1)\n",
        "## Conditions et boucles"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 1\n",
        "Écrivez un programme Python pour supprimer le caractère d'indice n d'une chaîne de caractères."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "var = input(\"Entrer une chaîne de caractères: \")\n",
        "var2 = input(\"Entrer l'indice du caractère que vous souhaitez supprimer: \")\n",
        "x = int(var2)\n",
        "var4 = var[:x]\n",
        "var5 = var[x+1:]\n",
        "print(var4+var5)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 2\n",
        "Écrivez un programme Python pour construire le modèle suivant, en utilisant des boucles for imbriquées.\n",
        "\n",
        "```\n",
        "* \n",
        "* * \n",
        "* * * \n",
        "* * * * \n",
        "* * * * * \n",
        "* * * * \n",
        "* * * \n",
        "* * \n",
        "*\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "k = 4\n",
        "for str_colors in range(1, 10):\n",
        "    if str_colors <= 5:\n",
        "        print('*'*str_colors)\n",
        "    else:\n",
        "        print('*'*k)\n",
        "        k = k-1\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 3\n",
        "Écrivez un programme Python qui prend une liste de mots et renvoie le mot le plus long et la longueur du mot le plus long.\n",
        "Exemples de la liste : [“python”, “boucle”, “exercices”]\n",
        "\n",
        "Résultat :\n",
        "\n",
        "Mot le plus long : exercices\n",
        "\n",
        "Longueur du mot le plus long : 9"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "liste = [\"python\", \"boucle\", \"exercices\"]\n",
        "max = liste[0]\n",
        "for str_colors in liste:\n",
        "    if len(str_colors) > len(max):\n",
        "        max = str_colors\n",
        "print(f'''Résulat:\n",
        "Mot le plus long : {max}\n",
        "Longeur du mot le plus long : {len(max)}''')\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 4\n",
        "Écrivez un programme Python pour supprimer les doublons d'une liste."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 1ere methode\n",
        "liste = [\"A\", \"B\", \"A\", \"C\"]\n",
        "li = []\n",
        "for str_colors in liste:\n",
        "    if str_colors not in li:\n",
        "        li.append(str_colors)\n",
        "print(li)\n",
        "\n",
        "li = []\n",
        "\n",
        "# 2eme methode\n",
        "[li.append(mot) for mot in liste if mot not in li]\n",
        "print(li)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 5\n",
        "Écrivez un script Python pour ajouter un élément à un tuple."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "mon_tuple = (1, 2, 3)\n",
        "mon_tuple = mon_tuple + (4,)\n",
        "mon_tuple = mon_tuple + (7,)\n",
        "print(mon_tuple)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 6\n",
        "Écrivez un script Python pour compter le nombre de caractères (fréquence des caractères) d'une chaîne de caractères.\n",
        "\n",
        "Exemple d'une chaîne de caractères : 'google.com'.\n",
        "\n",
        "Résultat : {'g' : 2, 'o' : 3, 'l' : 1, 'e' : 1, '.' : 1, 'c' : 1, 'm' : 1}\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "ch = 'google.com'\n",
        "frequences = {}\n",
        "for caractere in ch:\n",
        "    if caractere in frequences:\n",
        "        frequences[caractere] += 1\n",
        "    else:\n",
        "        frequences[caractere] = 1\n",
        "for caractere, frequence in frequences.items():\n",
        "    print(f\"{caractere} : {frequence}\")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 7\n",
        "Écrivez un script Python pour concaténer les dictionnaires suivants afin d'en créer un nouveau.\n",
        "\n",
        "Exemple des dictionnaires :\n",
        "\n",
        "dic1={1:10, 2:20}\n",
        "\n",
        "dic2={3:30, 4:40}\n",
        "\n",
        "dic3={5:50, 6:60}\n",
        "\n",
        "Résultat : {1 : 10, 2 : 20, 3 : 30, 4 : 40, 5 : 50, 6 : 60}\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "dic1 = {1:10, 2:20}\n",
        "dic2 = {3:30, 4:40}\n",
        "dic3 = {5:50, 6:60}\n",
        "dic = {}\n",
        "for d in [dic1, dic2, dic3]:\n",
        "    dic.update(d)\n",
        "print(dic)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 8\n",
        "Écrivez un script Python pour trier un dictionnaire par valeur."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Fonctions"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 1\n",
        "Écrivez une fonction Python qui accepte les paramètres b et n puis calculez la valeur de b<sup>n</sup> où n est l'exposant et b est la base."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def puissance(b, n):\n",
        "    s = 1\n",
        "    for value in range(n):\n",
        "        s *= b\n",
        "    return s\n",
        "\n",
        "\n",
        "print(puissance(2, 3))\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 2\n",
        "Écrivez une fonction Python pour afficher les nombres pairs d'une liste donnée.\n",
        "\n",
        "Exemple de liste : [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
        "\n",
        "Résultat attendu : [2, 4, 6, 8]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def paires(liste):\n",
        "    liste_paires = []\n",
        "    for value in liste:\n",
        "        if value % 2 == 0:\n",
        "            liste_paires.append(value)\n",
        "    return liste_paires\n",
        "\n",
        "\n",
        "print(paires([1, 2, 3, 4, 5, 6, 7, 8, 9]))\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 3\n",
        "Écrivez une fonction Python pour faire la somme de deux listes données.\n",
        "\n",
        "Exemple des listes : [1, 2, 3] , [4, 5, 6]\n",
        "\n",
        "Résultat : [5, 7, 9]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def sommeListes(liste1, liste2):\n",
        "    sommes = []\n",
        "    if len(liste1) >= len(liste2):\n",
        "        for i in range(len(liste1)):\n",
        "            if i < len(liste2):\n",
        "                sommes.append(liste1[i]+liste2[i])\n",
        "            else:\n",
        "                sommes.append(liste1[i])\n",
        "    else:\n",
        "        for i in range(len(liste2)):\n",
        "            if i < len(liste1):\n",
        "                sommes.append(liste1[i]+liste2[i])\n",
        "            else:\n",
        "                sommes.append(liste2[i])\n",
        "    return sommes\n",
        "\n",
        "\n",
        "print(sommeListes([1, 2, 3], [4, 5, 6]))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "from operator import add\n",
        "\n",
        "def sommeListes(liste1, liste2):\n",
        "    return list(map(add, liste1, liste2))\n",
        "\n",
        "print(sommeListes([1, 2, 3], [4, 5, 6]))"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 4\n",
        "Écrivez une fonction Python qui multiplie chaque nombre d'une liste par un nombre donné.\n",
        "\n",
        "Exemple d’une liste : [2, 4, 6, 9, 11]\n",
        "\n",
        "Nombre donné : 2\n",
        "\n",
        "Résultat : [4, 8, 12, 18, 22]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def multiplierListe(liste, n):\n",
        "    multiples = []\n",
        "    for i in range(len(liste)):\n",
        "        multiples.append(liste[i]*n)\n",
        "    return multiples\n",
        "\n",
        "\n",
        "print(multiplierListe([2, 4, 6, 9, 11], 2))\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 5\n",
        "Écrivez une fonction Python qui accepte un nombre arbitraire de paramètres (listes) et trouvez la liste la plus longue et la plus courte.\n",
        "\n",
        "Exemple des arguments : [0], [1, 3], [5, 7], [9, 11], [13, 15, 17]\n",
        "\n",
        "La liste la plus longue : (3, [13, 15, 17])\n",
        "\n",
        "La liste la plus courte : (1, [0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def min_maxListes(*listes):\n",
        "    min = max = listes[0]\n",
        "    for value in listes:\n",
        "        if len(value) < len(min):\n",
        "            min = value\n",
        "        elif len(value) > len(max):\n",
        "            max = value\n",
        "    return max, min\n",
        "\n",
        "\n",
        "max, min = min_maxListes([0], [1, 3], [5, 7], [9, 11], [13, 15, 17])\n",
        "print(f\"La liste la plus longue: {len(max), max}\")\n",
        "print(f\"La liste la plus courte: {len(min), min}\")\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 6\n",
        "Écrivez une fonction Python qui accepte comme paramètre une séquence de mots séparés par des traits d'union et qui retourne les mots séparés par des traits d'union après les avoir triés par ordre alphabétique.\n",
        "\n",
        "Exemple d'éléments :\n",
        "\n",
        "vert-rouge-jaune-noir-blanc\n",
        "\n",
        "Résultat attendu :\n",
        "\n",
        "blanc-jaune-noir-rouge-vert"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def sortColors(str_colors):\n",
        "    x = str_colors.split('-')\n",
        "    x = sorted(x)\n",
        "    return '-'.join(x)\n",
        "\n",
        "str_colors = 'vert-rouge-jaune-noir-blanc'\n",
        "print(sortColors(str_colors))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 7\n",
        "Écrivez une fonction Python pour combiner deux dictionnaires en ajoutant les valeurs des clés communes.\n",
        "\n",
        "Exemple d'entrée :\n",
        "\n",
        "{'a' : 100, 'b' : 200, 'c':300}, {'a' : 300, 'b' : 200, 'd':400}\n",
        "\n",
        "Résultat :\n",
        "\n",
        "{'a' : 400, 'b' : 400, 'd' : 400, 'c' : 300}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def joiner(dic1,dic2):\n",
        "    dic ={}\n",
        "\n",
        "    for item in dic1:\n",
        "        x=0\n",
        "        for item2 in dic2:\n",
        "            if item == item2:\n",
        "                x+=1\n",
        "                dic[item] = dic1[item[0]]+dic2[item2[0]]\n",
        "        if x==0:\n",
        "            dic[item] = dic1[item[0]]\n",
        "\n",
        "    for item2 in dic2:\n",
        "        x=0\n",
        "        for item2 in dic2:\n",
        "            if item == item2:\n",
        "                x+=1\n",
        "        if x==0:\n",
        "            dic[item2] = dic2[item2[0]]\n",
        "\n",
        "    return dic\n",
        "\n",
        "\n",
        "dic1 = {'a': 100, 'b': 200, 'c': 300}\n",
        "dic2 = {'a': 300, 'b': 200, 'd': 400}\n",
        "\n",
        "print(joiner(dic1, dic2))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def joiner2(dic1, dic2):\n",
        "    dic = {}\n",
        "\n",
        "    for key, value in dic1.items():\n",
        "        if key in dic2:\n",
        "            dic[key] = value + dic2[key]\n",
        "        else:\n",
        "            dic[key] = value\n",
        "    \n",
        "    for key, value in dic2.items():\n",
        "        if key not in dic:\n",
        "            dic[key] = value\n",
        "        \n",
        "\n",
        "    return dic\n",
        "\n",
        "\n",
        "dic1 = {'a': 100, 'b': 200, 'c': 300}\n",
        "dic2 = {'a': 300, 'b': 200, 'd': 400}\n",
        "\n",
        "print(joiner2(dic1, dic2))\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Programmation orientée objet"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 1\n",
        "Définissez une classe, **Boule**, qui représente une seule boule de glace. Chaque boule doit avoir un seul attribut, **gout**, une chaîne que vous pouvez initialiser lorsque vous créez une instance de Boule.\n",
        "\n",
        "Une fois votre classe créée, écrivez une fonction **creerBoules** qui crée des instances de la classe Boule à l'aide d'une liste passée en paramètre, chacune avec un goût différent (```['chocolat', 'vanille', 'fraise']```). Placez ces instances dans une liste appelée boules et renvoyez la liste.\n",
        "\n",
        "Enfin, appelez la fonction **creerBoules** et itérez sur la liste renvoyée, en affichant le goût de chaque boule de glace que vous avez créée."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "class Boule:\n",
        "    def __init__(self, gout):\n",
        "        self.gout = gout\n",
        "\n",
        "    def __str__(self):\n",
        "        return self.gout\n",
        "\n",
        "\n",
        "def creerBoules(gouts):\n",
        "    boules = []\n",
        "    for gout in gouts:\n",
        "        boule = Boule(gout)\n",
        "        boules.append(boule)\n",
        "    return boules\n",
        "\n",
        "\n",
        "boules = creerBoules(['chocolat', 'vanille', 'fraise'])\n",
        "for boule in boules:\n",
        "    print(boule)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 2\n",
        "Dans l'exercice précédent, nous avons créé une classe Boule qui représente une boule de glace. Cependant, si nous voulons vraiment modéliser le monde réel, nous devons disposer d'un autre objet dans lequel nous pouvons placer les boules de glace. Créez une classe **Bol**, représentant un bol dans lequel nous pouvons mettre notre glace. Voici un exemple :\n",
        "\n",
        "```\n",
        "s1 = Boule('chocolat')\n",
        "s2 = Boule('vanille')\n",
        "s3 = Boule('fraise')\n",
        "b = Bol()\n",
        "b.ajouterBoules(s1, s2)\n",
        "b.ajouterBoules(s3)\n",
        "print(b)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "class Bol:\n",
        "    def __init__(self):\n",
        "        self.boules = []\n",
        "\n",
        "    def ajouterBoules(self, *boules):\n",
        "        for boule in boules:\n",
        "            self.boules.append(boule)\n",
        "\n",
        "    def __str__(self):\n",
        "        return \" - \".join([str(boule) for boule in self.boules])\n",
        "\n",
        "\n",
        "s1 = Boule('chocolat')\n",
        "s2 = Boule('vanille')\n",
        "s3 = Boule('fraise')\n",
        "b = Bol()\n",
        "b.ajouterBoules(s1, s2)\n",
        "b.ajouterBoules(s3)\n",
        "print(b)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 3\n",
        "Essayez de limiter le nombre de boules dans un bol à trois. En d'autres termes, vous pouvez ajouter autant de boules que vous le souhaitez lors de chaque appel à ```b.ajouterBoules```, et vous pouvez appeler cette méthode autant de fois que vous le souhaitez, mais seules les trois premières boules seront réellement ajoutées. Toutes les autres boules seront ignorées."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "class Bol:\n",
        "    def __init__(self):\n",
        "        self.boules = []\n",
        "\n",
        "    def ajouterBoules(self, *boules):\n",
        "        for boule in boules[:3]:\n",
        "            if len(self.boules) > 2:\n",
        "                break\n",
        "            self.boules.append(boule)\n",
        "    \n",
        "    def __str__(self):\n",
        "        return \" - \".join([str(boule) for boule in self.boules])\n",
        "\n",
        "\n",
        "s1 = Boule('chocolat')\n",
        "s2 = Boule('vanille')\n",
        "s3 = Boule('fraise')\n",
        "b = Bol()\n",
        "b.ajouterBoules(s1, s2, s1, s2)\n",
        "b.ajouterBoules(s3)\n",
        "print(b)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Programmation modulaire"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 1\n",
        "Écrivez un programme Python pour deviner une lettre. Vous pouvez utiliser la fonction **choice()** du module random pour choisir un élément aléatoire à partir d'une séquence spécifiée.\n",
        "\n",
        "La constante **ascii_letters** du module **string** renvoie une chaîne contenant les lettres minuscules et majuscules.\n",
        "\n",
        "Demander à l'utilisateur d'entrer une lettre et ensuite vérifier si c'est la lettre générée aléatoirement, si c'est le cas afficher \"Bravo\" sinon afficher \"Essayez à nouveau\"."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "import random\n",
        "\n",
        "lettres = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',\n",
        "           'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n",
        "lettre_a_deviner = random.choice(lettres)\n",
        "\n",
        "while True:\n",
        "    lettre_devinee = input(\"Devinez une lettre : \")\n",
        "    if lettre_devinee == lettre_a_deviner:\n",
        "        print(\"Bravo ! Vous avez deviné la lettre correcte.\")\n",
        "        break\n",
        "    else:\n",
        "        print(\"Désolé, la lettre que vous avez devinée est incorrecte. Essayez encore.\")\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 2\n",
        "Écrivez un programme Python pour générer un code hexadécimal de couleur aléatoire (par exemple \"FF0000\" pour le rouge).\n",
        "\n",
        "Afficher la couleur précédente générée aléatoirement dans une fenêtre à l'aide d'un paquet appelé **tkinter**. Remplacer la valeur spécifiée (\"#FF0000\") par la valeur appropriée.\n",
        "\n",
        "```\n",
        "from tkinter import Tk\n",
        "\n",
        "gui = Tk(className=\"Couleur Aléatoire\")\n",
        "gui.geometry(\"400x300\")\n",
        "gui.configure(bg=\"#FF0000\")\n",
        "gui.mainloop()\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "from tkinter import Tk\n",
        "import random\n",
        "\n",
        "\n",
        "def random_color():\n",
        "    hex_digits = \"0123456789ABCDEF\"\n",
        "    color = \"\"\n",
        "    for i in range(6):\n",
        "        color += random.choice(hex_digits)\n",
        "    return \"#\" + color\n",
        "\n",
        "\n",
        "gui = Tk(className=\"Couleur Aléatoire\")\n",
        "gui.geometry(\"400x300\")\n",
        "gui.configure(bg=random_color())\n",
        "gui.mainloop()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exercice 3\n",
        "Créer un module nommé **guess_game** qui peut être utilisé pour deviner un nombre, une lettre ou un mot aléatoire."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "import random\n",
        "\n",
        "\n",
        "def guess_number():\n",
        "    secret_number = random.randint(1, 6)\n",
        "    print(\"Je pense a un nbr entre 1 et 6. devinez le \")\n",
        "    guess = None\n",
        "    num_guesses = 0\n",
        "\n",
        "    while guess != secret_number:\n",
        "        guess = int(input(\"Devinez un nombre : \"))\n",
        "        num_guesses += 1\n",
        "\n",
        "        if guess < secret_number:\n",
        "            print(\"plus haut \")\n",
        "        elif guess > secret_number:\n",
        "            print(\"plus bas \")\n",
        "        else:\n",
        "            print(\"t-bien, n° {} fois\".format(num_guesses))\n",
        "\n",
        "\n",
        "def guess_letter():\n",
        "    alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
        "    secret_letter = random.choice(alphabet)\n",
        "    print(\"deviner la letre \")\n",
        "    guess = None\n",
        "    num_guesses = 0\n",
        "\n",
        "    while guess != secret_letter:\n",
        "        guess = input(\"Devinez une lettre : \")\n",
        "        num_guesses += 1\n",
        "\n",
        "        if guess < secret_letter:\n",
        "            print(\"Trop tôt \")\n",
        "        elif guess > secret_letter:\n",
        "            print(\"Trop tard \")\n",
        "        else:\n",
        "            print(\"tbien n° coups {}\".format(num_guesses))\n",
        "\n",
        "\n",
        "def guess_word():\n",
        "    word_list = [\"python\", \"java\", \"ruby\", \"zozo\", \"lool\"]\n",
        "    secret_word = random.choice(word_list)\n",
        "    print(\"deviner un des mot suivant python, java, ruby, zozo, lool \")\n",
        "    guess = None\n",
        "    num_guesses = 0\n",
        "\n",
        "    while guess != secret_word:\n",
        "        guess = input(\"Devinez un mot : \")\n",
        "        num_guesses += 1\n",
        "\n",
        "        if guess < secret_word:\n",
        "            print(\"Trop tôt  \")\n",
        "        elif guess > secret_word:\n",
        "            print(\"Trop tard \")\n",
        "        else:\n",
        "            print(\"tbien coup n° {}\".format(num_guesses))\n",
        "\n",
        "\n",
        "guess_number()\n",
        "guess_letter()\n",
        "guess_word()"
      ]
    }
  ],
  "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.10.4"
    },
    "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 2
}