TP0-partie1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Mmb_Tr5fEiR6"
   },
   "source": [
    "# Initiation à la programmation sous Python pour le calcul scientifique (partie 1)\n",
    "\n",
    "## Objectifs du TP:\n",
    "\n",
    "- Connaître les bases du langage Python\n",
    "- Savoir manipuler les principales librairies Python\n",
    "\n",
    "## Introduction:\n",
    "### Python c'est quoi?\n",
    "\n",
    "Python est un langage de programmation inventé par Guido van Rossum. La première version de python est sortie en 1991.\n",
    "\n",
    "### Pourquoi Python?\n",
    "\n",
    "\n",
    "Python est parmi les langages de programmation les plus utilisés dans le domaine de l'ingénierie. \n",
    "\n",
    "* Python est le langage de programmation open source le plus employé.\n",
    "\n",
    "\n",
    "* Python est un langage de programmation puissant et facile à apprendre. Il dispose de structures de données de haut \n",
    "\n",
    "niveau et permet une approche simple mais efficace de la programmation orientée objet. Parce que sa syntaxe est \n",
    "\n",
    "élégante,que son typage est dynamique et qu'il est interprété, Python est un langage idéal pour l'écriture de scripts \n",
    "\n",
    "et le développement rapide d'applications dans de nombreux domaines et sur la plupart des plateformes.\n",
    "\n",
    "\n",
    "* Python est aussi utilisé dans le domaine de la science des données et du Machine Learning. Avec l’essor de l’analyse \n",
    "\n",
    "de données dans toutes les industries, c’est d’ailleurs devenu l’un de ses principaux cas d’usage.\n",
    "\n",
    "\n",
    "* Python est un excellent langage de programmation à usage général en soi, mais avec l'aide de quelques bibliothèques \n",
    "\n",
    "populaires (numpy, scipy, matplotlib), il devient un environnement puissant pour le calcul scientifique."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1Q5tNzTuApCp"
   },
   "source": [
    "# Partie I : Variables: listes, tuples, chaines de caractères et dictionnaires :\n",
    "\n",
    "## Les variables :\n",
    "\n",
    "`Une variable` est un conteneur qui sert à stocker une valeur et pour appliquer la création de cette variable on doit choisir `un nom` et affecter `une valeur`.\n",
    "\n",
    "`Le type` d'une variable correspond à la nature de celle-ci.\n",
    "\n",
    "Dans nos TP nous allons voir $4$ types de variables : \n",
    "\n",
    "1. `les entiers(integers ou int).`\n",
    "2. `les nombres décimaux(floats).` \n",
    "3. `les chaines de caractères(strings ou str)`  \n",
    "4. `les booléens(booleans ou bool: True and False).`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oA9-srgZEyJx"
   },
   "source": [
    "**Activités (1):**\n",
    "\n",
    "1. Exécuter les instructions suivantes:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yYwN2T_nFutJ"
   },
   "outputs": [],
   "source": [
    "a=2\n",
    "b=2.  \n",
    "c=\"Hello Python\"  \n",
    "u=True   \n",
    "z=3+5.2j # avec j^2=-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LwsHZ219GqXk"
   },
   "source": [
    "**Pour savoir le type de chaque variable on utilse la commande `type`.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m3JHcDWVFy24"
   },
   "source": [
    "2.  Vérifier alors le type de chacune de ces variables. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "I4obeBO_E2IS",
    "outputId": "5ed214a4-0dd7-454f-fdb2-1b91966d741d"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q8p2ArNqG96K"
   },
   "source": [
    "### Les opérartions élémentaires : \n",
    "\n",
    "Sous python, les opérations élémentaires sont les suivantes : \n",
    "  \n",
    "|Opération | |Signification |  \n",
    "|:---------|:--------|:-------------|\n",
    "|$x+y$     |     |Addition      |\n",
    "|$x-y$     |       |   Soustraction           |\n",
    "|$x/y$     |         |      Division        |\n",
    "|$x*y$     |         |      Multiplication        |\n",
    "|$x**y$ $( $pow(x,y)$)$   |         |         Puissance     |\n",
    "|$x\\%y$    |         |Le reste de la division Euclidienne|\n",
    "|$x//y$    |         |Le quotient de la division Euclidienne|\n",
    "\n",
    "\n",
    "### Opérateurs d'affectation augmentés :  \n",
    "\n",
    "Le tableau suivant introduit les différents opérateurs d'affectation augmentés et leurs significations:  \n",
    "  \n",
    "\n",
    "|Opération          |Signification    |  \n",
    "|----------------   |-----------------|\n",
    "|$x$ $+=y$          |$x=x+y$          |\n",
    "|$x$ $-=y$          |$x=x-y$          |\n",
    "|$x$ $/=y$          |$x=x/y$          |\n",
    "|$x$ $*=y$          |$x=x*y$          |\n",
    "|$x$ $**=y$         | $x=x**y$        |\n",
    "|$x$ $\\%=y$         | $x=x\\%y $       |  \n",
    "|$x$ $//=y$         |   $x=x//y$      |  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Dp9thWP8HB_j"
   },
   "source": [
    "**Exercice (1):**  \n",
    " Tester les opérations introduites dans les deux tableaux pour $x=5$ et $y=3$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=5\n",
    "y=3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oujuW7VrMHcM"
   },
   "source": [
    "## Les listes :\n",
    "\n",
    "`Une liste` est une structure de données dans laquelle on peut mettre plusieurs types de variables séparées par des virgules, et le tout encadré par des crochets.\n",
    "\n",
    "### Exemples:   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AvMbtmFSJVVg"
   },
   "source": [
    "1. **Création d'une liste vide :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YrP2IxHMOFGo",
    "outputId": "af1c11f3-9172-4581-8590-332e44409436"
   },
   "outputs": [],
   "source": [
    "l=[]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oJqgK0N3OMY8"
   },
   "source": [
    "2. **Création d'une liste quelconque :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "C3VkzYlcOXku",
    "outputId": "7fff3998-01c9-4170-edf2-17fe1e92d534"
   },
   "outputs": [],
   "source": [
    "L=[1,2.,True,'Hello',[1,'g']]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mZBnu_xzOzJm"
   },
   "source": [
    "### Operations sur les listes :\n",
    "\n",
    "Dans cette partie, nous allons citer quelques utilisations d'une liste. \n",
    "\n",
    "1. Nous pouvons caractériser ses élements par leurs positions.\n",
    "\n",
    "`L=           [1,  2.,  True,  'Hello',  [1,'g']]`\n",
    "\n",
    "```indices=      0   1     2        3         4```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eZwqvXLuPXya"
   },
   "outputs": [],
   "source": [
    "#print(\"L'élément dans la position 0 est \",L[0],\"et l'élément dans la position 3 est\", L[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DlyL05LQPZjb"
   },
   "source": [
    "\n",
    "- La liste L peut également être indexée avec des nombres négatifs.\n",
    "\n",
    "`L=                    [1,  2.,  True,  'Hello',  [1,'g']]`\n",
    "\n",
    "`indices positifs=      0    1      2         3          4    `\n",
    "\n",
    "`indices négatifs=     -5   -4     -3        -2         -1   `"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CN1VB7IaQmyT"
   },
   "source": [
    "\n",
    "- On peut  accéder au  dernier élément d'une liste en utilisant `L[-1]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rnLN4tmwPnUQ"
   },
   "outputs": [],
   "source": [
    "#L[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "j1M8PCGTQ-Hu"
   },
   "source": [
    "- Pour determiner l'indice d'un élément dans une liste on utilise `.index()` l'élément"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EnzOihARVWFo"
   },
   "outputs": [],
   "source": [
    "#L.index([1,'g'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ii0SZH8KVZtL"
   },
   "source": [
    "2. Pour connaitre la longueur d'une liste on utilise `len`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "keBykEGpVmXX"
   },
   "outputs": [],
   "source": [
    "#len(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CLQKtk6jVn6X"
   },
   "source": [
    "3. Les listes supportent l'opérateur $+$ de concaténation et l'opérateur $*$ pour la duplication par un scalaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "_H08DFytVnWx"
   },
   "outputs": [],
   "source": [
    "# Executer et commenter.\n",
    "L1=['souris','girafe']\n",
    "L2=[1.,4.32,0,True,False]\n",
    "#print(L1+L2)\n",
    "#print(3*L1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n2ZJn4LfW09H"
   },
   "source": [
    "4. On peut ajouter un élément à la fin de la liste en utilisant la méthode `.append()`\n",
    "\n",
    "\n",
    "\n",
    "- Ajouter l'élément `[0,'Merci']` à  la litse `L1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KgSGqINAXFOy"
   },
   "outputs": [],
   "source": [
    "..................................."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OAAgMNOBXGEK"
   },
   "source": [
    "5. Pour ajouter un élément dans une position précise dans la liste, on utilise la méthode `.insert(position,l'élément à rajouter)`\n",
    "\n",
    "\n",
    "\n",
    "- Insérer l'élément `'Bonsoir'` dans la litse `L2` dans la position $3$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-F8btmmxXX7A"
   },
   "outputs": [],
   "source": [
    "..................................."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RHSeBATEX3iZ"
   },
   "source": [
    "6. Sélectionner une partie d'une liste en utilisant un indiçage construit sur la liste`[m:n+1]`.\n",
    "\n",
    "- `L[m:n+1]` : pour récupérer tous les éléments de la liste du mième au nième."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FA7LriaiXoMe"
   },
   "outputs": [],
   "source": [
    "#Exécuter\n",
    "#L2[2:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ARpbJ0AiYjeQ"
   },
   "source": [
    "\n",
    "- `L[m:]` : pour récupérer tous les éléments de la liste du mième jusqu'à la fin de la liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "g3p9TUD3YrFM"
   },
   "outputs": [],
   "source": [
    "#Exécuter\n",
    "#L2[2:]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lOEo1iAZYy36"
   },
   "source": [
    "\n",
    "- `L[:n+1]` : pour récupérer tous les éléments de la liste du premier au nième."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hAdJGLMUY3RP"
   },
   "outputs": [],
   "source": [
    "#Exécuter\n",
    "#L2[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "15cdCG6MZAhy"
   },
   "source": [
    "\n",
    "- `L[:]` : pour récupérer tous les éléments de la liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "68NxOCWWY7a4"
   },
   "outputs": [],
   "source": [
    "#Exécuter\n",
    "#L2[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t7DgzOX7ZFzU"
   },
   "source": [
    "\n",
    "- `L[n:-1]` : pour récupérer tous les éléments de la liste du nième jusqu'à l'avant dernier éléments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sf80RZxMZE4L"
   },
   "outputs": [],
   "source": [
    "#Exécuter\n",
    "#L2[1:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CWCTwjHFZNd5"
   },
   "source": [
    "\n",
    "7. Pour supprimer un élément de la liste, on utilise `del`:\n",
    "\n",
    "-  Supprimer l'élément de la position $3$ de la liste `L2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jtzOm8ISZU5a"
   },
   "outputs": [],
   "source": [
    ".........................................................."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6PERZEi1ZhhM"
   },
   "source": [
    "\n",
    "-  Supprimer les éléments de la deuxième au quatrième de la liste `L2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pZ0NlgPXaIko"
   },
   "outputs": [],
   "source": [
    ".............................................."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YTf1hY3vaVry"
   },
   "source": [
    "\n",
    "-  Pour supprimer l'élément `[1,'g']` de la liste `L`, on peut utiliser `del` ou `remove`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "U0Oxx7HIaRW-"
   },
   "outputs": [],
   "source": [
    "#Exécuter\n",
    "#del L[L.index([1,'g'])]\n",
    "#L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ki8NaezyahMm"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice (2)**\n",
    "\n",
    "Créez $4$ listes `hiver`, `printemps`, `été` et `automne` contenant les mois correspondants à ces saisons. \n",
    "\n",
    "Créez ensuite une liste `saisons` contenant les listes `hiver`, `printemps`, `été` et `automne`.\n",
    "\n",
    "Prévoyez ce que renvoient les instructions suivantes, puis vérifiez-le dans l'interpréteur :\n",
    "\n",
    "1. `saisons[2]`\n",
    "\n",
    "2. `saisons[1][0]`\n",
    "\n",
    "3. `saisons[1:2]`\n",
    "\n",
    "4. `saisons[:][1]`. \n",
    "\n",
    "Comment interpreter-vous ce dernier résultat ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#completer\n",
    "hiver=...........................\n",
    "printemps=.......................\n",
    "été=.............................\n",
    "automne=..........................\n",
    "saisons=[hiver,printemps,été,automne]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QZeNK0Uqam3i"
   },
   "source": [
    "## Les tuples :\n",
    "\n",
    "`Un tuple` correspend à une liste non mutable (non modifiable) dans laquelle on utilise les parenthèses au lieu des crochets.\n",
    "\n",
    "#### Exemples :\n",
    "\n",
    "1.Un tuple vide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "f0k0zT9hbAuW"
   },
   "outputs": [],
   "source": [
    "#K=()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FLv5qlYrbB-K"
   },
   "source": [
    "2. Un tuple contenant un seul élément."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AIBlWdgWbF8V"
   },
   "outputs": [],
   "source": [
    "#P=(3,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mCsKWHwvbOwI"
   },
   "source": [
    "3. Un tuple quelconque."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dYlvL8zTbTB0"
   },
   "outputs": [],
   "source": [
    "#T=([1,2,3],3.,'Hello',('Sam','John','Albert'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tkPFMtj3bUGI"
   },
   "outputs": [],
   "source": [
    "#type(K),type(P),type(T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CjIql1lHbWIL"
   },
   "outputs": [],
   "source": [
    "#len(K), len(P), len(T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3QVzzkVSA6F_"
   },
   "source": [
    "Dans un tuple l'affectation et l'indiçage fonctionnent comme avec les listes, mais si on essaie de modifier un des éléments du tuple, Python renvoie un message d'erreur.\n",
    "\n",
    " **Activité (2) :**\n",
    "\n",
    "1. Executer la cellule ci-dessous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xcUa5DdQA6GA"
   },
   "outputs": [],
   "source": [
    "#del K[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eKwz1i2JA6GA"
   },
   "source": [
    "2. Executer la cellule suivante et analyser le résultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z2KWVeuTA6GB"
   },
   "outputs": [],
   "source": [
    "#T+(23,)\n",
    "#T+P\n",
    "#3*T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zj0CEZAVg9oU"
   },
   "source": [
    "## Les chaines de caractères :\n",
    "\n",
    "Une chaine de caractères est une suite de caractères (string en anglais) est une séquence de caractères, c'est à dire des caractères qui se suivent les uns derrieres  les autres.  \n",
    "Comme les tuples, seulement les operateurs de concatenation et de duplication par un scalaire peuvent faire un changement dans une chaine de caractère.\n",
    "\n",
    "### Exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ny5u39yvg_k0"
   },
   "outputs": [],
   "source": [
    "#Executer\n",
    "#C='girafe tigre singe souris'\n",
    "#D=\"Hello\"\n",
    "#E='girafe, tigre, singe, souris'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uFMYY1HDhE51"
   },
   "outputs": [],
   "source": [
    "#Executer\n",
    "#type(C), type(D), type(E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ndO6kHj6hLpt"
   },
   "outputs": [],
   "source": [
    "#Executer\n",
    "#len(C), len(D), len(E)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M13yiCptA6GF"
   },
   "source": [
    "**Les tuples et les chaines de caractères sont des objets non mutables ce qui n'est pas le cas pour les listes**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les  dictionnaires "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Un dictionnaire Python est une collection d'éléments non ordonnés. Alors que d'autres types de données composées ont uniquement la valeur en tant qu'élément, un dictionnaire possède une paire `clé:valeur`.\n",
    "\n",
    "*Exemple*\n",
    "\n",
    "`mon_dictionnaire =            {\"name\": \"Mohamed\", \"age\": 45, \"adresse\": \"Tunisie\"}`\n",
    "\n",
    "`clé   =      \"name\"       \"age\"      \"adresse\"         `\n",
    "\n",
    "`valeur=     \"Mohamed\"      45        \"Tunisie\"        `"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Executer et commenter\n",
    "mon_dictionnaire ={\"name\": \"Mohamed\", \"age\": 45, \"adresse\": \"Tunisie\"}\n",
    "print(mon_dictionnaire)\n",
    "print(len(mon_dictionnaire))\n",
    "print(mon_dictionnaire['name'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On peut récupérer toutes les clés d'un dictionnaire grâce à la fonction `keys`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mon_dictionnaire.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- On peut récupérer toutes les clés d'un dictionnaire  grâce à la fonction `items`, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mon_dictionnaire.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Opérations sur  les dictionnaires**\n",
    "1. Pour initialiser un dictionnaire , on utile la syntaxe suivante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    }
   ],
   "source": [
    "dic = {}\n",
    "#ou\n",
    "#dic= dict()\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Pour ajouter des valeurs à un dictionnaire il faut indiquer une clé ainsi qu'une valeur:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Executer \n",
    "dic[\"nom\"] = \"Mohamed\"\n",
    "dic[\"prenom\"] = \"Tounsi\"\n",
    "dic[\"age\"]= 45\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. La méthode `get` vous permet de récupérer une valeur dans un dictionnaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Executer et commenter\n",
    "dic.get(\"nom\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Il est possible de supprimer une entrée en indiquant sa clé, comme pour les listes: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Executer et commenter\n",
    "del dic[\"age\"]\n",
    "print(dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. La méthode `update` permet de fusionner deux dictionaires . "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Executer et commenter\n",
    "c={'Module': 'Calcul scientifique'}\n",
    "d={'chapitre': 'TP0'}\n",
    "c.update(d)\n",
    "print(d)\n",
    "print(c)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5QrdEOg9nHDT"
   },
   "source": [
    "# Partie II : Les fonctions\n",
    "\n",
    "Une fonction est un bloc de code nommé, elle correspond à un ensemble d’instructions crées pour effectuer une tâche précise, regroupées ensemble et qu’on va pouvoir exécuter autant de fois qu’on le souhaite en `l’appelant` avec son nom.   \n",
    "\n",
    "Notez que  `appeler` une fonction signifie exécuter les instructions qu’elle contient.  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_VsBzLFRnJi4"
   },
   "source": [
    "## Structure ```def```\n",
    "Une fonction sous python est définie comme suit : \n",
    "  \n",
    "  \n",
    "**def nom_de_la_fonction (les entrées):  \n",
    "$\\longrightarrow$ Le coprs de la fonction   \n",
    "$\\longrightarrow$ $\\vdots$  \n",
    "$\\longrightarrow$    return le_résultat**  \n",
    "    \n",
    "**Attention à l'indentation indiquée par $\\longrightarrow$**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2acuj0FCj6Ah"
   },
   "source": [
    "### Exemple  \n",
    "\n",
    "Executer la fonction `` somme(a,b)`` et la tester pour `` a=12`` et `` b=17``. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "kNZjBmGlnVjT",
    "outputId": "c453e065-45c5-4366-e49c-c526348154f1"
   },
   "outputs": [],
   "source": [
    "def somme(a,b):\n",
    "    return a+b\n",
    ".....................\n",
    "....................."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UlV1VRr-nhcM"
   },
   "source": [
    "## La structure  anonyme ```lambda```   \n",
    "\n",
    "``nom_de_la_fonction = lambda`` les entrées **:** instruction demandée (mathématique)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WsEd-kO7nrMk"
   },
   "source": [
    "**Exemple**\n",
    "\n",
    "Reécrire la fonction `` somme(a,b)`` avec la structure `` lambda`` et la tester pour les mêmes valeurs de `` a`` et `` b``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bCZBskqtnpU2"
   },
   "outputs": [],
   "source": [
    "...................\n",
    "...................\n",
    "...................\n",
    "..................."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U7zk3B37nw4C"
   },
   "source": [
    "**Exercice (3)**\n",
    "1. Ecrire une fonction ```prod()``` calculant, pour deux variables $u$ et $v$, la valeur de $uv-2v$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LS1dksB-n201"
   },
   "outputs": [],
   "source": [
    "#Complter\n",
    "prod=lambda u,v: ..............."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LyslUwwLA6HE"
   },
   "source": [
    "2.  Ecrire une fonction ```calcul``` calculant, pour deux variables $u$ et $v$, l'inverse de $uv-2v$ qui fait l'appel de la fonction ```prod(u,v)``` pour calculer $uv-2v$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "q4qv_hv9A6HE",
    "outputId": "ac653012-94cb-4a82-a873-e90ac3f9c674"
   },
   "outputs": [],
   "source": [
    "#Completer\n",
    "def calcul(x,y):\n",
    "    .................... \n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jS1o5W1yn8G-"
   },
   "source": [
    "# Partie III : La structure conditionnelle et les boucles\n",
    "\n",
    "## La structure conditionnelle :\n",
    "\n",
    "\n",
    "**La structure conditionnelle 1 :**  \n",
    "\n",
    "**if (condition 1):**    \n",
    "\n",
    "**$\\longrightarrow$ Instruction 1** \n",
    "\n",
    "**else(condition 2):**      \n",
    "\n",
    "**$\\longrightarrow$    Instruction 2**\n",
    "\n",
    "**Attention à l'indentation indiquée par $\\longrightarrow$** \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Q-QVyU9tn9hh"
   },
   "source": [
    "**Exercice (4)** (synchrone)\n",
    "\n",
    "Ecrire une fonction `comparaison` qui prend, comme arguments, deux réels `a` et `b` qui este le signe de $a-b$ :\n",
    "\n",
    "- Si $a-b>0$ elle retourne `a est plus grand que b`.\n",
    "\n",
    "- Si $a-b\\leq0$ elle retourne `a est plus petit ( ou égale) que b`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "E5U21E3loJgX"
   },
   "outputs": [],
   "source": [
    "#Comleter \n",
    "def comparaison(a,b):\n",
    "    if .......:\n",
    "         .................................\n",
    "    else:\n",
    "         .................................."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NMai1NpDoN2G"
   },
   "source": [
    "**La structure conditionnelle 2 :**  \n",
    "\n",
    "**if (condition 1):**\n",
    "\n",
    "**$\\longrightarrow$ Instruction 1**\n",
    "\n",
    "**elif (condition 2):**\n",
    "\n",
    "**$\\longrightarrow$ Instruction 2**\n",
    "\n",
    "**else(condition 3):**\n",
    "\n",
    "**$\\longrightarrow$    Instruction 3**\n",
    "\n",
    "**Attention à l'indentation indiquée par $\\longrightarrow$** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YVa8TMimoVxv"
   },
   "source": [
    "**Exercice (5)** (asynchrone)\n",
    "\n",
    "Ecrire une fonction `comparaison1` qui prend, comme arguments, deux réels `a` et `b`. Cette fonction teste le signe de $a-b$ :\n",
    "\n",
    "a. Si $a-b>0$ elle retourne `a est plus grand que b`.\n",
    "\n",
    "b. Si $a-b<0$ elle retourne `a est plus petit que b`.\n",
    "\n",
    "c. Sinon elle retourne `a est égale à b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jK1b3AWHoabJ"
   },
   "outputs": [],
   "source": [
    "def comparaison1(a,b):\n",
    "    .............................\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TIxj94ogogTc"
   },
   "source": [
    "### Application: La structure récursive d'une fonction \n",
    "\n",
    "Les structures conditionnelles nous permet de définier les fonctions à strcuture récursive.\n",
    "\n",
    "Une fonction est dite `récursive` si, à un moment, elle s'auto-appelle.     \n",
    "\n",
    "\n",
    "#### Exemple :\n",
    "\n",
    "On considère la somme suivante :\n",
    "$$\\sum_{i=0}^{n}i=n+(n-1)+(n-2)+\\dots+2+1+0=n+\\sum_{i=0}^{n-1}i$$\n",
    "\n",
    "Pour effectuer le calcul de cette somme, on construit une fonction récursive `somme_rec`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compléter les pointillés "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5ni7qcgBonHQ"
   },
   "outputs": [],
   "source": [
    "def somme_rec(n):\n",
    "    if .....:\n",
    "        return 0\n",
    "    else:\n",
    "        return ............."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oeN__CCNo8kh"
   },
   "source": [
    "## Les boucles :\n",
    "### La structure pour (`for`):\n",
    "\n",
    "On est souvent amené à répéter plusieurs fois une instruction.\n",
    "\n",
    "Incontournables à tout langage de programmation, les boucles vont nous aider à réaliser cette tâche de manière compacte et efficace.  \n",
    "Parmi les fonctionnalités qui servent à la manipultaion des boucles on peut citer:\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**la commande `range(n)`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `range(n,m)` permet d’obtenir un tableau 1D de la valer de départ `n` à la valeur de fin `m-1` avec un pas `1`.  \n",
    "\n",
    "- `range(m)` permet d’obtenir un tableau 1D de la valer de départ `0` à la valeur de fin `m-1` avec un pas `1`.  \n",
    "- `range(n,m,p)` permet d’obtenir un tableau 1D de la valer de départ `n` à la valeur de fin `m-1` avec un pas `p`.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **Boucle `for` (Structure 1) :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "34srgVA7o54I"
   },
   "outputs": [],
   "source": [
    "L=['Julia', 'Python', 'R']\n",
    "for l in L:\n",
    "    print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **Boucle `for` (Structure 2) :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lgyvcVWioyfp"
   },
   "outputs": [],
   "source": [
    "# structure 2-1\n",
    "\n",
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# structure 2-2\n",
    "for i in range(4,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# structure 2-3\n",
    "n=10\n",
    "for i in range(4,10,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kY0BrK3gpFRh"
   },
   "source": [
    "**Exercice(7)**\n",
    "\n",
    "Soit la liste suivante : `L=[i for i in range(2,20)]`\n",
    "\n",
    "Ecrire une fonction `parite` qui a pour argument la liste `L`.\n",
    "\n",
    "Cette fonction doit parcourir une partie de la liste `L` (de l'élément d'indice $7$ à l'élément d'indice $15$)\n",
    "\n",
    "`[On utilise la boucle for]` et vérifier la parité de chaque élément de cette partie :`[on utiliste la structure  conditionnelle]`\n",
    "\n",
    "Si cet élément est pair elle retourne `l'élément est pair`.\n",
    "\n",
    "Si non elle retourne `l'élément est impair`.\n",
    "\n",
    "****"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "om5eRiHDpLQJ",
    "outputId": "0e5d5884-548b-47a3-a75e-00b619576a51"
   },
   "outputs": [],
   "source": [
    "#Completer\n",
    "L=[i for i in range(2,20)]\n",
    "def parite(L):\n",
    "    G=...................\n",
    "    for i in G:\n",
    "        ................................\n",
    "        ................................\n",
    "        ................................"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "23nhgAu0pOgj"
   },
   "source": [
    "### La structure tant que (`while`):\n",
    "\n",
    "Une autre alternative à l'instruction `for` couramment utilisée est la boucle while. Le principe est simple : Une \n",
    "\n",
    "série d'instructions est exécutée tant qu'une condition est vraie\n",
    "\n",
    "**Exemple :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "P9L_bH51pScU"
   },
   "outputs": [],
   "source": [
    "#Structure 1: \n",
    "i = 1\n",
    "while i <= 4:\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ByAOkgt3pb2Q"
   },
   "outputs": [],
   "source": [
    "#Structure 2:\n",
    "L=[0,1,2,3]\n",
    "while len(L)<10:\n",
    "    L.append(len(L))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice (8):** \n",
    "\n",
    "1. Ecrire une fonction ``somme_rac(n)`` qui évalue la somme $S$ suivante :\n",
    "$$S=\\sum_{i=0}^{n} \\sqrt{1+i^2} $$\n",
    "\n",
    "Tester pour $n=100$ et $n=200$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Completer\n",
    "def somme_rac(n):\n",
    "    s=1\n",
    "    .........................."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Ecrire une fonction `factoriel(n)`qui calcule le factoriel d'un entier `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#completer le script\n",
    "def factoriel(n):\n",
    "    p=1\n",
    "    ..........................\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculer 5! en utilisant la fonction factoriel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JKcBNVJzuHBQ"
   },
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Références  \n",
    "\n",
    "[1] [Kiusalaas, J. (2013). Numerical methods in engineering with Python 3. Cambridge university press.](https://books.google.tn/books?hl=fr&lr=&id=YlkgAwAAQBAJ&oi=fnd&pg=PP10&dq=numerical+methods+in+engineering+&ots=-42y60OrWf&sig=wxL2oISNUKKPlvgH4-tsYh1RK9o&redir_esc=y#v=onepage&q=numerical%20methods%20in%20engineering&f=false)  \n",
    "[2] [Numpy Package](https://numpy.org/devdocs/user/quickstart.html)  \n",
    "[3] [Mathplotlib Package](https://matplotlib.org/tutorials/index.html#introductory)  \n",
    "[4] [Jupyter markdowns](http://faccanoni.univ-tln.fr/user/enseignements/20182019/M62-CM1.pdf)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "TP0_Intiation à la programmation_python_version_0 .ipynb",
   "provenance": []
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}