test1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Premier note-book Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": false
   },
   "source": [
    "# Types de variables\n",
    "\n",
    "Jusqu’alors, en mathématiques, tu n’as utilisé (sur ta calculatrice ou sur Algobox) que des\n",
    "variables de type « nombre ». Python distingue plusieurs types de variables, voici les\n",
    "principaux :\n",
    "## Le type *bool*\n",
    "Il sert à représenter les variables booléennes : une variable de type *bool* est une valeur\n",
    "logique et vaut *True* (vrai) ou *False* (faux).\n",
    "\n",
    "On peut d'abord *déclarer* la variable en donnant son type, à ce moment elle est initialisée avec une valeur par défaut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": false
   },
   "outputs": [],
   "source": [
    "a = bool()  # déclare une variable de type bool\n",
    "print(a)  # affiche la valeur par défaut de a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": false
   },
   "source": [
    "En général en Python, on déclare une variable en même temps qu'on lui affecte une valeur. Python détermine tout seul le type qui convient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = True  # on déclare b en même temps qu'on lui affecte une valeur\n",
    "print(b)  # affiche la valeur de b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>À FAIRE :</font>\n",
    "\n",
    "Dans les 2 cellules suivantes, déclare une variable c de type *bool* qui vaut *True* et une variable d de type *bool* qui vaut *False*.\n",
    "\n",
    "Affiche les."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les *bool* servent très souvent lorsqu’on veut tester si une condition est vraie ou non. (on\n",
    "y reviendra plus tard).\n",
    "\n",
    "Avec les *bool* , on dispose d’opérations logiques : *or* (ou), *and* (et) et *not* (non)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not a or b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>À FAIRE :</font>\n",
    "\n",
    "Evalue dans les 3 cellules suivantes ce que vaut  *c or d*, *c and d*, *c and not d*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c or d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c and d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c and not d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>À FAIRE :</font>\n",
    "\n",
    "Evalue *not  c and d* et ensuite *not(c and d)*.\n",
    "\n",
    "Que peux-tu en conclure ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Conclusion:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le type *int*\n",
    "\n",
    "Il sert à représenter les *entiers relatifs* (*integer* signifie « entier » en Anglais).\n",
    "\n",
    "Sur les *int* , on dispose des opérations + (addition), - (soustraction), * multiplication."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = int()  # on peut déclarer la variable de type int sans l'initialiser\n",
    "print(a)  # elle prend une valeur par défaut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 3  # déclare une variable b de type int qui vaut 3\n",
    "c = 2\n",
    "print(b + c)  # évalue b+c puis affiche le résultat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 2 * b - c  # évalue 2*b-c et puisque c'est un entier,\n",
    "# déclare d comme variable de type int\n",
    "# et lui affecte la valeur 2*b-c\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>À FAIRE :</font>\n",
    "\n",
    "Déclare x qui vaut 2, y qui vaut -3 et z qui vaut 7, puis t qui vaut 2x+3y-6z et affiche sa valeur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On dispose également de deux opérations très pratiques : soient a et b deux *int* , et b non\n",
    "nul, alors on peut effectuer la *division euclidienne* de a par b .\n",
    "\n",
    "a//b est le quotient et a%b est le reste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(64//10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(64%10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(23//7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(23%7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On dispose de l’opération d’*exponentiation* (opération puissance), notée ** .\n",
    "\n",
    "**Attention:** Cette opération peut produire un résultat non-entier, de type *float* (voir partie\n",
    "suivante)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 ** 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(10 ** 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 **(-1))  # ici le résultat n'est pas un entier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour finir, la division décimale peut être effectuée sur des entiers, mais elle renvoie un\n",
    "résultat de type *float*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(4/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le type *float*\n",
    "\n",
    "Il sert à représenter les nombres à virgule flottante (*to float* : flotter en Anglais). Ce sont des nombres décimaux (pas tout à fait, on y reviendra plus tard).\n",
    "\n",
    "Python comprend et utilise la notation scientifique :\n",
    "2.35e6 vaut $2,35 \\times 10^6$ , c’est-à-dire 2 350 000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = float() # un float est déclaré qui aura par défaut la valeur 0\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 3/2 # Python évalue 3/2, voit que c'est un float, donc déclare b comme float valant... 3/2\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 13.0 # si on écrit 13 tout court on aura un int\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 1.2e-4 # idem mais avec une notation scientifique\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour les opérations plus compliquées (racine carrée, cosinus, logarithme etc) on fait appel au module *math* :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt # on importe la fonction sqrt depuis le module math\n",
    "# sqrt est la racine carrée (square root en Anglais)\n",
    "\n",
    "a = sqrt(65)\n",
    "print(a) # évidemment c'est une valeur qpprochée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(pi) # Python ne connait pas pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi # mais on peut le trouver dans le module math\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import * # permet d'importer TOUTES les fonctions du module math\n",
    "print(cos(pi/3))\n",
    "print(exp(log(2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>À FAIRE :</font>\n",
    "\n",
    "On veut calculer la norme du vecteur de l'espace de coordonnées $(11,16,8)$ :\n",
    "* déclarer 3 *float* x, y et z valant 11,16 et 8;\n",
    "* déclarer le *float* n tel que $$n=\\sqrt{x^2+y^2+z^2}$$ et afficher la valeur de n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Le type *str*\n",
    "Il sert à représenter les chaînes de caractères ( *str* est l’abréviation de *string*, qui\n",
    "veut dire chaîne en anglais). des apostrophes, ou des guillemets)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = str() # déclaration sans initialisation\n",
    "print(a) # a contient la chaîne vide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 'Bonjour'\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 'J'aime Python' #déclenche une erreur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=\"J'aime Python\" #est valide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=\"\"\"J'aime qu'on m'appelle \"Le Roi du Python\".\"\"\" # dans les cas extrêmes\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi utiliser le *symbole d'échappement* \\\\ (backslash en Anglais, accessible avec ALT GR+8) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b='J\\'aime qu\\'on m\\'appelle \\\"Le Roi du Python\\\".'\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut additionner 2 variables de type *str* , on peut aussi multiplier une variable de type\n",
    "*str* par un *int*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=\"to\"\n",
    "b=\"fu\"\n",
    "print(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(b+a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a*2+b*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>À FAIRE :</font>\n",
    "\n",
    "À l'aide des variables précédentes, comment afficher tototofutotofutotofufu de manière simple ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut accèder à chaque caractère d'une variable de type *str*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chaine = 'Bonjour!'\n",
    "print(chaine[0])\n",
    "print(chaine[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici comment Python représente la chaîne précédente :\n",
    "\n",
    "|i           |0|1|2|3|4|5|6|7|\n",
    "|------------|-|-|-|-|-|-|-|-|\n",
    "|chaine\\[i\\] |B|o|n|j|o|u|r|!|\n",
    "\n",
    "Les espaces comptent aussi pour un caractère.\n",
    "\n",
    "Il faut remarquer que **l'indexation commence à 0 et non à 1**.\n",
    "\n",
    "On a parfois besoin de connaître la longueur (*length* en Anglais) d'une chaîne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_chaine=\"Salut ça va ?\"\n",
    "print(len(ma_chaine))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin on peut accéder directement au dernier (ou à l'avant dernier) caractère d'une variable de type *str* :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_chaine=\"M'enfin ?!\"\n",
    "print(ma_chaine[-1])\n",
    "print(ma_chaine[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enfin on peut vouloir extraire une sous-chaîne d’une chaine : \n",
    ">chaine\\[p :q\\] renvoie la sous-chaine de caractère qui commence par chaine\\[p\\] et qui se termine par chaine\\[q-1\\] :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_chaine=\"Salut la compagnie !\"\n",
    "print(ma_chaine[1:4]) # affiche la chaine qui commence au caractère d'indice 1 jusqu'à celui d'indice 4 exclu, donc d'indice 3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>À FAIRE :</font>\n",
    "\n",
    "Inspire-toi de l'exemple précédent pour afficher \"RSTUV\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_chaine=\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\" #à toi de jouer\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deux derniers \"trucs\" : pour obtenir la chaîne qui commence au début, pas besoin de préciser le 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Salu\n"
     ]
    }
   ],
   "source": [
    "ma_chaine=\"Salut à tous !\"\n",
    "print(ma_chaine[:4]) #affiche la chaine du caractère 0 au caractère 3\n",
    "# équivaut à ma_chaine[0:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encore mieux : pour obtenir une chaîne qui se termine à la fin de la chaîne de départ, pas besoin de préciser l'indice du caractère de fin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t à tous !\n"
     ]
    }
   ],
   "source": [
    "print(ma_chaine[4:]) #affiche la chaine qui commence au caractère d'indice 4.\n",
    "# équivaut à print(ma_chaine[4:len(ma_chaine)]) ... ouf, c'est plus rapide."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le type *list*\n",
    "Il représente des *listes ordonnées* dont les éléments sont indexés par 0, 1,2 etc.\n",
    "Si a est une variable de type *list*, on accède aux éléments de a avec a\\[0\\], a\\[1\\], comme avec les *str*.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_liste=list()\n",
    "print(ma_liste) # on va afficher une liste vide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(ma_liste[0]) # va produire une erreur car IL N'Y A PAS d'élémént d'indice 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_liste[0]=2 # pas possible de créer un élément à la volée non plus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_liste=[20,18,14,16] #voilà comment faire pour définir une liste, avec des crochets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(ma_liste[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut mettre ce que l'on veut dans une liste, y compris des éléments de types différents :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_liste=[20, 3/4, \"stylo\", True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ma_liste=[[1, 2, 3], [11, 12, 13]] # une liste à 2 éléments, chacun étant une liste à 3 éléments !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'exemple précédent est très courant, il sert à représenter un \"tableau de nombres à deux dimensions\" (en mathématique cela correspond à une *matrice*) :\n",
    "\n",
    "$$\\left(\n",
    "\\begin{matrix} \n",
    "1 & 2 & 3\\\\\n",
    "11 & 12 &13\\\\ \n",
    "\\end{matrix}\\right)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tout comme avec les *str* on peut ajouter des listes et les multiplier par un *int*.\n",
    "\n",
    "On reviendra plus tard sur ce type très utile."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le type *dict*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est l'abréviation de *dictionary* (dictionnaire en Français).\n",
    "\n",
    "Un *dict* est une correspondance *clé-valeur*. Les clés doivent cependant être uniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre_de_pattes = {\"homme\":2,\"chien\":4,\"loup\":4,\"abeille\":6} # les accolades servent à définir des dict\n",
    "print(nombre_de_pattes[\"chien\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contrairement aux listes, on peut créer des couples *clé-valeur* à la volée :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre_de_pattes[\"araignée\"]=8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ce qu'il faut savoir pour l'instant c'est que la notion de dictionnaire est compliquée (enfin, surtout au début) mais très puissante.\n",
    "## La fonction *type* et les conversions de types\n",
    "Pour connaître (ou vérifier) le type d'une variable on peut utiliser la fonction *type* :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=\"salut\"\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=[2,3,4]\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut parfois convertir une variable en une variable d'un autre type. Cela s'appelle le *transtypage* :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=2016\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = float(a) # convertit un int en float\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = str(a) # convertit un int en float\n",
    "d=\" Super année !\"\n",
    "print(c+d) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cela peut avoir un intérêt car (entre autres) on ne peut pas toujours ajouter deux variables si elles n'ont pas le même type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=red>À FAIRE :</font>\n",
    "\n",
    "Rectifie le code de la cellule suivante à l'aide de la fonction *type*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "debut =\"Dans Stranger Things, la fille aux super-pouvoirs s'appelle : \"\n",
    "fin = 11\n",
    "print(debut+fin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ex1 :  affectations\n",
    "\n",
    "Que fait le script suivant ? (ne pas chercher à l'exécuter)\n",
    "\n",
    "a = 1\n",
    "\n",
    "b = a + 1\n",
    "\n",
    "c = 2 * b − ( a + b − 4)\n",
    "\n",
    "print(b)\n",
    "\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Réponse :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quels sont les types des variables a, b et c ?"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Réponse : \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ex2 : définition d'un *float*\n",
    "Donne 3 manières de définir un *float* valant 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ex3 : des histoires de *str*\n",
    "\n",
    "Qu'affiche le script suivant ?\n",
    "\n",
    "a='ko'\n",
    "\n",
    "b='ka'\n",
    "\n",
    "c= 'la'\n",
    "\n",
    "print(a+b+a+c)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Réponse :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ex4 : encore une histoire de *str*\n",
    "\n",
    "Qu'affiche le script suivant ?\n",
    "\n",
    "a=\"pincemi pincemoi\"\n",
    "\n",
    "b=a\\[:8\\] + \"et \" + a\\[8:\\]\n",
    "\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Réponse :"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}