Notebook/imperatif/Les_structures_un_programme_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Les structures d'un programme Python.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMuGGsI9JVX0xuvWoeHgHYY",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/opentrainingcamp/python/blob/main/Notebook/imperatif/Les_structures_un_programme_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Algorithme et impératif \n",
        "**Données et structure de données :**\n",
        "- [ ] atomique\n",
        "- [ ] Séquence\n",
        "- [ ] structures complexe\n",
        "\n",
        "**L'instruction : affectation**\n",
        "\n",
        "**Flot d’instructions (affectation):**\n",
        "- [ ] <ins>Séquence</ins> $\\Rightarrow$ bloc d’instruction \n",
        "- [ ] <ins>conditions</ins> $\\Rightarrow$ if else\n",
        "- [ ] <ins>Répétition</ins> $\\Rightarrow$ while\n",
        "- [ ] appel de procédures (instruction) ou appel de Fonctions (expression)\n",
        "\n",
        "**Definition de nouveaux éléments**\n",
        "- [ ] procédures (instruction)\n",
        "- [ ] Fonctions (expression)\n",
        "- [ ] Modules\n",
        "- [ ] Classe d'objets\n"
      ],
      "metadata": {
        "id": "gAQrg9waH7sK"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y3zq4FxSWUuf"
      },
      "source": [
        "## Bloc et instructions\n",
        "Un programme en paradigme impératif Python est composé d'instructions. \n",
        "* En Python les limites des instructions et des blocs sont définies par la mise en page.\n",
        "    * Pas de point-virgule (;) à la fin de chaque instruction comme en  Java Mais juste un saus de ligne le caractère de fin de ligne (symbolisé par \"\\n\" newLine). \n",
        "    * Les accolades `{ ... }` pour le début et la fin de bloc sont remplacées par les niveaux d'indentations, terminé par une ligne blanche\n",
        "\n",
        "En définitive, Python oblige à écrire du code lisible, et à prendre de bonnes habitudes conservables dans d'autres langages, ce qui en est fait un langage idéal pour apprendre la programmation. *Je sais ce n'est pas votre cas, mais....*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YKV38Q0JXQis"
      },
      "source": [
        "## Organiser un porgramme Python\n",
        "Un programme Python est construit à partir de blocs de code. Un block est un morceau de texte de programme Python qui est exécuté en tant qu'unité.\n",
        "Les éléments suivants sont des blocs : \n",
        "* un module, \n",
        "* un corps de fonction ou de procédure (sous-programme)\n",
        "* et une définition de classe. (une meilleure organisation des module?)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y1sN5rX9XzO5"
      },
      "source": [
        "## Pour vous, comment programmer en Python\n",
        "1. Sans rien installer dans Goolge collab (comme ce cours)\n",
        "2. Windows: installer Python directement depuis Windows store avec un EDI simple par exemple VS code\n",
        "3. Linux: En natif ou installer WSL (Windows Subsystem for Linux) et travailler dans un environnement Linux depuis Windows\n",
        "4. d'autres outils nécessaires pour vos développements: git, github, ssh"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ENzln9uS8DC"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CdBJAufxC5qt"
      },
      "source": [
        "## Parcourons les basiques\n",
        "\n",
        "quelques présentations rapide avant de détailler les différentes structuration d'un programme Python.\n",
        "\n",
        "pour apprendre un nouveaux language il faudrait apprendre comment faire ceci:\n",
        "\n",
        "1. affectation\n",
        "2. bloc\n",
        "3. conditions\n",
        "4. repétition\n",
        "5. Les types de données prédéfinies \n",
        "6. Comment créer de nouvaux type de données\n",
        "7. comment structurer son code par les sous-programmes ou modules"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ISRmtDbkDJRE",
        "vscode": {
          "languageId": "python"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2d18e8ed-a70d-4a74-df7b-5692f257ec60"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "valeur : 0\n",
            "valeur : 1\n",
            "valeur : 2\n",
            "Fin\n"
          ]
        }
      ],
      "source": [
        "# premier exemple! (sans explication: que fait-il?)\n",
        "for i in [0, 1, 2]:\n",
        "    print(\"valeur :\", i)\n",
        "print(\"Fin\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uNQUZvvCDN46"
      },
      "source": [
        "Noter le `:` et les tabulations, pas besoin de begin/end ou {, } ni de ; pour faire des blocs d'instructions\n",
        "\n",
        "## Les expressions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rl5Q4CW2Diwb",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "(3 * 4) + 2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ROfgiC8BDz_T"
      },
      "source": [
        "## L'affectation\n",
        "profitons en m^me temps de présenter queleus type de base dans python (enter, flotant, chaine de caractères (string)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tk5MPyUtD2ns",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "x = (3 + 5) / 4\n",
        "y = 2 * x\n",
        "z = \"Un texte\"\n",
        "w = 'un autre texte'\n",
        "#Du texte formaté f\"\"\n",
        "A = f\"x={x} et y={y}\"\n",
        "C = \"x={x} et y={y}\"\n",
        "B = None"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VVwF8ld6EWgr"
      },
      "source": [
        "Vérifier les valeurs des variables x,y,z,w,A et B"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cRiJR8ZzDqsT",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Les opérateurs\n",
        "Les opérateurs sont des caractères ou des chaines de caractères qui on un sens en fonction du type de données manipulé:\n",
        "* +, -, *, /, //, %, ...\n",
        "\n",
        "> [Pour en savoir plus sur les variables et les opérateurs, lire et relire si nécessaire](https://utc503.page.link/variables)\n"
      ],
      "metadata": {
        "id": "BvvSlkDZQCHn"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eIJpmqqUElwd"
      },
      "source": [
        "### par exemple Essayons la différence entre / et //\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PtQe5FY2EtQh",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "f\"le / {5/2} et // {5//2}\""
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Remarque : `f\"...\"` est une chaine formatée, tout ce qui est entre `{...}` est évalué puis remplacé dans la chaine.*"
      ],
      "metadata": {
        "id": "z0Vdhl_DQocn"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e6zlLZNTFpkX"
      },
      "source": [
        "La fonction print"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7qhx71yGFYOL",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# La fonction print\n",
        "print(f\"le / {5%2} et // {5//2}\")\n",
        "print(5*x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VpfTvNCEF55T"
      },
      "source": [
        "## La Conditionelle"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "z5Bihw2JF_1b",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "condition = True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OnJMxwgjF3qS",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "if (condition):\n",
        "  x = 2\n",
        "  print(x)\n",
        "else:\n",
        "  y = 5\n",
        "  print(y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OfCpSw2sjQfT",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "if (condition): \n",
        "  print (\"Vraie\") \n",
        "else: \n",
        "  print(\"Faux\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8mOSyLFzGMR7"
      },
      "source": [
        "Essayer avec condition False si elle était True et True si elle était False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zlk2d_3SGcBO"
      },
      "source": [
        "## La répétition"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BgrciLMmGg4b",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "x = 10\n",
        "while (x > 0):\n",
        "  print(x, end=' ')\n",
        "  x = x -1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GiuFndG-Hdv9"
      },
      "source": [
        "## La répétition par itérateur `for`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "spRUfV8fHhf_",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "for i in range(10):\n",
        "  print(i, end=':')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3yRUmcS1koQ-",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "help(print)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Qcbzi5hnHpe8",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "# cas de range\n",
        "range(10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0ZSXQac6HvWD",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "list(range(10))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p4t2QgKUH0jV"
      },
      "source": [
        "## définition de fonction ou de procedure"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "38-vDi7YH26G",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "def f(x,y):\n",
        "  return (x+y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nwgjEP4BlT25",
        "vscode": {
          "languageId": "python"
        }
      },
      "outputs": [],
      "source": [
        "f(3,4)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oRhkjtTHH7I7"
      },
      "outputs": [],
      "source": [
        ""
      ]
    }
  ]
}