1_Introduction.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "1_Introduction.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "Nx49_9RZwiWR"
      ],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/titsitits/Python_Data_Science/blob/master/1_Introduction.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DfQ-d2onvooo",
        "colab_type": "text"
      },
      "source": [
        "Mickaël Tits\n",
        "CETIC\n",
        "mickael.tits@cetic.be"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gT78kDJQYzEH",
        "colab_type": "text"
      },
      "source": [
        "# Chapitre 1 - Introduction au langage de programmation Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FlKvA2FSt-C1",
        "colab_type": "text"
      },
      "source": [
        "# Pourquoi Python ?\n",
        "1. C'est un langage **interprété**: lorsqu'on écrit une instruction, on peut directement l'exécuter. A l'opposé, un langage **compilé** nécessite l'écriture (et la compilation) d'un programme entier avant de pouvoir le tester. Un langage interprété permet de programmer plus facilement, **de manière interactive**, de tester facilement un morceau de code. C'est donc un langage idéal pour rapidement développer et tester des prototypes, ou plus particulièrement, des algorithmes d'analyse de données.\n",
        "\n",
        "2. C'est un langage **haut-niveau**: une seule ligne de code permet dans certains cas de réaliser des processus complexe, en cachant les détails liés notamment à la gestion ou la représentation des données dans la mémoire de l'ordinateur, ou les opérations arithmétiques ou binaires de bas-niveau. Un langage de haut-niveau rend plus facile le développement d'un programme, et augmente donc la **productivité** (généralement au détriment de la vitesse d'exécution).\n",
        "\n",
        "3. Python est **open source**: et donc **gratuit** pour tout le monde, y compris les entreprises.\n",
        "\n",
        "4. C'est un langage **populaire**: la communauté de développeurs est très active, et on trouve facilement sur internet de la documentation et de très **nombreux exemples d'utilisation** dans tout type d'application. De plus, la communauté développe et maintient de très **nombreuses librairies** développées et/ou compatibles avec Python, permettant d'augmenter la productivité lors de l'écriture d'un programme, particulièrement dans les domaines des mathématiques et des sciences des données.\n",
        "\n",
        "![Texte alternatif…](https://github.com/titsitits/Python_Data_Science/blob/master/Images/python_stack_overflow_withsource.png?raw=true)\n",
        "\n",
        "(source: https://stackoverflow.blog/2017/09/06/incredible-growth-python/)\n",
        "\n",
        "\n",
        "Python est donc le langage idéal pour développer et tester facilement et rapidement un algorithme. Le désavantage principal est sa lenteur: l'exécution d'un langage haut-niveau et interprété est généralement plus lente que celle d'un langage compilé. \n",
        "\n",
        "Dans un contexte où la vitesse d'exécution est cruciale (e.g. pour des systèmes embarqués, ou traitement de données en temps réel, des programmes réactifs), Python n'est pas le langage idéal. A l'inverse, dans un contexte où la vitesse de développement est cruciale (développement de prototypes, d'applications business concurrentes), la productivité offerte par le langage Python en fait un bon choix."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QL889EyHjniU",
        "colab_type": "text"
      },
      "source": [
        "#Instructions\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OWwb8aHl9rn9",
        "colab_type": "text"
      },
      "source": [
        "* Les **instructions** permettent de commander l'**interpréteur** Python, c'est-à-dire un système qui comprend les instructions et les traduit en traitements sur des données binaires, représentées sous forme d'**objets** informatiques.\n",
        "* Par défaut, chaque ligne de code correspond à une instruction\n",
        "* Les instructions sont interprétées séquentiellement par l'interpréteur Python.\n",
        "* Il existe différents types d'instructions, telles que des assignations de variables, des opérations, des appels de fonctions, des conditions, des boucles, etc. que nous allons voir ci-dessous.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K9_3X5sYieOe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Assignation d'une variable, dont l'identifiant est \"prix\"\n",
        "prix = 300000\n",
        "\n",
        "#Appel d'une fonction de base, \"print\", qui permet d'imprimer la variable dans la console\n",
        "print(prix)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bTU1o58Pik_s",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#On peut écrire plusieurs instructions sur une seule ligne, en les séparant avec le symbole ;\n",
        "a = 100000; b = 200000; c = 300000\n",
        "\n",
        "#On peut écrire Une instruction sur plusieurs lignes, en la découpant avec le symbole \\\n",
        "print(a + b \\\n",
        "     + c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wF6q5rvmjEKi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Oups, la variable prix2 n'existe pas: l'interpréteur ne comprend donc pas l'instruction et renvoie un message d'erreur pour le signaler. Il faut bien sûr assigner une variable avant de l'utiliser.\n",
        "print(prix + \\\n",
        "     prix2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4aRNFha3iyA7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "prix2 = 250000\n",
        "print(prix + \\\n",
        "     prix2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EeasGouZi6ih",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "prix2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2DCdosyImaOy",
        "colab_type": "text"
      },
      "source": [
        "Les identifiants d'une variable s'écrivent en un mot, peuvent contenir des lettres, des nombres, et \"_\", mais ne peuvent pas commencer par un nombre. Ils ne peuvent pas contenir de symboles spéciaux tels que !, @, #, $, %."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dMkf4q_ojJDw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "_variable = 1\n",
        "#Oups: ces identifiants sont invalides => l'interpréteur renvoie un message d'erreur.\n",
        "2variable = 1\n",
        "v@ri@ble = 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2QZ7fUYrqcFn",
        "colab_type": "text"
      },
      "source": [
        "Certains mots-clés ne peuvent pas être utilisés comme identifiants, car ils ont une signification bien précise pour l'interpréteur python. C'est par exemple le cas de **`del`** qui est une instruction en soi, et qui permet en l'occurrence de supprimer une variable.\n",
        "Pour éviter tout risque de confusion, il est également préférable d'éviter d'utiliser comme identifiant ceux définissant déjà des fonctions de base de Python, tel que **`print`**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p7qjS2-8jvps",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Oups, j'ai redéfini une fonction de base. L'interpréteur ne comprend plus alors l'appel à la fonction.\n",
        "print = 1\n",
        "print(\"Rue de Bruxelles 61, Namur\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mXfmu6GRkInd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Supprimons la variable créée avec le mot-clé \"del\"\n",
        "del print\n",
        "#La fonction de base fonctionne de nouveau\n",
        "print(\"Rue de Bruxelles 61, Namur\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cw-8UJdPkx-Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Oups, j'ai utilisé un mot-clé comme nom de variable\n",
        "del = 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j02sjwqOttpj",
        "colab_type": "text"
      },
      "source": [
        "# Types de données de base"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OJe8qc_Qiipc",
        "colab_type": "text"
      },
      "source": [
        "On identifie généralement quatre types de données de base en Python.\n",
        "\n",
        "Trois sont des **données numériques**:\n",
        "* Booléen (**`bool`**): `True, False`\n",
        "* Nombre entier (**`int`**): `-42, 0, 1, 42, 250000`\n",
        "* Nombre décimal à virgule flottante (**`float`**): `42.0, 3.14, -0.01`\n",
        "\n",
        "La dernière permet de représenter du **texte**:\n",
        "\n",
        "* Chaîne de caractères (**`string`**): `\"Hello World!\"` ou `'Hello World!' `\n",
        "\n",
        "On définit un **`string`** en entourant le texte des symboles **\"double quote\"** ou **'simple quote'**. Ainsi, 4 représente un **`int`**, mais \"4\" représente un **`string`**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "topa9bZ1_LzX",
        "colab_type": "text"
      },
      "source": [
        "## Assignation dynamique\n",
        "* Pas besoin de définir le type d'une variable, l'interpréteur Python comprend tout seul :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fQpdYIbDwZ6J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_int = 250000\n",
        "my_float = 1.23\n",
        "my_bool = True\n",
        "my_string = \"Rue de Bruxelles 61, Namur\"\n",
        "#Veuillez notez les guillements pour définir le string"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MDN_RjvEwnQx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_int, my_float, my_bool, my_string"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ExLckC98fWfE",
        "colab_type": "text"
      },
      "source": [
        "* La fonction \"type\" permet de vérifier le type d'une variable :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8yOIDVQ3wtzx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "type(my_string)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "62yQ85nk_H5Y",
        "colab_type": "text"
      },
      "source": [
        "* On peut également modifier dynamiquement le type des variables :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sExIWlgL-98I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_string = 5.0\n",
        "type(my_string)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4VW52peNqBSu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_int1 = 2\n",
        "my_int2 = 2\n",
        "my_float1 = 4.2\n",
        "my_bool = True\n",
        "my_string1 = \"Rue de Bruxelles\"\n",
        "my_string2 = ' 61'\n",
        "my_string3 = \" Namur\"\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a9oA4Ic-fsGm",
        "colab_type": "text"
      },
      "source": [
        "* La commande \"whos\" permet de visualiser l'ensemble des variables actuellement présentes dans le programme :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JStVzuHmCgm4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "whos"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qDeZyjk5uwPZ",
        "colab_type": "text"
      },
      "source": [
        "## Conversion de types (casting)\n",
        "* Lorsque c'est possible, un type de données peut être converti vers un autre type de données.\n",
        "  * convertir un **`int`** en **`str`**:    **`str(4)`** => \"4\"\n",
        "  * convertir un **`str`** en **`int`**:    **`int(\"4\")`** => 4\n",
        "  * convertir un **`float`** en **`int`**:    **`int(4.8)`** => 4\n",
        "  * conversion en **`bool`**: **`bool(\"\"), bool(0.0), bool(0)`** => **`False`**. Tout le reste renvoie **`True`**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TShUkq-5j41v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(bool(\"\"), bool(0.0), bool(0))\n",
        "print(bool(\"0\"), bool(-1.2), bool(-10), bool(\"hi\"))\n",
        "str(True), str(False), int(True), int(False), float(True), float(False)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W_WvNT5Imd-q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "int(4.9), float(\"3.5\"), str(3.5), bool(4.2), bool(-2), bool(0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "erueK9u6w35g",
        "colab_type": "text"
      },
      "source": [
        "# Opérations de base\n",
        "  \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1g5ZK-F9qg-V",
        "colab_type": "text"
      },
      "source": [
        "## Opérations arithmétiques\n",
        "\n",
        "Les opérations de base peuvent se faire entre différents types de données numériques, en réalisant des conversions implicites de types si nécessaire:\n",
        "\n",
        "* Les **int**, **float** et **bool** peuvent être additionnés (**+**), multiplés (**\\***), divisés (**/**), ou soustraits (**-**) entre eux.  \n",
        "* L'opérateur **\\*\\*** et un opérateur de puissance (exposant): 2\\*\\*10 => 1024\n",
        "* L'opérateur **%** et un modulo (reste de la division entière): 11%3 => 2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "91uAuVpbsm8I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Operations sur un seul type de donnée\n",
        "print(  my_int1+my_int2,   111-69,   6*7,   (my_int1 + my_int2) * 10 + 2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "psumtjRGBFD3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Opération compatibles entre types différents (entier, float, booléen)\n",
        "print(my_int1 + my_float1,\\\n",
        "      my_float1 + my_bool,\\\n",
        "      (my_int1 + my_int2 - 3.5) * 5 / 2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TIJAjY4eBhxg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Exposant\n",
        "print(2 ** 42)\n",
        "#Modulo\n",
        "print(11%3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c-H_YAb3HcNB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#La division entière renvoie un float (contrairement au langage C)\n",
        "8/3"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "02YJHXTyqlV9",
        "colab_type": "text"
      },
      "source": [
        "## Opérations sur des string\n",
        "\n",
        "Les string peuvent être additionnés entre eux (**+**), ou multiplés par un entier (**\\***):\n",
        "\n",
        "  * Deux **string** peuvent être additionnés, ce qui résulte en une concaténation: \"hell\" + \"o\" => \"hello\"\n",
        "  * Un **string** peut être multiplié par un entier, ce qui résulte en une concaténation multiple du string: \"hi\"*3 => \"hihihi\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OmUps4p3_16q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Les opérations sur les strings sont des concaténation\n",
        "address = my_string1 + my_string2 + my_string3\n",
        "print(address)\n",
        "print(\"hi\" * 3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0k8t2ZQW9L7x",
        "colab_type": "text"
      },
      "source": [
        "* Les opérations invalides (telle qu'additionner un string avec une variable numérique), renvoient une erreur:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mhBeoWyks8In",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_int1 + my_string1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mvy5DPPQs-P3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "string = '4'\n",
        "string + str(my_int1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PGkQdMjktCfm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_int1 + int(string)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d0WLB3Mah1Tt",
        "colab_type": "text"
      },
      "source": [
        "## Opérateurs spéciaux: +=, *=, -=, /=, **=, %=\n",
        "\n",
        "* Les opérateurs spéciaux **`+=`**, **`*=`**, **`-=`**, **`/=`** permettent à la fois de réaliser une opération arithmétique et une assignation. \n",
        "\n",
        " > L'instruction \"**`toto += 1`**\" est équivalente à \"**`toto =  toto + 1`**\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ogRkFXK5DNHP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Self-operation\n",
        "toto = 1\n",
        "toto += 100\n",
        "toto *= 2\n",
        "toto -= 76\n",
        "toto /= 3\n",
        "toto"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nffPqKhspl-6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "hi = 11\n",
        "hi %= 3\n",
        "hi"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dSYmLW86ODdZ",
        "colab_type": "text"
      },
      "source": [
        "## Opérateurs de tests\n",
        "* test d'égalité: ==\n",
        "* test d'inégalité: !=\n",
        "* test de supériorité et infériorité stricte: > et <\n",
        "* inférieur/supérieur ou égal: <= et >=\n",
        "* le mot-clé **`is`** est équivalent à l'opérateur **`==`**\n",
        "* le mot-clé **`is not`** est équivalent à l'opérateur **`!=`**\n",
        "\n",
        "Ces opérateurs sont généralement utilisés avec les conditions: if, elif, ..., elif, else (voir plus loin)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e4WF9dj0OFa9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#assignation de variable\n",
        "a = 42\n",
        "\n",
        "# l'opérateur de test d'égalité \"==\" renvoie un booléen, ne doit surtout pas être confondu avec l'opération d'assignation \"=\" (c'est une source fréquente de bugs dans les conditions)\n",
        "a == 42  ,\\\n",
        "a != 42  ,\\\n",
        "a > 3    ,\\\n",
        "a <= 42  ,\\\n",
        "a is 42  ,\\\n",
        "a is not 42"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tWUGwB5MeQOh",
        "colab_type": "text"
      },
      "source": [
        "## Opérateurs logiques\n",
        "* **`and`**: \"et\", **`*`** logique: True and False = False (1 * 0 = 0)\n",
        "* **`or`** : \"ou\", **`+`** logique: True or False = True (1 + 0 = 1)\n",
        "\n",
        "Remarque: en logique, 1 + 1 = 1 (True or True = True)\n",
        "\n",
        "Ces opérateurs sont généralement utilisés avec les opérateurs de tests, pour vérifier des conditions multiples (voir plus loin)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lEDJ4VzHRR-w",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(not True)\n",
        "\n",
        "print((a > 41) and (a < 43))\n",
        "\n",
        "print((a == 42) or (a == 43))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eeAdHBHmrRzt",
        "colab_type": "text"
      },
      "source": [
        "# Contrôle du flux des instructions\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PcN74MUv9u49",
        "colab_type": "text"
      },
      "source": [
        "Certaines instructions permettent de contrôler le flux du code:\n",
        "\n",
        "* Les **conditions** permettent de réaliser un bloc d'instructions, ou de l'éviter, ou encore de choisir un bloc d'instructions parmi plusieurs.\n",
        "* Les **boucles** permettent de repasser plusieurs fois, de manière itérative, par le même bloc d'instructions\n",
        "* Pour différencier les différents blocs d'instructions, on utilise l'**indentation** (en utilisant des Tab, ou des Whitespace)\n",
        "\n",
        "En Python, l'indentation de chaque ligne de commande est donc très importante, puisque c'est elle qui définit le flux des instructions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xyi7hNPwsMdo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = 1\n",
        "b = 2\n",
        "#On ne peut pas changer d'indentation sans définir un comportement \n",
        "#pour ce nouveau bloc de code (avec une condition ou une boucle)\n",
        "  c = 3\n",
        "  d = 4"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mzdy9jacqbRX",
        "colab_type": "text"
      },
      "source": [
        "## Conditions\n",
        "Les mot-clés **`if`**, **`elif`**, et **`else`** permettent de définir un flux conditionnel d'instructions:\n",
        "* \"**`if condition:`**\" : si la condition est vraie (**`True`**), le bloc d'instruction indenté sous cette condition est réalisé\n",
        "* \"**`elif condition2:`**\": si la condition précédente était fausse (dans le **`if`** précédent), et que cette condition2 est vraie, le bloc d'instruction indenté sous cette condition est réalisé\n",
        "* \"**`else:`**\": si toutes les conditions précédentes étaient fausses, le bloc indenté suivant est réalisé\n",
        "* Attention à l'**indentation** et au symbole **\":\"** ! C'est le bloc indenté après le symbole \":\" qui dépend de la condition\n",
        "* Si on veut spécifier un bloc d'instruction qui n'exécute rien, on peut utiliser le mot-clé **`pass`**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ey0G8G1BOXvh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#condition = True\n",
        "a = 42\n",
        "condition = a == 43\n",
        "\n",
        "if condition:\n",
        "  print(\"C'est vrai!\")\n",
        "  \n",
        "if condition == True:  \n",
        "  print(\"C'est vraiment vrai!\")\n",
        "  \n",
        "if condition == False:\n",
        "  print(\"C'est faux!\")\n",
        "  \n",
        "if not condition:\n",
        "  print(\"Ce n'est pas vrai!\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x1LfvyQ9eEXi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "prix_maison = 150000\n",
        "\n",
        "condition = prix_maison < 200000\n",
        "#condition = a == 43\n",
        "\n",
        "if condition:\n",
        "  print(\"C'est pas cher!\")\n",
        "else:\n",
        "  print(\"C'est cher!\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "awQni_LeP30h",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "PER = 35 #price_earning_ratio\n",
        "\n",
        "if PER < 0:  \n",
        "  pass #il ne se passe rien\n",
        "elif PER < 10:\n",
        "\tprint(\"J'achète!\")\n",
        "elif PER <= 30:\n",
        "\tprint(\"Hodl!\")\n",
        "else:\n",
        "\tprint(\"Je vends!\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "akgy0WgBTPGH",
        "colab_type": "text"
      },
      "source": [
        "## Boucles\n",
        "Les boucles permettent de définir un flux itératif d'instructions:\n",
        "* **`while condition:`**: on éxécute le même bloc d'instructions itérativement tant qu'on respecte une condition\n",
        "* **`for variable in variable_set:`**: on exécute le bloc d'instructions itérativement sur un ensemble d'éléments"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3aFkZPXaS4O5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "count = 0\n",
        "while count < 5:\n",
        "\tprint(\"Je suis dans une boucle while depuis \" + str(count) + \" itérations\")\n",
        "\tcount += 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wJywAemKU39K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(0, 5):\n",
        "\n",
        "  print(\"Je suis à l'itération\", i)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TTygHqOqw13N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for year in range(9,50):\n",
        "  \n",
        "  if year % 4 == 0:\n",
        "    print(\"Année bissextile!\")\n",
        "    continue #continuer directement la suite de la boucle\n",
        "    \n",
        "  if year == 18:\n",
        "    print(\"Adulte!\")\n",
        "    break #sortie d'une boucle\n",
        "    \n",
        "  print(year)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oelH_ek3xwew",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "prix = 100000\n",
        "mine = False\n",
        "while True: \n",
        "  #la condition est toujours vraie, c'est une boucle infinie; \n",
        "  #il faut donc au moins inclure un \"break\"\n",
        "  #dans le bloc d'instruction pour permettre une sortie de la boucle\n",
        "  #(sinon il faut arrêter le programme manuellement)\n",
        "  \n",
        "  prix += 20000\n",
        "  print(prix)\n",
        "  \n",
        "  if prix > 150000 and prix < 200000 and mine == False:\n",
        "    print(\"j'achète\")\n",
        "    mine = True    \n",
        "  \n",
        "  elif prix > 200000 and mine:\n",
        "    print(\"Je revends\")\n",
        "    mine = False\n",
        "    \n",
        "    break\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O837MBoAygsu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Boucle infinie\n",
        "while True:\n",
        "  pass"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ia4gzC9V1NDZ",
        "colab_type": "text"
      },
      "source": [
        "# Bonus - Exemple minimaliste: un petit programme mathématique\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fRLbUg989zLU",
        "colab_type": "text"
      },
      "source": [
        "Approximation de $\\pi$:\n",
        "\n",
        "> $\\pi = 4\\sum_{n=0}^{\\infty} \\cfrac {(-1)^n}{2n+1} = 4\\left( \\frac11- \\frac13+ \\frac15- \\frac17+- \\cdots\\right)$\n",
        "\n",
        "\n",
        "* On estime itérativement pi, avec une série de fractions de plus en plus longue\n",
        "* On définit une condition pour sortir de la boucle d'itération: lorsque la nouvelle estimation ne change presque plus, on considère qu'on est assez proche de la solution\n",
        "\n",
        "(Remarque: ce n'est pas la meilleure méthode d'estimation mais elle est facile à coder, ce qui en fait un bon exemple de programme mathématique)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HmUWZtO_ZKun",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "k=3\n",
        "series=1\n",
        "previous_pi = 0\n",
        "new_pi = 10\n",
        "\n",
        "epsilon = 10**-5\n",
        "\n",
        "while abs(new_pi - previous_pi) > epsilon:\n",
        "  \n",
        "    previous_pi = new_pi\n",
        "    series = series - 1/k + 1/(k+2)\n",
        "    k+=4\n",
        "    \n",
        "    #estimations successives de pi\n",
        "    new_pi = 4*series\n",
        "    \n",
        "    #afficher le résultat toutes les 5 itérations\n",
        "    if (k-3)%20 == 0:\n",
        "      #afficher le résultat sur la même ligne\n",
        "      print(new_pi, end = ' ')\n",
        "    \n",
        "\n",
        "print('')\n",
        "print(new_pi)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "71l9Dhjp-pdG",
        "colab_type": "text"
      },
      "source": [
        "# Attention à la syntaxe et à l'indentation !\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LeZ8WTjddRWZ",
        "colab_type": "text"
      },
      "source": [
        "## Exercice: corrigez ce code"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5jtjpcPqzvVD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "prix = 100000\n",
        "mine = False\n",
        "\n",
        "while True:\n",
        "  \n",
        "prix += 20000\n",
        "print(prix)\n",
        "  \n",
        "  if prix > 150000 and prix < 200000 and mine == False\n",
        "    print(\"j'achète\")\n",
        "  mine = True\n",
        "  \n",
        "  elif prix > 200000 and mine:\n",
        "    print(\"Je \n",
        "          revends\")\n",
        "    mine = False\n",
        "    \n",
        "  break"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PfhnWVvQMeAh",
        "colab_type": "text"
      },
      "source": [
        "Solutions des exercices [ici](https://github.com/titsitits/Python_Data_Science/blob/master/Exercise_Solutions.ipynb)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KG_PPSe9e1-M",
        "colab_type": "text"
      },
      "source": [
        "# Récapitulatif des mots-clés et types de données de base"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y5t-fPt2e1G4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Types de base\n",
        "250000 #entier\n",
        "0.12 #float\n",
        "'42' ou \"42\" #string\n",
        "True False #booléens\n",
        "\n",
        "#Opérateurs de test\n",
        "is\n",
        "in\n",
        "not\n",
        "and\n",
        "or\n",
        "\n",
        "#Boucles\n",
        "for\n",
        "while\n",
        "\n",
        "#Conditions\n",
        "if\n",
        "elif\n",
        "else\n",
        "\n",
        "pass\t#Instruction nulle (il ne se passe rien)\n",
        "break #Sortie de boucle\n",
        "continue #On passe à l'itération suivante dans une boucle\n",
        "\n",
        "#Quelques fonctions de base\n",
        "print\n",
        "range\n",
        "type\n",
        "abs\n",
        "\n",
        "#Fonctions de conversion de type (casting)\n",
        "int\n",
        "float\n",
        "bool\n",
        "str\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SnSuv8RjqwzB",
        "colab_type": "text"
      },
      "source": [
        "Maintenant que vous connaissez les bases du Python, vous pouvez passer au [Chapitre 2: Les collections d'objets Python](https://colab.research.google.com/github/titsitits/UNamur_Python_Analytics/blob/master/2_Collections.ipynb)"
      ]
    }
  ]
}