{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programmation Python : interagir avec l'utilisateur\n",
    "\n",
    "Avec la carte Micro:Bit sur laquelle nous avons fait nos débuts en Python (plus précisemment en MicroPython), l'interaction avec l'utilisateur peut se faire :\n",
    "\n",
    "* en entrée : \n",
    "    - avec les boutons poussoirs A et B\n",
    "    - avec le module accéléromètre (détection de mouvement)\n",
    "* en sortie :\n",
    "    - avec l'afficheur 5x5 Leds\n",
    "\n",
    "Les boutons poussoirs ainsi que l'afficheur 5x5 Leds constituent l'**Interface Homme Machine** (ou **IHM**) de la carte Micro:Bit\n",
    "    \n",
    "Lorsque l'on veut faire un logiciel qui tourne sur un ordinateur, on peut opter pour un logiciel :\n",
    "* en mode texte\n",
    "* en mode graphique (l'utilisateur se retouve devant une fenêtre qui permet par exemple l'usage de la souris pour cliquer sur différents objets : boutons, case à cocher, ascenceurs etc...)\n",
    "\n",
    "Pour démarrer, il est préférable de réaliser des programmes dont la sortie est en mode texte, même si au niveau visuel cela peut paraître un peu \"décevant\" par rapport à ce que l'on a l'habitude de rencontrer.\n",
    "\n",
    "Dans ce mode, pour interagir avec l'utilisateur, on disposera de deux fonctions :\n",
    "* en entrée :\n",
    "    - la fonction input() qui attendra de l'utilisateur une entrée au clavier\n",
    "    \n",
    "* en sortie :\n",
    "    - la fonction print() qui affichera à l'écran des caractères (lettres, chiffres, symboles)\n",
    "    \n",
    "**Tous les petits exemples donnés dans ce notebook pourront être réessayés dans le logiciel Thonny** \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1- La fonction print( ) :\n",
    "\n",
    "Nous l'avons rencontrée dans le notebook d'introduction aux notebooks Jupyter sans donner de détails sur la façon de l'utiliser :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "print(a + b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exemple, on demande à l'interpréteur Python de faire la somme des valeurs associées aux variables a et b et de l'afficher avec la fonction print(). \n",
    "(Remarque : le nombre obtenu suite à la somme de a et de b est en fait converti en une **\"chaîne de caractères\" (string en anglais)** avant d'être affiché.\n",
    "\n",
    "On peut aussi demander l'affichage explicite d'un texte :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Somme de deux nombres :')\n",
    "a = 5\n",
    "b = 7\n",
    "print(a + b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...ou mieux : dans l'exemple ci-dessous, on demande à la fonction print() d'afficher deux arguments : un texte et le résultat de la somme a + b. C'est possible à condition de **séparer les deux arguments par une virgule** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Somme de deux nombres :')\n",
    "a = 1\n",
    "b = 2\n",
    "print('La somme de a et b fait : ', a + b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :**\n",
    "Compléter le code ci-dessous pour que la fonction print() renvoie:\n",
    "\n",
    "                                    a + b = 1 + 2 = 3\n",
    "                                    \n",
    "                                    (si a = 1 et b = 2)\n",
    "                                    \n",
    "(Bien sûr, si on change les valeurs de a et b, la phrase affichée devra tenir compte de ce changement!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Somme de deux nombres :')\n",
    "a = 1\n",
    "b = 2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarque : nous avons placé le texte à afficher entre apostrophes (single quotes en anglais). Mais cela pose un souci si dans le texte on a une phrase dans laquelle on doit mettre un apostrophe.\n",
    "Essayer le code suivant : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Les chaussettes de l'archiduchesse sont elles sèches ?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python propose alors une solution simple : une chaine de caractères peut être placée entre deux apostrophes ou bien entre deux guillemets (double quotes en anglais) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Les chaussettes de l'archiduchesse sont elles sèches ?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# il est également possible de dire à l'interpréteur de ne pas considérer l'apostrophe comme un guillemet simple en utilisant le caractère d'échappement antislash : \\\n",
    "print('Les chaussettes de l\\'archiduchesse sont elles sèches ?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2- La fonction input( ):\n",
    "Cette fonction va attendre de l'utilisateur une entrée d'information par le clavier et sa validation par la touche Entrée.\n",
    "\n",
    "Dans VSCodium, l'entrée utilisateur est réalisée dans une petite boite de dialogue située en haut du notebook :\n",
    "\n",
    "![title](images/vscodium_input.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nom = input('Quel est ton nom ? ')\n",
    "print('Bonjour', nom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Essayons de voir ce que cela donne avec des nombres :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nom = input('Quel est ton nom ? ')\n",
    "print('Bonjour', nom)\n",
    "print('')\n",
    "annee_naissance = input('Quelle est ton année de naissance ? ')\n",
    "print(\"Si j'ai bien lu \", nom, ' tu es né(e) en ', annee_naissance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cela semble fonctionner aussi avec les nombres, mais ...\n",
    "essayer de compléter le code ci-dessous pour qu'il affiche l'âge de l'utilisateur, calculé à partir de l'année de naissance entrée :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nom = input('Quel est ton nom ? ')\n",
    "print('Bonjour', nom)\n",
    "print('')\n",
    "annee_naissance = input('Quelle est ton année de naissance ? ')\n",
    "# code à compléter :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si cela ne fonctionne pas, c'est parce que la foncion input() renvoie par défaut une **chaîne de caractères (string en anglais)**. Ainsi, une année écrite de façon usuelle, comme par exemple 2003 :\n",
    "\n",
    "    - n'est pas interprétée comme le nombre \"deux mille trois\"\n",
    "    \n",
    "    - mais comme une suite de caractères : 2, 0, 0 et 3\n",
    "    \n",
    "Pour pouvoir traiter cette entrée de l'utilisateur comme un nombre (et donc pouvoir faire des calculs dessus), **il faut réaliser une conversion explicite en entier avec la fonction int():**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nom = input('Quel est ton nom ? ')\n",
    "print('Bonjour', nom)\n",
    "print('')\n",
    "annee_naissance = int(input('Quelle est ton année de naissance ? '))\n",
    "# compléter alors ce code pour qu'il donne l'âge de l'utilisateur :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Remarque :* Il arrive que l'entrée utilisateur soit un nombre à virgule. En Python, un tel nombre est un *nombre à virgule flottante*. On utilise alors la fonction de conversion **float()** à la place de la fonction **int()**\n",
    "\n",
    "**EXERCICE 1:**\n",
    "Ecrire un programme demandant à l'utilisateur d'entrer un nombre entier \"a\" puis un nombre entier \"b\". Le programme calcule alors la somme des deux et affiche le résultat de façon explicite :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tout est à faire ci-dessous ...\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3- Pour aller un peu plus loin :\n",
    "\n",
    "**EXERCICE 2:**\n",
    "Ecrire un programme demandant à l'utilisateur d'entrer un nombre entier \"a\" puis un nombre entier \"b\". \n",
    "\n",
    "Avec ses deux nombres, le programme calcule alors :\n",
    " - la somme (a + b), \n",
    " - la différence (a - b), \n",
    " - le produit (a.b), \n",
    " - la division (a/b) \n",
    "    \n",
    "et affiche les résultats de façon explicite.\n",
    "\n",
    "Votre programme est-il exempt de bugs ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ecrire et tester ici votre programme :\n",
    "???\n",
    "...\n",
    "??? "
   ]
  }
 ],
 "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.3-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}