1.Print-Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=right> <font color='darkblue'>Une petite introduction à Python [1/5]</font></div>\n",
    "\n",
    "----\n",
    "\n",
    "#  <font color=\"darkred\"> &#10070; Affichage à l'écran et variables [1/5]</font>\n",
    "\n",
    "## <font color=\"darkblue\"> &diams; L'instruction `print` : afficher à l'écran</font>\n",
    "Traditionnellement, lorsqu'on débute l'apprentissage d'un langage informatique, on commence par un programme qui affiche \"Hello world\" à l'écran. En langage Python, c'est l'instruction `print` qui permet d'afficher quelque chose à l'écran. \n",
    "\n",
    "**Exécuter** l'instruction ci-dessous pour vous en rendre compte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Bonjour\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Notez bien la présence des guillemets et des parenthèses, elles font partie de ce qu'on appelle la \"*syntaxe*\" du langage et doivent êtres respectées **scrupuleusement**, dans le cas contraire, Python risque fort de ne pas vous comprendre ! \n",
    "\n",
    "**Executez** les lignes d'instructions suivantes pour le voir :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Allo, Houston ? on a un problème\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print \"Il manque pas quelque chose là ?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Print(\"Attention, Python respecte les majuscules et les minuscules dans les noms d'instructions \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>&#9889; A retenir : </b> <br>\n",
    "Comme tout langage de programmation, notez que Python renvoie une erreur lorsqu'il ne comprend pas ce qu'on lui demande. Prenez l'habitude de <i>lire attentivement</i> ces messages, ils sont là pour vous aider à corriger votre code.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "1. <font color=green> <b>Corriger</b> les trois lignes d'instructions ci-dessus </font><br>\n",
    "2. <font color=green> <b>Ecrire</b> une instruction permettant d'afficher \"3*5=15\" à l'écran </font>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Taper votre instruction dans cette cellule\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Bien sûr, Python peut aussi effectuer des calculs et afficher le résultat à l'écran.\n",
    "Observez attentivement les exemples ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(7*6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(22+13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvions donc plus haut, afficher le résultat de 3*5 sans le calculer nous même :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"3*5=\",3*5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plusieurs observations sur cet exemple :\n",
    "* Il y a des guillemets autour du premier 3*5, ce qui l'affiche __tel quel__\n",
    "* Il n'y en a pas autour du deuxième, ce qui le calcule avant de l'afficher\n",
    "* La virgule permet de séparer différents items à afficher"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "3. <font color=green> <b>Ecrire</b> un programme python qui affiche à l'écran \"17*17=\" suivi du résultat de ce calcul.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Taper votre réponse ici. Exécuter pour vérifier que cela fonctionne !\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. <font color=green> <b>Tester</b> sur quelques exemples l'opération `**` par exemple calculer ``10**4``, ou  `2**3`, ou encore `7**2`. Selon vous à quelle opération mathématique correspond le symbole `**`? </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Faites vos essais ici\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. <font color=green> <b>Calculer</b> le résultat de $3+5^5-2^{10}$ </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Taper votre réponse ici\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. <font color=green> 5346123 est-il divisible par 17 ? </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Taper votre réponse ici\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=blue> &diams; Notion de variable informatique </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avant d'aller plus loin, il nous faut aborder la notion fondamentale de **variable** informatique. Commençons par un extrait du site internet [wikipedia](https://fr.wikipedia.org/wiki/Variable_(informatique)) :\n",
    "\n",
    ">*\"En informatique, les variables sont des symboles qui associent un nom (l'identifiant) à une valeur. (...).Dans la plupart des langages et notamment les plus courants, les variables peuvent changer de valeur au cours du temps (dynamique).\"*\n",
    "\n",
    "Une variable a donc un *nom* (ou identifiant) et une *valeur* **qui peut changer**. En `python`, on peut par exemple créer une variable avec l'instruction suivante :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_variable = 42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous venons de créer une varible dont le nom (ou identifiant) est `ma_variable` et dont la valeur est 42. Pour attribuer la valeur 42 à cette variable nous avons utilisé le symbole `=`, on dit que `=` est le symbole d'**affectation**.\n",
    "\n",
    "Un `print` sur une variable permet d'afficher la valeur qu'elle contient :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(ma_variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarquez l'utilisation du caractère _ pour séparer les deux mots, en effet nous devons faire quelques remarques sur l'utilisation des noms de variables :\n",
    "1. Le caractère espace n'est pas autorisé dans les noms de variables. Par exemple `ma note` n'est pas un nom de variable correct.\n",
    "2. Même si  les chiffes sont autorisées dans les noms de variables, ceux-ci doivent toujours commencer par une lettre. Par exemple, `1test` n'est pas un nom de variable correcte, mais `test1` l'est.\n",
    "3. On évitera d'utiliser des caractères accentués ou spéciaux (autres que `_`) dans les noms de variables. A titre d'exemple, `çava?`, `lycée`, `Bonjour!` et `elle&lui` sont à éviter comme noms de variable\n",
    "4. Enfin, il est fortement recommandé (cela fait partie des **bonnes pratiques de programmation** dont nous reparlerons) d'utiliser des noms de variables **explicites**. Par exemple, une variable qui va contenir votre moyenne de mathématiques pourrait s'appeler `moyenne` ou `moy`, il serait malvenu de l'appeler `prenom` ou `meteo`.\n",
    "5. Python distingue les majuscules et les miniscules, par conséquent `var` et `VAR` sont deux variables différentes\n",
    "6. Cela n'est pas obligatoire mais, il est recommandé d'insérer un espace avant et après le symbole d'affectation = dans le but d'augmenter la lisibilité de vos programmes.\n",
    "---\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>&#9889; Pour résumer : </b> <br>\n",
    "1. Ne pas utiliser de caractères spéciaux dans les noms de variables excepté le caractère _ qui se lit <i>underscore</i> <br>\n",
    "2. Les noms de variables doivent commencer par une lettre <br>\n",
    "3. Utiliser des noms de variables explicites\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "7. <font color=green> <b>Executer</b> les cellules ci-dessous.</font>\n",
    "8. <font color=green> <b>Corriger</b> les noms de variables incorrects </font>\n",
    "9. <font color=green> Une fois la correction effectuée, ré-<b>exécuter</b> les cellules en ajoutant une instruction permettant d'afficher la valeur de ces variables </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "la température = 37"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "1division = 59/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "un_nom_top! = \"Iron man\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "50% = \"cinquante pour cent\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "On peut bien sûr effectuer des calculs avec les variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = a/2\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'exécution de la cellule ci-dessus nous permet de remarquer que pour Python les nombres decimaux s'écrivent avec un point. Faites très attention, d'autant plus que comme le montre l'exemple ci-dessous, la virgule a aussi une signification pour `python` ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "un_demi = 0,5\n",
    "print(un_demi*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "10. <font color=green> Corriger l'exemple ci-dessus afin que la variable `un_demi` soit égale à $\\frac{1}{2}$ (et que donc le programme affiche 1).</font>\n",
    "11. <font color=green> Créer une variable nommée `var` et contenant 1,414. Faire afficher la valeur de `var**2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Taper votre réponse ici\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avant d'aller plus loin, intéressons nous à l'exemple suivant qui peut sembler surprenant à première vue :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 18\n",
    "a = a + 1\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La deuxième ligne `a = a + 1`, ne doit pas s'interpréter comme une égalité mathématique (elle serait alors evidemment fausse) mais en se rappellant que `=` est le symbole d'affectation. En clair, l'instruction transmise à Python est d'**attribuer à la variable `a` sa valeur augmentée de 1**. Comme `a` valait 18, elle vaut après cette affectation 19.\n",
    "Ce type d'instruction est très commune en programmation, et il faut vous y familiariser. Elle s'écrit parfois sur vos calculatrices programmables avec $\\leftarrow$ pour éviter la confusion avec le symbole `=` mathématique\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>&#9889; A retenir : </b> <br>\n",
    "En python, le symbole = sert à changer la valeur d'une variable et ne doit pas être confondu avec le symbole = mathématique. Par conséquent une instruction comme a = a + 2 signifie augmenter la valeur de a de 2.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=green> &#9998; Exercices </font>\n",
    "12. <font color=green> On rappelle que le  périmètre $p$ d'un cercle de rayon $r$ se calcule avec la formule $p=2\\pi r$. <b>Compléter</b> le programme ci-dessous qui calcule puis affiche la valeur de $p$ lors $r$ vaut 6. On prendra $\\pi=3,14$</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Programme à compléter pour afficher le périmètre d'un cercle de rayon 6\n",
    "r = 6\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "13. <font color=green> <b>Compléter</b> par une seule instruction le programme suivant de sorte que la valeur de `var` soit multipliée par 2. Vérifer en testant votre programme pour diverses valeurs initiales de var  </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Insérer une seule instruction entre les deux lignes suivantes\n",
    "var = 10 #changer cette valeur initiale pour tester le bon fonctionnement de votre programme.\n",
    "\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans la cellule ci-dessus et auparavant, vous avez pu remarqué la présence de lignes précédées par le symbole #. Ces lignes ne sont pas traitées par python, on les appelle des **commentaires**. Même si cela vous semble peu utile au début, prenez l'habitude de commenter vos programmes. Ils sont partie intégrante des bonnes pratiques de programmation et permettent notamment (mais pas seulement) d'expliquer à un relecteur éventuel votre démarche.\n",
    "\n",
    "14. <font color=green> On dispose de deux variables `ancien_prix` et `reduction` on veut calculer la valeur de `ancien_prix` lorsqu'on lui applique une réduction de `reduction` %. <b>Compléter</b> le code ci-dessous en vous aidant des commentaires laissés pour vous</font>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compléter le code ci-dessous pour calculer le nouveau prix, tester en choisissant d'autres valeurs pour les variables\n",
    "ancien_prix = 200\n",
    "reduction = 30 #attention la réduction est en pourcentage\n",
    "#Pour calculer le nouveau prix, il faut multiplier l'ancien par  (1-reduction/100)\n",
    "nouveau_prix =      #Compléter cette ligne\n",
    "print(nouveau_prix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "15. <font color=green> Le programme ci-dessous ne fonctionne pas, son auteur ne semble avoir respecté ni la syntaxe du langage ni les bonnes pratiques de programmation. Essayer de comprendre l'intention de l'auteur, puis corriger ce code **en prenant des noms de variables explicites** et y laisser des commentaires pour expliquer ce qu'il fait.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7p= 120\n",
    "$e =19\n",
    "m=0,5 * p * e\n",
    "Print la surface du triangle est \",m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "16. <font color=\"green\"> On donne le programme de calcul suivant : <br>\n",
    "    &#10112; Choisir un nombre <br>\n",
    "    &#10113; Ajouter 3 à ce nombre <br>\n",
    "    &#10114; Multiplier par le nombre choisi au départ <br>\n",
    "    &#10115; Soustraire 9 <br> \n",
    "    Ecrire en python ce programme de calcul.<br>\n",
    "    Est-il possible d'écrire ce programme de calcul en n'utilisant  qu'une seule variable ?</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ecrire votre programme ci-dessous\n",
    "nombre = 10  #Ici on entre le nombre choisi au départ\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "17. <font color=green><b>Ecrire</b> et tester un algorithme en langage Python que échange les valeurs de deux variables (Nombres quelconques) A et B entrées en début de programme. Ainsi, par exemple, si A vaut 1 et B vaut 3 en entrée, on obtient comme affichage après exécution A = 3 et B = 1.</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ecrire votre programme ci-dessous\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>&#9889; A retenir : </b> <br>\n",
    "Prenez l'habitude d'utiliser des noms de variables explicites et de laisser des commentaires dans vos programmes !\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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}