03 - Structures de Controles.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled3.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMj3VzLYETwJDJ7iMVVo3pw",
      "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/MachineLearnia/Python-tutoriel/blob/master/03%20-%20Structures%20de%20Controles.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mc-EcvradiEm",
        "colab_type": "text"
      },
      "source": [
        "# 3/30 : Structures de Controle\n",
        "Dans le monde de la programmation, il existe 3 principales **structures de controle** pour créer des algorithmes.\n",
        "- Les alternatives **If / Else**\n",
        "- Les boucles **For**\n",
        "- Les boucles **While**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GCRRr0YTdpRc",
        "colab_type": "text"
      },
      "source": [
        "## 1. Alternatives If / Else :\n",
        "Cette structure permet de tester une séquence d'alternatives. Si une condition est respéctée, alors les instructions qui la suivent sont executée et la structure de controle est stopée, sinon la condition suivante est testée."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "36oymtgkdebr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def test_du_signe(valeur):\n",
        "  if valeur < 0:\n",
        "    print('négatif')\n",
        "  elif valeur == 0:\n",
        "    print('nul')\n",
        "  else:\n",
        "    print('positif')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eCbpqCywfazE",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5f69f649-4092-473e-ed5a-2f97203b2752"
      },
      "source": [
        "test_du_signe(-2)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "négatif\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CaHzgd9lfq5o",
        "colab_type": "text"
      },
      "source": [
        "Note importante : Une condition est respectée si et seulement si elle correspond au résultat **booléen True**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eT4ffeSrfeB2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "80a81a89-0672-4812-a264-24e5014b059f"
      },
      "source": [
        "valeur = -2\n",
        "print(valeur < 0) # le résultat de cette comparaison est True\n",
        "\n",
        "if valeur < 0:\n",
        "  print('négatif')"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "négatif\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EPk6O53vhZkW",
        "colab_type": "text"
      },
      "source": [
        "Cela permet de développer des algorithmes avec des mélanges d'opéations Logiques et d'opérations de comparaisons. Par exemple : *si il fait beau et qu'il faut chaud, alors j'irai me baigner*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "52NzMgaegVhP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e8996961-8d44-4da2-d7ae-45c8798dd543"
      },
      "source": [
        "x = 3\n",
        "y = -1\n",
        "if (x>0) and (y>0):\n",
        "  print('x et y sont positifs')\n",
        "else:\n",
        "  print('x et y ne sont pas tous les 2 positifs')"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x et y ne sont pas tous les 2 positifs\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X7ySgVEwhbFd",
        "colab_type": "text"
      },
      "source": [
        "## 2. Boucle For\n",
        "Une boucle for permet de créer des algorithmes itératifs (qui effectuent une certaine tache plusieurs fois de suite). Pour ca, la boucle parcourt tous les éléments d'un objet dit **itérable**. Il peut s'agir d'une liste, d'un dictionnaire, d'un range, d'un tableau numpy, ou de bien d'autres objets..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4O5B4LHbhMze",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "6c890d52-f5fe-4ed7-e674-314687a88d70"
      },
      "source": [
        "# range(début, fin, pas) est une built-in fonction tres utile de python qui retourne un itérable.\n",
        "for i in range(0, 10):\n",
        "  print(i)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aZSpQmXRjJGx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        },
        "outputId": "87cbbc20-302d-42b3-aa70-c2f8ef4e8ef9"
      },
      "source": [
        "# on peut s'amuser a combiner cette boucle avec notre fonction de tout a l'heure.\n",
        "for i in range(-10, 10, 2):\n",
        "  print(i)\n",
        "  test_du_signe(i)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-10\n",
            "négatif\n",
            "-8\n",
            "négatif\n",
            "-6\n",
            "négatif\n",
            "-4\n",
            "négatif\n",
            "-2\n",
            "négatif\n",
            "0\n",
            "nul\n",
            "2\n",
            "positif\n",
            "4\n",
            "positif\n",
            "6\n",
            "positif\n",
            "8\n",
            "positif\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_saAMgPukHO-",
        "colab_type": "text"
      },
      "source": [
        "## 3. Boucle While\n",
        "Une boucle While permet d'effectuer en boucle une action, tant que la condition d'execution est validée (tant que la condition est **True**)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M8qYGgBkj3m9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "cb4df7df-e53c-4a74-ed59-7a83a72f4540"
      },
      "source": [
        "x = 0\n",
        "while x < 10:\n",
        "  print(x)\n",
        "  x += 1 # incrémente x de 1 (équivalent de x = x+1)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uky4XsM2k1WE",
        "colab_type": "text"
      },
      "source": [
        "## 4. Exercice et Solution\n",
        "Implémentez la **suite de Fibonacci** [0, 1, 1, 2, 3, 5, 8, 13, 21, ...] qui part de 2 nombres a=0 et b=1, et qui calcule le nombre suivant en additionnant les 2 nombres précédents.\n",
        "\n",
        "Indices :\n",
        "- Pour cet exercice vous aurez besoin d'une bouce **While**\n",
        "- Vous pouvez imprimer cette suite jusqu'a atteindre un nombre **n** que vous aurez choisit\n",
        "- dans python il est possible de mettre a jour 2 variables simultannément sur la meme lignes : **a, b = b, a+b**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O9D6U0bBktyC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 289
        },
        "outputId": "917e9e6e-a9d7-4ab9-bd8f-42fd4061ad2c"
      },
      "source": [
        "# Solution\n",
        "\n",
        "def fibonacci(n):\n",
        "    # retourne une liste contenant la suite de fibonacci jusqu'a n\n",
        "    a = 0\n",
        "    b = 1\n",
        "    while b < n:\n",
        "      a, b = b, a+b\n",
        "      print(a)\n",
        "\n",
        "fibonacci(1000)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n",
            "55\n",
            "89\n",
            "144\n",
            "233\n",
            "377\n",
            "610\n",
            "987\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3wKUNitUntVE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}