{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1><center><span style=\"border-style:solid;border-width:1px;border-radius:5px;\n",
    "    padding:5px;background-color:yellow;box-shadow: 6px 6px 6px black;\">Activité 1 - Bases du langage Python</span></center></h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Sommaire</h2>\n",
    "<ol>\n",
    "    <li>\n",
    "        <a href=\"#partie1\">Nombres et calculs</a>\n",
    "    </li>\n",
    "    <li>\n",
    "        <a href=\"#partie2\">Variables et affectations</a>\n",
    "    </li>\n",
    "    <li>\n",
    "        <a href=\"#partie3\">Chaînes de caractères</a>\n",
    "    </li>\n",
    "    <li>\n",
    "        <a href=\"#partie4\">Saisie de l'entrée utilisateur</a>\n",
    "    </li> \n",
    "    <li>\n",
    "        <a href=\"#partie5\">Résumé</a>\n",
    "    </li> \n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border:solid purple 1px; border-radius:5px; padding: 5px;\"><p style=\"text-align:justify;\">On présente ici les bases du langage <strong>Python</strong> : calculs, variables, affichage, saisie, type de données.\n",
    "Les fonctionnalités un peu plus avancées telles que les instructions conditionnelles, les boucles, les fonctions ou les listes seront étudiées dans les chapitres suivants.</p>\n",
    "<p style=\"text-align:justify;\">Le langage Python a été créé par le néerlandais Guido van Rossum en 1991.<br>\n",
    "    Il existe de nombreux langages de programmation (voir <a href=\"https://www.tiobe.com/tiobe-index/\">ce site</a> qui indique la popularité des langages au cours du temps). Parmi les avantages du langage Python, on peut citer :</p>\n",
    "<ul>\n",
    "    <li>facile à apprendre ; Python est devenu le langage privilégié pour l'enseignement de la programmation dans les lycées du monde entier.</li>\n",
    "    <li>syntaxe simple et courte (cette simplicité a aussi ses limites)</li>\n",
    "    <li>puissant, de haut niveau et polyvalent (réseau, images, interfaces graphiques, etc.)</li>\n",
    "    <li>très utilisé dans le domaine du \"Deep Learning\" et plus généralement de l'intelligence artificielle</li>\n",
    "</ul>\n",
    "<p style=\"text-align:justify;\">Si le langage Python n'avait que des avantages, les autres langages concurrents auraient disparu. Le principal défaut de Python est sa relative lenteur par rapport à d'autres langages comme C/C++ ou Java. La vérification des types peut aussi poser quelques problèmes au niveau de la fiabilité des programmes (pas de compilation préalable donc détection de certaines erreurs au moment de l'exécution seulement) et de la maintenance. Enfin ce langage est peu adapté à la programmation sur smartphone.</p></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"partie1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"text-decoration:underline;\" id=\"partie1\">1- Nombres et calculs</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python permet d'effectuer tout type de calcul, comme une calculatrice ordinaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "trusted": false
   },
   "outputs": [],
   "source": [
    "5 + 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les règles de priorité des calculs sont les mêmes qu'en mathématiques. On utilise des parenthèses lorsqu'on a besoin de changer l'ordre de priorité. Le symbole de la multiplication est * (afin qu'il n'y ait pas de confusion avec la lettre x)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 1 : </strong> Dans une école, il y a trois classes : <ul>\n",
    "    <li>Classe A : 32 élèves</li>\n",
    "    <li>Classe B : 27 élèves</li>\n",
    "    <li>Classe C : 34 élèves</li>\n",
    "</ul>  <br> \n",
    "Chaque élève de l'école doit recevoir 192 photocopies.<br>\n",
    "Combien faut-il prévoir de photocopies en tout ?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17856"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(32+27+34)*192"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une des particularités du langage Python est que le nombre de chiffres n'est pas limité pour les nombres entiers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 2 : </strong> Calculer le produit de deux nombres à 10 chiffres. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "77636554580752591722"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9838366282*7891203921"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour calculer une <strong>puissance</strong>, on utilise la notation ** . Par exemple pour calculer 7 au carré, on écrira 7**2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 3 : </strong> Calculer 6 au cube de deux manières différentes : en utilisant une puissance et sans utiliser de puissance. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "216"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6*6*6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "216"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<strong>Types numériques</strong>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe deux types de nombres en Python : les <strong>entiers</strong> (<code>int</code>, abréviation de \"integer\") et les <strong>flottants</strong> (<code>float</code>, abréviation de \"floating number\" qui signifie \"nombre à virgule flottante\")."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction <code>type()</code> indique le type du nombre qu'on lui donne en paramètre :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(5.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**La division**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe deux types de division en Python : la division entière avec l'opérateur // et la division flottante avec l'opérateur / .<br>\n",
    "L'opérateur % permet d'obtenir le reste dans une division entière."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "13 // 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.6"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "13 / 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "13 % 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 4 : </strong> En utilisant les opérateurs précédents, écrire 437 secondes au format minutes:secondes.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nombre de minutes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "437//60"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nombre de secondes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "437%60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 : 17\n"
     ]
    }
   ],
   "source": [
    "print(437//60,\":\",437%60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<strong>Nombres aléatoires</strong>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:justify;\">Les fonctions concernant les nombres aléatoires ne font pas partie des fonctions de base du langage Python. Pour pouvoir les utiliser, on doit commencer par donner l'accès à une bibliothèque de fonctions appelée <code>random</code> (\"random\" signifie \"aléatoire\") au moyen de l'instruction <code>import random</code>.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "trusted": false
   },
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.randint(4,7)  # Ceci renvoie un entier choisi au hasard entre 4 et 7 inclus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi importer toutes les fonctions de la bibliothèque <code>random</code> d'un seul coup, ce qui permet d'éviter d'écrire le préfixe <code>random.</code> lorsqu'on utilise une de ces fonctions :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import *\n",
    "randint(2,9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 5 : </strong> Simuler le lancer de deux dés et afficher la somme obtenue.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "randint(1,6)+randint(1,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction <code>random()</code> renvoie une nombre aléatoire compris entre 0 et 1, de type <code>float</code> :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5798081527413247"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random() # nombre aléatoire compris entre 0 et 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.615012619849558"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random() * 8 # nombre aléatoire compris entre 0 et 8 (de type float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"partie2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"text-decoration:underline\" id=\"partie2\">2- Variables et affectations</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les **variables** permettent de stocker des données (nombre ou résultat d'un calcul) en mémoire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 2    # on affecte la valeur 2 à la variable a\n",
    "b = 5\n",
    "c = a + b\n",
    "a = 3\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le contenu des variables persiste en mémoire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afficher une variable qui n'a pas encore été définie ou déclarée provoque une erreur :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'd' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[22]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43md\u001b[49m\n",
      "\u001b[31mNameError\u001b[39m: name 'd' is not defined"
     ]
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 6 : </strong> Ecrire un algorithme qui échange le contenu des variables a et b ci-dessous (trois lignes à compléter).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "trusted": false
   },
   "outputs": [],
   "source": [
    "a = 7\n",
    "b = 4\n",
    "c=b\n",
    "b=a\n",
    "a=c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 7 : </strong> Quel est le rôle de l'algorithme ci-dessous ? Prouvez-le!</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "trusted": false
   },
   "outputs": [],
   "source": [
    "a = 7\n",
    "b = 4\n",
    "a = a + b\n",
    "b = a - b\n",
    "a = a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Syntaxe abrégée** <br>\n",
    "On a souvent besoin d'**incrémenter** une variable (augmenter sa valeur de 1) ou de la décrémenter (diminuer sa valeur de 1).<br>\n",
    "Au lieu d'écrire <code>a = a + 1</code>, on peut écrire de façon plus courte : <code>a += 1</code>.<br>\n",
    "Cette syntaxe raccourcie fonctionne pour n'importe quelle valeur de l'incrément, ainsi que pour les opérateurs <code>+ , - , *, / , // et %</code>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 8 : </strong> En utilisant la syntaxe abrégée, ajouter 37 à la variable a ci-dessous, puis multiplier sa valeur par 2.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "trusted": false
   },
   "outputs": [],
   "source": [
    "a = 9\n",
    "a=a+37\n",
    "a=a*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"partie3\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"text-decoration:underline;\" id=\"partie3\";>3- Chaînes de caractères</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:justify;\">La fonction <code>print()</code> permet d'afficher une chaîne de caractères (\"string\" en anglais).\n",
    "La chaîne de caractère que l'on souhaite afficher doit être écrite entre guillemets (simples ' double \" ou triples '''). Sans guillemets, c'est le contenu de la variable dont le nom est transmis en paramètre qui sera affiché.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bonjour\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "bonjour = 8\n",
    "print(\"bonjour\")\n",
    "print(bonjour)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 9 : </strong> Ecrire une ligne de programme qui affiche le message \"Au revoir!\". \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Au revoir !\n"
     ]
    }
   ],
   "source": [
    "print(\"Au revoir !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "trusted": true
   },
   "source": [
    "Une variable peut contenir une chaîne de caractères :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "coucou\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message = \"coucou\"\n",
    "print(message)\n",
    "type(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut afficher plusieurs chaînes de caractères à l'aide d'une seule instruction <code>print()</code>. Par défaut, un espace sera inséré entre chaque chaîne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vous avez 32 ans.\n"
     ]
    }
   ],
   "source": [
    "age = 32\n",
    "print(\"Vous avez\",age,\"ans.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plutôt qu'un espace, on peut insérer :\n",
    "* un autre caractère (par exemple un point-virgule)\n",
    "* plusieurs caractères (par exemple \" et \")\n",
    "* aucun caractère (les chaînes seront \"collées\")\n",
    "* un saut de ligne (que l'on écrit \"\\n\", et qui signifie \"new line\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Victor;Léa;Ninon\n",
      "Victor et Léa et Ninon\n",
      "VictorLéaNinon\n",
      "Victor\n",
      "Léa\n",
      "Ninon\n"
     ]
    }
   ],
   "source": [
    "print(\"Victor\",\"Léa\",\"Ninon\",sep=\";\")     # le séparateur sera le caractère point-virgule (;)\n",
    "print(\"Victor\",\"Léa\",\"Ninon\",sep=\" et \")\n",
    "print(\"Victor\",\"Léa\",\"Ninon\",sep=\"\")      # aucun sépérateur, pas même un espace\n",
    "print(\"Victor\",\"Léa\",\"Ninon\",sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 10 : </strong> Ecrire une instruction qui affiche une liste de courses séparées par un tiret. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "concombre-citron-navet\n"
     ]
    }
   ],
   "source": [
    "print(\"concombre\",\"citron\",\"navet\",sep=\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on ne souhaite pas passer à la ligne suivante pour la prochaine instruction <code>print</code>, on peut l'indiquer au moyen du paramètre <code>end=\"\"</code> :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Victor\n",
      "Léa\n",
      "Ninon\n",
      "VictorLéaNinon\n"
     ]
    }
   ],
   "source": [
    "print(\"Victor\")\n",
    "print(\"Léa\")\n",
    "print(\"Ninon\")\n",
    "print(\"Victor\",end=\"\")\n",
    "print(\"Léa\",end=\"\")\n",
    "print(\"Ninon\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut **concaténer** (fusionner) plusieurs chaînes de caractère au moyen de l'opérateur <code>+</code> :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonjour Madame\n",
      "Bonjour Madame!\n"
     ]
    }
   ],
   "source": [
    "message1 = \"Bonjour \"\n",
    "message2 = \"Madame\"\n",
    "message3 = message1 + message2\n",
    "print(message3)\n",
    "message3 += \"!\"    # la syntaxe abrégée fonctionne aussi pour la concaténation de chaînes de caractères\n",
    "print(message3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On ne peut pas concaténer une chaîne de caractères avec une valeur numérique directement. Il faut au préalable transformer la valeur numérique en chaîne de caractères au moyen de la fonction <code>str()</code> :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "J'ai 25 ans.\n"
     ]
    }
   ],
   "source": [
    "âge = 25\n",
    "début = \"J'ai \"\n",
    "fin = \" ans.\"\n",
    "phrase = début + str(âge) + fin\n",
    "print(phrase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"partie4\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"text-decoration:underline;\" id=\"partie4\";>4- Saisie de l'entrée utilisateur</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut demander à l'utilisateur de saisir une valeur avec la fonction <code>input()</code>. La valeur renvoyée par la fonction <code>input()</code> est du type **chaîne de caractères** (string). On peut ajouter en paramètre facultatif un message qui donne des précisions sur la valeur attendue :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "37\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "a = input()\n",
    "b = input(\"Entrez votre âge : \")\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on souhaite utiliser la valeur saisie pour effectuer des calculs, on doit d'abord convertir cette chaîne en **entier** avec la fonction <code>int()</code> ou en **flottant** avec la fonction <code>float()</code> :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dans 5 ans, vous aurez 23 ans\n"
     ]
    }
   ],
   "source": [
    "réponse = input(\"Veuillez entrer votre âge :\")\n",
    "âge = int(réponse)\n",
    "âge += 5\n",
    "print(\"Dans 5 ans, vous aurez\",âge,\"ans\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" style=\"border:solid 1px; border-radius: 5px\"><strong>Exercice 11 : </strong> Ecrire un programme qui demande à l'utilisateur d'entrer le rayon d'un cercle et qui affiche son périmètre.<br>\n",
    "<em>Le programme doit fonctionner pour des valeurs non entières du rayon, et devra afficher une phrase de réponse complète se terminant par un point</em>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "62.83185307179586\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "math.pi   # Ceci renvoie le nombre pi\n",
    "\n",
    "R=float(input(\"Donne le rayon du cercle\"))\n",
    "print(2*math.pi*R)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "trusted": true
   },
   "source": [
    "<div id=\"partie5\" style=\"background-color: rgb(250,250,190); padding:10px; border:solid 2px; border-radius:5px;border-color:purple\">\n",
    "    \n",
    "<h2>Résumé</h2>\n",
    "    \n",
    "<h4 style=\"color:purple;text-decoration:underline\">Opérations mathématiques</h4>\n",
    "Multiplication : <code>*</code> <br>\n",
    "Division ordinaire : <code>/</code>   <br>\n",
    "Division entière : <code>//</code>  <br>\n",
    "Reste (modulo) : <code>%</code>  <br>\n",
    "Puissance : <code>**</code>   (exemple : <code>2**3</code> pour \"2 au cube\")\n",
    "\n",
    "<h4 style=\"color:purple;text-decoration:underline\">Types de variables</h4>\n",
    "int (integer) : nombre entier<br>\n",
    "float (flottant) : nombre à virgule<br>\n",
    "str (string) : chaîne de caractères\n",
    "\n",
    "<h4 style=\"color:purple;text-decoration:underline\">Incrémenter une variable</h4> \n",
    "    <code>a = a + 1</code><br>\n",
    "Syntaxe abrégée : <code>a += 1</code><br>\n",
    "Concaténation de chaînes : <code>\"bon\"</code> + <code>\"jour\"</code> donne <code>\"bonjour\"</code>\n",
    "\n",
    "<h4 style=\"color:purple;text-decoration:underline\">Affichage</h4>\n",
    "Fonction <code>print()</code><br>\n",
    "On peut rajouter des paramètres <code>sep</code> (séparateur) et <code>end</code> (fin).<br>\n",
    "Exemple : <code>print(\"a\",\"b\",\"cd\",sep=\"-\",end=\"@\")</code> donne\n",
    "    <code>a-b-cd@</code>\n",
    "    \n",
    "<h4 style=\"color:purple;text-decoration:underline\">Saisie utilisateur</h4>\n",
    "<code>réponse = input(\"Saisissez une valeur : \")</code><br>\n",
    "    (la réponse est une chaîne de caractères)    \n",
    "    \n",
    "<h4 style=\"color:purple;text-decoration:underline\">Changer le type d'une variable</h4>\n",
    "<code>int(chaine)</code> : transforme une chaîne de caractère en int<br>\n",
    "<code>float(chaine)</code> : transforme une chaîne en float<br>\n",
    "<code>str(nombre)</code> : transforme un nombre en chaîne de caractères\n",
    "    \n",
    "<h4 style=\"color:purple;text-decoration:underline\">Nombres aléatoires</h4> \n",
    "    module <code>random</code><br>\n",
    "<code>randint(a,b)</code> : renvoie un nombre entier aléatoire entre a et b (inclus).<br>  \n",
    "</div>"
   ]
  }
 ],
 "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": 2
}