Python-M2GM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Master 2 Genie Mécanique - \n",
    "###### UE : Optimisation des structures\n",
    "###### Enseignant: Enrico Calzavarini enrico.calzavarini@polytech-lille.fr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction à Python "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le texte de cette session de travaux pratiques est également disponible ici: \n",
    "\n",
    "https://github.com/ecalzavarini/python-at-polytech-lille/blob/master/Python-M2GM.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction aux commandes Linux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avant de commencer avec notre introduction au langage de programmation $Python$, nous devons familiariser avec l'environnement du système d'explotation $Linux$. \n",
    "\n",
    "La première étape est d'apprendre les commandes les plus courantes. Ces commandes peuvent être tapées sur une console Linux.\n",
    "\n",
    "Pour savoir comment accéder à une console sur la distribution Linux Debian dont vous disposez, voir:  https://wiki.debian.org/fr/Console ou simplement recherchez l'application \"terminal\" sur le menu des applications."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La commande pwd:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande \"pwd\" affiche le répertoire courant, c'est à dire le répertoire où l'on se trouve au moment où on tape la commande."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La commande ls:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande \"ls\" permet de lister ce que contient un répertoire.\n",
    "Il y a plusieurs manières de l'utiliser :\n",
    "\n",
    "\"ls\" donne la liste brute de ce qui se trouve dans le répertoire\n",
    "\n",
    "\"ls -l\" donne la liste de ce qui se trouve dans le répertoire avec des informations \tcomplémentaires (droits de lecture, écriture et exécution, propriétaire, taille, date de création ou de dernière modification).\n",
    "\n",
    "\"ls -a\" liste tous (pensez au mot \"all\") les fichiers du répertoire, y compris les fichiers cachés. Cette option est très utile lorsque l'on se trouve dans son répertoire personnel car il contient les fichiers de configuration de l'utilisateur dont les noms commencent généralement par un point et seule l'option -a permet de détecter leur existence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La commande mkdir:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande \"mkdir\" permet de créer un répertoire (ou dossier).\n",
    "\n",
    "\"mkdir Nom_repertoire\" crée le répertoire ayant pour nom Nom_repertoire. \n",
    "\n",
    "Par convention, les noms des dossiers sous Linux sont choisis commencer par une lettre majuscule. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La commande cd:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande \"cd\" permet de se déplacer dans l'arborescence de repertoires. Il y a plusieurs manières de l'utiliser : \n",
    "\n",
    "\"cd Nom_repertoire\" permet d'aller dans le répertoire Nom_repertoire\n",
    "\n",
    "\"cd ..\" permet de retourner dans le répertoire parent (celui qui est au-dessus dans l'arborescence de répertoires)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### L'éditeur de texte emacs:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour créer ou modifier un fichier \"emacs -nw nom_fichier.txt\", ou \"emacs nom_fichier.txt\" pour acceder à la version graphique de l'editeur de texte.\n",
    "\n",
    "Pour sauvegarder tapez la combinaison de touches suivante: Ctrl-x Ctrl-s.\n",
    "\n",
    "Pour quitter emacs: Ctrl-x Ctrl-c.\n",
    "\n",
    "\n",
    "D'autres éditeurs de texte sont disponibles sous Linux, par exemple \"vi\" , \"pico\", \"nedit\" . Chacun d'entre eux possède sa propre interface (graphique ou non) et ses propres commandes. Ils effectuent tous les mêmes tâches, il est important d'apprendre à bien en utiliser au moins un."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La commande rm:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande \"rm\" permet de supprimer un fichier :\n",
    "\n",
    "\"rm nom_fichier\" supprime le fichier nom_fichier si il se trouve dans le répertoire courant. Par convention, les fichiers ont des noms commençant par une lettre minuscule.\n",
    "\n",
    "\"rm –r Nom_repertoire\" supprime un répertoire et ses sous répertoires."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La commande top: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande \"top\" affiche en continu des informations décrivant l'activité du système. Elle permet surtout de suivre les ressources que les processus utilisent (quantité de mémoire, pourcentage de CPU...).\n",
    "Sous top il est possible d'expédier de manière interactive un signal à un processus, par exemple afin de le stopper, en tapant \"k\", top demande ensuite l'identifiant (PID) du processus concerné.\n",
    "Pour quitter top, appuyer simplement sur la touche \"q\".\n",
    "\n",
    "Une autre commande utile pour arrêter un programme est \"kill\", son utilisation typique est la suivante \"kill -9 PID\" où PID est le nom du processus concerné. Pour trouver le PID du processus, on peut utiliser \"top\" comme dit précédemment ou la commande \"ps -u nom_utilisateur\" (ps signifie processus)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Archivage de données (zip/unzip):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande \"zip\" (ou \"gzip\") gère des archives, contenant chacune au moins un répertoire ou fichier.\n",
    "\n",
    "Une archive peut être créée en utilisant la commande: \"zip [nom_archive.zip] [liste des fichiers à zipper ou nom du dossier]\"\n",
    "\n",
    "Le contenu d'une archive peut être ouvert en utilisant la commande \"unzip [nom_archive.zip]\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Questions  : "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Ouvrir une consolle Linux et créer un répertoire TP-PYTHON dans le répertoire courant. Comment vérifier qu'il a bien été créé ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2) Aller dans le répertoire que vous venez de créer, puis lister ce qu'il contient. Quelle commande vous permet de savoir si vous êtes bien dans le répertoire TP-PYTHON ?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3) Créer un fichier appelé README.txt dans le répertoire TP-PYTHON avec la commande \"emacs\", taper quelques lignes dedans. Enregistrer le ficher. Vérifier qu'il a bien été créé."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4) Créer un fichier-archive du repertoire TP-PYTHON."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5) Supprimer le fichier que vous venez de créer, comment vérifier qu'il a bien été supprimé ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6) Supprimer le répertoire TP-PYTHON. Vérifier qu'il a bien été supprimé.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction à la programmation numérique en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour lancer l'interprète du langage Python écrire \"python3\" dans la consolle de Linux.\n",
    "\n",
    "Saisir votre série d'instructions Python après l'invite de la ligne de commande \">>>\" (à noter que chaque instruction doit être validée avec la touche \"return\").\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une deuxième possibilité d'utilisation beaucoup plus pratique est de créer un fichier (appelé script), par exemple avec l'éditeur de text emacs : \"emacs -nw script.py\" ou \"emacs script.py\"(pour lancer la version avec interface graphique).\n",
    "\n",
    "\n",
    "Une fois que les instructions ont été écrites dans ce fichier, le script peut être exécuté avec la commande \"python3 script.py\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une troisième possibilité est d'utiliser un environnement de développement intégré (IDE) pour Python. Il en existe de nombreux et ils sont disponibles pour différents systèmes d'exploitation (Linux, Windows, OSX): \n",
    "- SPYDER https://www.spyder-ide.org/\n",
    "- PYCHARM https://www.jetbrains.com/pycharm/\n",
    "- THONNY https://thonny.org/\n",
    "\n",
    "voir aussi la page de Wikipedia https://en.wikipedia.org/wiki/Comparison_of_integrated_development_environments#Python\n",
    "\n",
    "\n",
    "Enfin $Jupyter$ $notebook$ est un environnement de programmation interactif basé sur le Web\n",
    "https://jupyter.org/ \n",
    "C'est avec ce dernier outil que le présent TP est rédigé. (Pour vérifier s'il est installé sur votre ordinateur linux, tapez \"jupyter notebook\" dans la console.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "$Documentation$: \n",
    "\n",
    "Le site le plus utile pour trouver des informations sur python est :\n",
    "https://docs.python.org/3/  \n",
    "voir notamment dans les sections \"Tutorial\" et \"Language reference\".\n",
    "\n",
    "Un autre site utile : https://pythonbasics.org/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modalités pour accomplir le TP et compte rendu "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Pendant ce TP vous aurez à écrire plusieurs scripts (nous vous suggérons de les nommer script1.py, script2.py, ...). \n",
    "Les scripts doivent être accompagnés par un document descriptif unique (README.txt). \n",
    "Dans ce fichier, vous devrez décrire le mode de fonctionnement des scripts et, si besoin, mettre vos commentaires.\n",
    "Merci d'y écrires aussi vos nomes et prénoms complets. Tous les fichiers doivent être mis dans un dossier appelé TP1-nom_prenom et ensuite être compressés dans un fichier TP1-nom_prenom.tgz ou TP1-nom_prenom.zip .\n",
    "\n",
    "Enfin vous allez envoyer ce fichier par email à l'enseignant : enrico.calzavarini@polytech-lille.fr\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vous avez une semaine de temps pour compléter le TP, c'est-à-dire que la date limite pour envoyer vos travaux c'est dans 7 jours à partir d'aujourd'hui. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Script 1 :  entrer ou afficher du texte et  des données "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Nous voulons écrire un script qui tout d'abord affiche simplement une message de bienvenue :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bienvenue au TP de Python\n"
     ]
    }
   ],
   "source": [
    "print(\"Bienvenue au TP de Python\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vérifiez que le programme ci-dessus fonctionne quand il est écrit dans un script (appelé par exemple script1.py) et interprété par python avec la commande \"python script1.py\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous souhaitons maintenant que ce programme nous demande aussi combien d'étudiants sont présents dans la salle et qu'il affiche ce numéro sur l'écran."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A noter que la lecture de données peut se faire par interrogation de l'utilisateur. Par exemple :  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer la valeur de la precision p, p =2\n"
     ]
    }
   ],
   "source": [
    "p = input(\"Entrer la valeur de la precision p, p =\")\n",
    "p = float(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "l'écriture des données enregistrées dans une variable peut se faire tout simplement encore avec la fonction \"print\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la valeure de la precision est :2.0\n"
     ]
    }
   ],
   "source": [
    "print(\"la valeure de la precision est :\" + str(p) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou de façon équivalente :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la valeure de la precision est : 2.000000e+00\n"
     ]
    }
   ],
   "source": [
    "print(\"la valeure de la precision est : %e\" %p )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Commentaires en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une bonne habitude à prendre est d'écrire des commentaires dans le srtipts. \n",
    "Nous pouvons le faire avec le symbole \" # \" , par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la valeure de p est : 2.000000e+00\n"
     ]
    }
   ],
   "source": [
    "print(\"la valeure de p est : %e\" %p ) # ici nous imprimons le résultat final"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gestion des accents en Python\n",
    "\n",
    "\n",
    "Si vous avez souvent rencontré un message d'erreur issu de l'utilisation des caractères accentués dans les scripts en Python: voici une solution  à  ce problème. \n",
    "En première ligne d’un script, il faut insérer la ligne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou bien"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: latin-1 -*-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il s’agit d’un pseudo-commentaire indiquant à Python le système de codage utilisé, ici l’utf-8 (ou le latin-1) qui comprend les caractères spéciaux comme les caractères accentués, les apostrophes, les cédilles , etc ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## $\\color{red}{\\text{Écrivez donc votre premier script ! }}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Script 2 : effectuer des opérations simples sur les variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous souhaiton écrire un script qui fait la conversion d'unité pour des mesures de pression. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Ce script devra demander à l'utilisateur d'introduire une valeur de pression et une unité de mesure (choisi parmi: Pascal (Pa) , bar (bar) , atmosphère (atm) , Torricelli (torr) et pounds per square inch (psi)), puis demander à l'utilisateur quelle unité il souhaite pour la conversion et enfin afficher la valeur de pression dans l'unité demandée.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour mener  à bien ce script les informations suivantes peuvent être utiles :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La table de conversion des unités de pression peut être repèrée ici :\n",
    "\n",
    "http://en.wikipedia.org/wiki/Pressure_measurement#Units"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### L'affectation de données dans des variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5.0 \n",
    "b , c = 10 , 3\n",
    "name = \"Mark\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici \"a\" , \"b\" , \"c\" et \"name\" sont des identificateurs (ou simplement des variables). \n",
    "\n",
    "Python ne nécessite pas de déclarer explicitement les types de variables, différemment qu'en Fortran, C et d'autres langages. Juste affectez une variable et Python comprendera automatiquement, ce n'est pas nécessaire de préciser le type (réel, entier, character, etc...) \n",
    "\n",
    "Vous pouvez demander à Python de vous dire quel type il a attribué à vos variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Portez une attention particulière à l'attribution de valeurs à virgule flottante à des variables ou vous risquez d'obtenir des valeurs que vous ne vous attendez pas dans vos programmes. Par exemple ,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "print(b/c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous voyez , si vous divisez un nombre entier par un nombre entier , Python retourne une réponse arrondie à l'entier le plus proche . Mais si vous voulez une résultat à virgule flottante (type float), l'un des numéros doit être de type float. Le simple ajout d'un point décimal fera l'affaire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "b , c = 10. , 3.\n",
    "print (b/c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utilisation des listes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une liste est une collections d’objets :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n",
      "4\n",
      "[0, 5, 6]\n",
      "[0, 6]\n"
     ]
    }
   ],
   "source": [
    "# Definition et affectation d'une liste\n",
    "l = [0, 5, 6, 4]  \n",
    "\n",
    "# Les indices commencent à 0, et non à 1\n",
    "print(l[0])      \n",
    "\n",
    "# Le dernier indice est le 3ème\n",
    "print(l[3])      \n",
    "\n",
    "# On peut compter à partir de la fin, en utilisant des indices negatifs\n",
    "print(l[-1])     \n",
    "\n",
    "# On peut selectioner une tranche (slice) d'elements dans la liste\n",
    "print(l[0:3])    \n",
    "\n",
    "# La syntaxe du “slicing” est [start:stop:step]\n",
    "print(l[0:3:2])  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une liste peut être modifiée:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 5, 13, 4]\n"
     ]
    }
   ],
   "source": [
    "l[2] = l[2]*2 + 1\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si nous voulons connaître le nombre d'éléments dans une liste :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons  créer  de la même manière une liste de mots  :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avion\n"
     ]
    }
   ],
   "source": [
    "mots = [\"arbre\" , \"avion\" , \"nuage\"]\n",
    "\n",
    "print(mots[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Structure alternative \"if\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regardez l'exemple ci-dessous concernant le calcul des racines réelles d'une équation algébrique du second ordre, pour comprendre le fonctionnement d'une structure \"if\" :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTATS :\n",
      "Deux racines distinctes : x1 = -1.632455532033676 et x2 = -0.3675444679663241\n"
     ]
    }
   ],
   "source": [
    "d = b**2-4*a*c\n",
    "\n",
    "if d > 0 :\n",
    "    x1 = (-b - sqrt(d))/(2*a)\n",
    "    x2 = (-b + sqrt(d))/(2*a)\n",
    "    print(\"RESULTATS :\")\n",
    "    print(\"Deux racines distinctes : x1 = \" + str(x1) + \" et x2 = \" + str(x2))\n",
    "elif d == 0 :\n",
    "    x1 = -b/(2*a)\n",
    "    print(\"RESULTATS :\")\n",
    "    print(\"Une racine double : x1 = \" + str(x1))\n",
    "else :\n",
    "    print(\"RESULTATS :\")\n",
    "    print(\"Aucune solution!\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### à noter : indentation nécessaire en langage Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour les structures de controle du langage Python, comme \"if\"(et nous verros ensuite \"for\"), il n'y a pas de mot clé \"end\" pour signaler la fin du bloc de lignes concernées par les structures \"if\",\"while\",\"for\".\n",
    "Il faut par contre indenter les lignes (c'est à dire créer des décalages à l'aide de la touche tabulation \"tab\" du clavier) afin de définir une dépendance d'un bloc de lignes par rapport à un autre."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Script 3 : lire des données à partir d'un fichier et les élaborer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous disposons des données de pression enregistrées  (à la fréquence d'une mesure par seconde) par un tube de Pitot d'un avion en vol à une altitude de 10000 mètres :\n",
    "\n",
    "https://www.dropbox.com/s/ebvjxhx6fgitw6o/pressure.txt?dl=0\n",
    "\n",
    "Vous pouvez télécharger ce fichier avec la commande de Linux \" wget \". Ecrivez sur votre console :  \"wget  adresse_internet_du_fichier\" . "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Image of Yaktocat](http://upload.wikimedia.org/wikipedia/commons/0/00/Pitot_tube_wings-fr.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On est interessé à écrire un script qui lit ces données et qui les transforme dans des mesures de vitesse. La relation entre la pression et la vitesse est donnée par la loi de Bernoulli: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$V(t) = \\sqrt{\\frac{2\\left(p(t)-p_s\\right)}{\\rho}}.$$ \n",
    "Ici:\n",
    "\n",
    "$p(t)$ est la pression mesurée au cours du temps ($t$) en Pascal,\n",
    "\n",
    "$p_s$ est la pression statique, $p_s=4 \\, kPa$,\n",
    "\n",
    "$\\rho$ est la masse volumique de l'air, $\\rho=0.91875 \\, kg/m^3$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour la réalisation de ce script les informations suivantes vous seront utiles :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La lecture des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "53274.300000\n"
     ]
    }
   ],
   "source": [
    "# Ouverture d'un fichier\n",
    "f = open(\"pressure.txt\", \"r\")\n",
    "# définition d'une liste vide\n",
    "data=[]\n",
    "# lecture de fichier complet et affectation des éléments de la liste \n",
    "data=f.read().split()\n",
    "# fermeture du fichier f\n",
    "f.close()\n",
    "\n",
    "#contrôle de type\n",
    "print( type(data[0]) )\n",
    "#impression de la première donnée \n",
    "print(data[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "Missing parentheses in call to 'print'. Did you mean print(data[0])? (<ipython-input-31-0a1e4a578970>, line 6)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-31-0a1e4a578970>\"\u001b[0;36m, line \u001b[0;32m6\u001b[0m\n\u001b[0;31m    print data[0]\u001b[0m\n\u001b[0m             ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m Missing parentheses in call to 'print'. Did you mean print(data[0])?\n"
     ]
    }
   ],
   "source": [
    "#conversion au type désiré \n",
    "data[0] = float(data[0])\n",
    "#contrôle de type\n",
    "print ( type(data[0]) )\n",
    "#impression\n",
    "print data[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "à noter que lorsque les données sont lues de la manière ci-dessus, elles sont stockées dans une liste de type chaîne de caractères (string). \n",
    "Si nous devons effectuer des opérations mathématiques sur elles, nous devons les convertir en un type numérique ( par exemple \"float \" ou \"int\" )."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ecriture dans un fichier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val1 = 5.0  # affectation d'une variable réelle\n",
    "\n",
    "val2 = str(val1) # conversion en chaîne de caractères\n",
    "\n",
    "# Ouverture d'un nouveau fichier\n",
    "f = open(\"output.txt\", \"w\")\n",
    "# écriture dans le fichier \n",
    "f.write(val2)  \n",
    "# fermeture du fichier \n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "à noter que la commande \"write\" ne peut écrire que des chaînes de caractères (string)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La structure repetitive \"for\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regardez l'exemple ci-dessous concernant tri par sélection de données, pour comprendre le fonctionnement d'une structure  boucle \"for\" :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tri par sélection\n",
    "# Données initiales \n",
    "M = [1. , 2. , 5. , 40. , 65. , 2.,8. , 98. ,115. ,0. , 3.]\n",
    "\n",
    "# Détermination de la longueur  de la liste\n",
    "N = len(M) \n",
    "\n",
    "for i in range(0,N-1):   \n",
    "    for j in range(i+1,N):\n",
    "        if M[j] < M[i]:\n",
    "            val_temp = M[i]\n",
    "            M[i] = M[j]\n",
    "            M[j] = val_temp\n",
    "print(\"Liste triée :\")\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "à noter que la commande \" range(a,b) \" produit une liste de nombres entiers progressifs  compris entre a et b-1 , par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(0,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utiliser les fonctions mathématiques"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python afin de pouvoir utiliser les fonctions mathématiques (par exemple, exp, sqrt , sin , cos , tan), vous devez les importer par avance à partir de la bibliothèque mathématique \"math\" :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing all functions from the math library\n",
    "from math import *      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous vous demandons donc de lire la serie des données de pression dans le fichier et de calculer la vitesse de l' avion en utilisant la relation donnée.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On demande ensuite de calculer la valeur moyenne de la vitesse de l'avion (en Km/heure) et de l'imprimer.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Question bonus : Seriez-vous capable de calculer l'accélération de l'avion au cours du temps, et de l'enregistrer dans un fichier?\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Script 4 : représentation graphique des données"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous souhaitons analyser graphiquement les données , par exemple en les traçant ou en faisant leur histogramme ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour la réalisation de ce script les informations suivantes vous seront utiles :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bibliothèques de Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python dispose de nombreuses bibliothèques qui fournissent des fonctionnalités avancées comme la possibilté d'effectuer des opérations sur des matrices, des fonctions graphiques, et bien plus encore. Nous pouvons donc importer ces bibliothèques de fonctions pour étendre les capacités de Python dans nos programmes.\n",
    "\n",
    "Nous allons commencer par l'importation de quelques bibliothèques pour nous aider.\n",
    "\n",
    "Premièrement, nous l'avons déjà vu, nous utilisons Math, la bibliothèque mathématique standard qui comprend les fonctions trigonométriques et transcendantales, ainsi que  d'autres fonctions spéciales.\n",
    "\n",
    "Pour voir la liste complète des fonctions de la bibliothèque Math:\n",
    "https://docs.python.org/2/library/math.html#module-math\n",
    "\n",
    "Notre deuxième bibliothèque préférée est NumPy (Numerical Python), fournissant un grande nombre d'opérations matricielles utiles (cette bibliothèque est similaire à MATLAB ). Nous allons l'utiliser beaucoup! \n",
    "\n",
    "La documentation de numpy se trouve ici : http://docs.scipy.org/doc/numpy/reference/\n",
    "\n",
    "La troisième bibliothèque dont nous avons besoin est Matplotlib, une bibliothèque de graphique 2D que nous allons utiliser pour tracer nos résultats.\n",
    "\n",
    "La documentation de référence est disponible ici : http://matplotlib.org/contents.html\n",
    "\n",
    "Le code suivant sera au sommet de la plupart de vos programmes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing all functions from the math library\n",
    "from math import *            \n",
    "# we import the array library, and call it 'np'\n",
    "import numpy as np                 \n",
    "# import plotting library, and call it 'plt'\n",
    "import matplotlib.pyplot as plt    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous importons donc toutes les fonctions de la bibliothèque \"math\" et nous importons aussi\n",
    "une bibliothèque nommée \"numpy\". Enfin, nous importons un module appelé \"pyplot\" d'une grande bibliothèque appelée \"matplotlib\".  \n",
    "\n",
    "Les deux dernières lignes ci-dessus ont créé des raccourcis pour les bibliothèques tel que \"np\" et \"plt\" respectivement. La raison de la création des raccourcis est que nous avons besoin de taper les noms de bibliothèque assez souvent dans le code.\n",
    "Pour utiliser une fonction appartenant à l'une de ces bibliothèques, nous devons dire à Python où la chercher. Pour cela, chaque nom de fonction est écrit après le nom de la bibliothèque, avec un point entre les deux. Par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.zeros(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tracer des courbes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEGCAYAAABLgMOSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydeXxU9bn/30/2hYQA2RMChGwkgbAJKogi+yKg0rq06rWL2ltva7d7vffXvbe93W9vN622tra1tSoq+44oiOxCyAohbAnZWLKQPZnv74/vjI0YyEwyM2dOOO/X67xm5qwfyJx5zvf5PosopbCwsLCwsHAVP6MFWFhYWFiYE8uAWFhYWFj0C8uAWFhYWFj0C8uAWFhYWFj0C8uAWFhYWFj0iwCjBXiT6OhoNXr0aKNlWFhYWJiKQ4cOXVBKxVy9/oYyIKNHj+bgwYNGy7CwsLAwFSJyprf1lgvLwsLCwqJfWAbEwsLCwqJfWAbEwsLCwqJfWAbEwsLCwqJfWAbEwsLCwqJfGGpAROQFEakVkYJrbBcR+aWIlIlIvohM7rFtoYiU2rc97T3VFhYWFhZg/AjkT8DC62xfBKTbl8eAZwBExB/4jX17NvCAiGR7VKmFhYWFxYcwNA9EKfWOiIy+zi7LgT8rXXN+r4hEiUgCMBooU0qVA4jIy/Z9izyr+MPYbIqyuitUXm7lfEMrTW1dZMVHMHFkFFFhQd6UYmFGOlqgfCe0XPznuphMSJoKfkY/2/VNfUsHxVVNlFQ30m1TjIkOZ3R0OKOGhxHg7/v6LQaOrycSJgHnenyusK/rbf303k4gIo+hRy+kpKS4RVRzexerDlfwx3dPc+pCc6/7pMUO4bO3jeHeycnWzWTxT5SCkvVw7BU4sRU6Wz66T0QijLsLpjwCcTne13gdbDbFlqJqfrm9jKKqxl73iR4SzKdnjuGTN6cQERLoZYUW3sTXDYj0sk5dZ/1HVyr1HPAcwNSpUwfUPUspxV/3nuEnm0tpbOsib2QUP753AmNjh5AYFUJYYACF5xs4UlHP5oJq/mPVMX6/6xT/vjCLueNiEelNtsUNQ/05WPcUlG2D8FjIewCyl8HwsXq76oZz+6FoNRz6Exz4Pcx8Cmb9OwSGGCodYGdpLT/eVEpRVSOpMeE8vSiL7IRIshIiCPDz49SFZsrrrrDm6Hl+tKmE3+4s4/FZqXzujjT8/azv/mBEjO5IaHdhrVNK5fay7XfATqXU3+2fS4E70C6sbyulFtjX/yeAUup/rnetqVOnqv6WMrnS3sXTq/JZl1/FbenRPDU3gymjhl1zf6UUmwur+fGmUsovNPPg9BS+uyzHGo3ciCgFB1+Ard/U7+d+C276DPj5X/uYlkuw5etw5CWIzoAVz0DyVO9p7oHNpvjF9hP8cvsJRo8I44tz01mWl3Rdo5BfUc+vd5SxpaiG29Kj+eX9kxgWbrl1zYqIHFJKfeQL6OsGZAnwJLAY7aL6pVJqmogEAMeBOUAlcAB4UClVeL1r9deAlFQ38q9/PcyZSy18dX4mj89Kxc/JJ6qubhs/23qcZ3aeZFZGDL95cJI1rL+RUAq2fgP2/ApSZ8Nd/wfDRjl/fNk2WPslaK6F+1+CtLme09oLLR1dfOWVo2wsqGbllGS+f3cuwQHXMXxX8fL+s3xzdSGxkcH87qEp5CQO9aBaC09xLQNidBjv34H3gEwRqRCRT4vIEyLyhH2XDUA5UAY8D/wrgFKqC21YNgPFwCt9GY+B8OKeMzS1d/G3z0znc3eMddp4AAT4+/EfC7P40b3j2VN2gY89+x41jW2ekmrhS9hssPHftfGY9hh88nXXjAdog/HYTohOh78/ACUbPKG0VxrbOrnvd3vZXFjN/1s8jp+snOCS8QC4f1oK/3j8Zrq6FR9/9j2OVTR4SK2FERg+AvEm/R2BtHZ009TeSWzEwPzQu09c4PG/HGR0dDivPH4L4cG+PgVl0W9sNj3fcfhFuOVJmP/fMJA5sNbL8Jd7oDof7v0D5Kxwn9Ze6Oiy8ak/HWBv+UWe+eQU5mXHDeh8NY1t3PPbPbR1drPqc7cyOjrcTUotvIFPjkDMQmiQ/4CNB8DM9Gh+/eBkiqsa+eLLR+i23TjG+4Zj98+08bjtKwM3HgChw+Dh1ZA0BV7/LFQeco/OXlBK8fTr+ewuu8D/3DN+wMYDIC4yhD9/eho2pXj4hf3UNlmj8MGAZUC8zOysWL69LIdtxTX8YEOx0XIsPEHZdtjxfRj/MbjzGwM3Hg5CIuGBl2FIPPzjYWi+2Pcx/eB/t53g9cOVfGluBh+bOtJt5x0bM4QX/uUm6praefSPB2jr7HbbuS2MwTIgBvDwLaN5dMZo/rD7FK8ePNf3ARbm4fIZWPVpiM3WE+buDt0OGw73/Rma62DVp8Dm3h/ht0pr+eX2E3xsSjJfmJPm1nMDTEoZxq8fnETh+UZ+uLHE7ee38C6WATGIry/J5ubU4XxnbREVl3tJJrMwH51t8MpDev7jvr9AkIf8/ImTYMnPdBb7ju+57bSXmzv499fyyYyL4Hsrcj2WtzRnXByfmjGGP+05zVultR65hoV3sAyIQfj7CT9ZmYdSin9/LR+bNR9ift75MVQdhbufhRFjPXutyQ/B5Idh9y908uEAUUrxX28co76lg5/fl0dIoGvRVq7y7wszyYqP4Guv5nPhSrtHr2XhOSwDYiAjh4fxjaXZ7Dl5kb/s7bXlsIVZqC6Ad/8P8h6ErMXeueaCH0BkEqz5AnR1DOhUb7xfycaCar48L9MruRohgf784v6JNLZ18h+v5XMjRYMOJiwDYjD33TSSOzJj+J+Nxdesq2Xh49i6Ye0XIGSojrjyFsERsPTnUFcM7/6i36epaWzjW6sLuWn0MB6blepGgdcnKz6Spxdmsb2klnX5VV67roX7sAyIwYgIP7p3AkH+fnxzdYH1JGZG9j+vw2oX/hDCR3j32hkLIOceeOcnUHe8X6f40aYS2rts/GRlntdrVj1y62hykyL5wYZiWjq6vHpti4FjGRAfIC4yhC/OzWDXiQvsLK0zWo6FKzRUwPbvwtg5OmzXCBb9CALDYO0XdekUF3j/7GVeP1zJp28bY0hyn7+f8O27cqhqaOO3b530+vUtBoZlQHyEh24eRWp0ON9bX0Rnt81oORbOsuO/wdalXUlGVVseEgvzvgNn90DxGqcPs9kU31lbRExEMJ+f7f6QXWeZOno4d09K4rl3yjlz0XLjmgnLgPgIQQF+fH3pOMrrmvmrNaFuDqoL4OjLMP0xGDbaWC0TPwkxWXo01N3p1CFvvF/JkXP1/MfCLIYYXFbnPxdlEegvfG+dV3vCWQwQy4D4ELMzY7ktPZpfbDvB5eaBRdVYeIHt39HZ4TO/bLQS8A+Aud+Gi2Vw+M997t7c3sWPNpWQNzKKeyYleVxeX8RGhvCFOelsK65lT9kFo+VYOIllQHwIEeEbS7NpauvkVzvKjJZjcT1O7YITW3Stq7DhRqvRZCyElFtg5w+h/cp1d33xvdPUNrXzzaXjXKou7UkeuXU0CUND+PnW41YwiUmwDIiPkREXwb2Tk3lp3xlqrbLvvolSujlUZJIu0+4riMC87+reIXt/e83drrR38fw75dyRGcOUUT5i/NC5IZ+fncbBM5fZdcIahZgBy4D4IE/emUaXTfHcO+VGS7HojeK1cP4wzP5/EBhqtJoPM3IaZC3VSY0tl3rd5cU9p7nc0slTczO8LK5vPj51JElRodYoxCRYBsQHGTUinBUTk/jrvjPUNVllHnwKpWDXT3Uf87z7jVbTO3d+HTquwL7ffWTTlfYunt9VzuzMGCaOjDJA3PUJCvDj3+5M48i5eiuk3QQY3ZFwoYiUikiZiDzdy/avicgR+1IgIt0iMty+7bSIHLNv61+jcx/myTvT6Oiy8fwuaxTiU5zcoetdzfzS9XuaG0nsOMhcAvuehfamD216cc9p6ls6+aIPjj4c3DslmZHDrVGIGTDMgIiIP/AbYBGQDTwgItk991FK/UQpNVEpNRH4T+BtpVTPcfls+/aPdMoyO2Oiw1k+MYm/vHeGi1axOd9h18/13MeE+4xWcn1u+zK01cOhP32wytdHHw4C/f34wp3pHKtssKr1+jhGjkCmAWVKqXKlVAfwMrD8Ovs/APzdK8p8hCfvTKOtq5vf7z5ltBQLgLP74Mxu3aI2IMhoNdcneSqMvg32/Bq69APIy/vP+vzow8GKSUkkDg2x5gF9HCMNSBLQs5tShX3dRxCRMGAhsKrHagVsEZFDInLNUBgReUxEDorIwbo6c/lUx8YMYfH4BP669wzN7VadIMPZ/XMIHQ5THjFaiXPc9hW4Ug1H/kZXt40/vnuaaWOG+/Tow0Ggvx+PzhjD3vJLHKtoMFqOxTUw0oD0Fnx+LYfnXcC7V7mvZiilJqNdYJ8XkVm9HaiUek4pNVUpNTUmJmZgig3g0zPH0NTWxWuHKoyWcmNTUwjHN8HNn/Ncoyh3k3qHbj717i/YfKyCyvpWPjNzjNGqnOb+aSOJCA6w5gF9GCMNSAXQs+FyMnD+Gvvez1XuK6XUeftrLfAG2iU26JicMoxJKVH88d1TVtMpI3nvNxAYDtM+a7QS5xHRk/2XT5O/42VGjwhj7rg4o1U5TURIIPdPG8n6Y1VU1rcaLceiF4w0IAeAdBEZIyJBaCPxkUpwIjIUuB1Y3WNduIhEON4D84ECr6g2gE/PHMPpiy3sKLEmFA2h+QIce02H7YYOM1qNa2QuoT08kTsuv8GnZ47xmaxzZ3l0xhgE+KM1D+iTGGZAlFJdwJPAZqAYeEUpVSgiT4jIEz12vRvYopTqWaYzDtgtIkeB/cB6pdQmb2n3Ngtz4kmKCuUP1k1kDIf+BN3tvpV17iz+AawPXsIt/kWsHNlotBqXSYwKZcmEBF4+cI7GNueKRFp4D0PzQJRSG5RSGUqpsUqp79vXPauUerbHPn9SSt1/1XHlSqk8+5LjOHawEuDvxyO3juK98osUnrcmFL1KdxccfAHG3A6xWUarcZmzF1v4XtVUOiWY0Pf/YLScfvHZ21K50t7FqweteUBfw8pENwn33ZRCWJA/L+w+bbSUG4uSddBYCdMfN1pJv3hp3xkaJZLOnHsh/xVovWy0JJfJTRrKpJQoXtp3xkos9DEsA2IShoYGcs/kJNbln6ehxRrKe439z0FUiq50azLau7p55eA55mfHETbzX6GzBd7/q9Gy+sUnp4+ivK6Z905eNFqKRQ8sA2IiHpw2ivYuG6sOW0N5r1BdAGfehZs+47tlS67DpoJqLrd08uD0FIgfDym36v7ttm6jpbnMkgkJRIUF8tK+s0ZLseiBZUBMRHZiJBNHRvG3/Wetobw3OPB7CAiBSQ8ZraRfvLT3LKNGhDFjbLReMf0xqD8DZduNFdYPQgL9WTk5mc2F1VabAx/CMiAm48HpKZTVXuHAafP5sk1FR7MO3c2523caRrnA8Zom9p++xIPTUv4Zupu5BMJj4PCLxorrJw9OT6HLpvjHgXN972zhFSwDYjKWTkggIjiAv+2z+qZ7lMI3oaMJJj9stJJ+8bd9Zwny92PllOR/rgwIgrwHdEZ9U41x4vpJaswQZqSN4O/7z9JtJdX6BJYBMRlhQQHcPTmJDQXVVt90T3L4zzAiXbeINRmtHd2sOlzBwtx4RgwJ/vDGyQ+DrQuOmrMu6Senj+J8QxtvWUm1PoFlQEzIg9NT6LAm0z1HXSmc26t/bMVcmdsA6/LP09TWxSemp3x0Y3S6nkw//GfdHMtkzM2OI3pIMK8ctNxYvoBlQExIVnwkk1Ki+Ls1me4ZDv8Z/AK0u8eEvHqogjHR4Uwbc425m8kPw6WTcGaPd4W5gUB/P+6elMiOklqrT44PYBkQk/LxqSM5WdfMkXP1RksZXHR1aPdO5mIYYr7qzWcvtrD/1CVWTklGrjV6yl4OwZHaUJqQlVNG0mVTvHnkWrVXLbyFZUBMypIJCQQH+FluLHdTugFaLsJkk/T8uIpVhysQgbsn9dpaRxMUBuM/BkVvQqv5HkAy4yOYkDzUanHgA1gGxKREhgSyICeetUeraO8yX2KYz3LkJd2yduxso5W4jM2mWHW4gplp0SRGhV5/58kPQVcbFKy6/n4+ysemJFNc1UhBpVUbzkgsA2Ji7p2STENrJ9uLrYgUt3ClVifZTfi4KTPP9526RMXl1g+H7l6LhIkQMw7y/+F5YR5gWV4SQf5+1ijEYCwDYmJmpkUTFxnMKusmcg/HXgPVDRPu73tfH+S1QxVEBAcwPzu+751FIO8+OLcPLpmv49/QsEDm5cTx5pFKawRuIJYBMTH+fsLdk5LZebyOuiYrImXA5L8MCXmmLNve3N7FxoIqluYlEBrk5Ohp/McB0VV6TcjHpiRT39LJDmsEbhiWATE5K6ck0W1TrD5SabQUc1NbAlVHTRu6u+FYFS0d3c65rxwMTYIxt8HRl02ZE3JbegxxkcG88b713TcKQw2IiCwUkVIRKRORp3vZfoeINIjIEfvyTWePvVFIi40gb2SU5QseKPkvg/hD7kqjlfSL1UfOM2pEGJNTXGy5O+F+uHwKKg54RpgH8fcT7pqQyM7SOqvFgUEYZkBExB/4DbAIyAYeEJHsXnbdpZSaaF++6+KxNwT3TEqipLqJ4zVNRksxJzYb5L8KaXNMmftR29jGnpMXWJ6XeO3cj2uRvQwCQk1b2mT5xCQ6um1sKKgyWsoNiZEjkGlAmb09bQfwMrDcC8cOOhaPT8BPYI2VWNU/zuyGxgqYcJ/RSvrFuvwqbAqWTUx0/eDgCBi3FApehy7zzaPlJkWSGhPOm5YbyxCMNCBJQM+CNhX2dVdzi4gcFZGNIpLj4rGIyGMiclBEDtbV1blDt88RExHMjLRo1hw9b5U26Q/5/4CgCMhaYrSSfrH66HlyEiNJi43o3wkm3A9t9XBii3uFeQERYcXEJPafvsT5+laj5dxwGGlAehtrX/3rdxgYpZTKA34FvOnCsXqlUs8ppaYqpabGxJjPPeEsyycmcfZSi1XaxFW62qForX4KD+wj+c4HOX2hmaPn6lnen9GHg9Q7ICzatEmFy/ISUQrWHrVG4N7GSANSAYzs8TkZ+NA3QCnVqJS6Yn+/AQgUkWhnjr3RWJATR1CAH6stN5ZrlG2H9gZTT56LwF15AzAg/gGQswJKN0H7FfeJ8xKjo8OZODLKqo1lAEYakANAuoiMEZEg4H5gTc8dRCRe7LOCIjINrfeiM8feaESEBDInK5Z1+VV0dduMlmMeClZB6HBIvd1oJS6jlGL10UqmjxlOwtABjp5y74WuVt1syoQsn5hIcVWjFUjiZQwzIEqpLuBJYDNQDLyilCoUkSdE5An7biuBAhE5CvwSuF9pej3W+/8K32JZXiIXrrSzt/yS0VLMQUezLp6YvRz8A41W4zKF5xspr2tm+cTrFE50lpE3Q0Siad1YSyck4u8nVj6Ulwkw8uJ2t9SGq9Y92+P9r4FfO3vsjc7srFgiggNYfaSSmenRRsvxfY5vhs4W/fRtQtYcPU+gv7Ao14nSJX3h5we598C+30HrZQh1MZ/EYGIigrl17AjW51fx1fmZroczW/QLKxN9EBES6M/8nHg2FVZb9YGcoWAVDImHUbcarcRllFKsz6/itvQYosKC3HPS3HvA1gkl691zPi+zZHwCpy+2UHi+0WgpNwyWARlkLM1LoKmti90nLhgtxbdpa4ATWyHnblNW3j1yrp7K+laWjE9w30kTJ8Ow0aZ1Yy3IicffT1h/zEoq9BaWARlkzBgbzdDQQNbnWzfRdSnZAN3tpnVfrc+vIsjfj7nZce47qYj+/yh/G66YL2dqWHgQM9KiWZdv5UN5C8uADDKCAvyYnx3H1qIay411PQpWwdAUSJ5qtBKXsdkUG45VMStDPyy4ldx7dUn74tXuPa+XWDo+gXOXWjlmNZryCpYBGYQsnpBAU3sXu45bbqxeab0M5Tt17oMJJ1vfP1fP+YY2FrvTfeUgNhuiM6DInAZkQU48gf5ijcC9hGVABiEON9YGyxfcO6Ub9WRx9gqjlfSLDcc84L5yIKLDmk/vhmbzPYAMDQtkZlo06/KrLDeWF7AMyCDEcmP1QdFqGDoSkiYbrcRl/um+iiEyxEO5K9nLQdmgZJ1nzu9hlkxIpLK+laMVlhvL01gGZJBiubGuQVsDnNyhfyRN6b66TFVDG0sneMB95SAuF4anQuGbfe/rg8zLjiPQX1hn1cbyOJYBGaRYbqxrcHwzdHdoA2JC1uVXERTgx5xxsZ67iIh27516B1rMV9VgaGggt6XHsLGg2nJjeRjLgAxSLDfWNSh8U5fsSDJf9JVSik0F1cxKjybCU+4rB9nLdTSWSZMKF+bEU1nfSkGllVToSfo0ICISLiJ+9vcZIrJMRMxXOOgGZPF47cbaU3bRaCm+QXsTlG3TP45+5nt2OlrRQFVDGwtzPei+cpCQB1GjTBuNNS87Dn8/YaPVqdCjOHMXvQOEiEgSsB14FPiTJ0VZuIdb00YQERxg3UQOjm/WyYMmdV9tLKgiwE+YN84D0VdX44jGKt+pw55NxrDwIG5OHc4my43lUZwxIKKUagHuAX6llLob3YfcwscJDvDnznGxbC2qsUq8g36aHhIPI6cbrcRllFJsLqjmlrEjGBrmJQdA9god7ly60TvXczMLcxMov9DM8Rrz9TgxC04ZEBG5BfgE4HCIGlrF18J5FuXGc7mlk/2nzDcZ6lY6WnTtq3FLTem+Kqlu4vTFFha6o/KusyRN1uHOxWu9d003siAnDhHYVFBttJRBizN30lPAfwJv2Pt1pAJveVaWj3Hg9/Dap41W0S9mZcQQEujHpsIb/CY6uV03TBp3l9FK+sXGgmpEYH62Fw2ICGQttXdtNN9TfGxECFNHDbNcuE018MfFUHHQ7afu04Aopd5WSi1TSv3I/rlcKfUFd1xcRBaKSKmIlInI071s/4SI5NuXPSKS12PbaRE5JiJHRMT9/zM9aa2Hgteg0Xxx5WFBAdyeEcPmwmpsthvYF1y8Tve4GDXDaCX9YnNBNTeNHk5MRLB3LzxuqZ43Ktvm3eu6iQU58Xr0dqHZaCnGUboezrwLgWFuP7UzUVhviciOq5eBXlhE/IHfAIvQcyoPiMjVcyungNuVUhOA7wHPXbV9tlJqolLKszGZjqdWk4Y0LspNoKaxnffP1RstxRi6O+H4RshYZMrOg+V1VyitaWJhjhdHHw5SboGwaNO6sRwuv403shureJ1ODI0d5/ZTO+PC+irwNfvyDeAI4I4n/mlAmX1E0wG8DHwoPEYptUcp5QgB2Qsku+G6rhOTCSPSTXsTzc6KJdBf2HyjurFO79IZ6CZ2XwHenf9w4OcPmYvgxBboavf+9QdI8rAwJiQPvXFduK31cOpt7Yr0QOUFZ1xYh3os7yqlvgy4I4wlCTjX43OFfd21+DTQMxxEAVtE5JCIPHatg0TkMRE5KCIH6+oG0ONg3FJdYM6kmbkz0qLZWHCDFpgrXguB4TB2ttFK+sWWwmrykoeSGBVqjIBxy6C9UWemm5AFOfEcPVdPdUOb0VK8z4ktYOvy2MOTMy6s4T2WaBFZALjjUag3c9jrr5uIzEYbkP/osXqGUmoy2gX2eRGZ1duxSqnnlFJTlVJTY2Ji+q826y6dmXt8c//PYSALc+I5d6mVoqobLDPXZtOux/S5EGjQD/AAqGrQRQEXGDH6cJB6OwRFQPEa4zQMgAU5Om9mS9ENOAopXqtD1z1UecEZF9YhtMvqEPAe8BX0j/lAqQBG9vicDHxkllpEJgC/B5YrpT5IqVZKnbe/1gJvoF1iniNxki6BYdIKpXOzdUjj1qIao6V4l4oDcKVGPwCYEMffy6vRV1cTEAwZ83UXR5v5yuKkxUaQGhPOlsIb7Lvf2aqDH7IWeyx03RkX1hilVKr9NV0pNV8ptdsN1z4ApIvIGBEJAu4HPvSIIyIpwOvAQ0qp4z3Wh4tIhOM9MB8ocIOma+Pnp91YZdt1ToHJiB4SzNRRw9h8o91ExWvAL1D/AJqQzYXVjI0JJy12iLFCxt0FLRfg7F5jdfST+dnx7C2/SENLp9FSvMfJt6CzxaNzf06ZJRG5VUQeFJGHHctAL6yU6gKeBDYDxcAr9jyTJ0TkCftu3wRGAL+9Klw3DtgtIkeB/cB6pdSmgWrqk6ylOpfg5HaPX8oTzM+Op7iqkXOXzGcA+4VSesSYejuEDDVajcs0tHSyt/wS842IvrqatHngH2zaQJIFOXF02RTbS26gB6iSdfp7P/o2j13CmTmQvwA/BWYCN9kXtzjUlFIblFIZSqmxSqnv29c9q5R61v7+M0qpYfZQ3Q/Cde2RW3n2JcdxrMcZNUPnEhSb0401/wNf8A1yE9UWweXT2vCbkO0lNXTbFAt8wYAED9FBCKXrtWE2GXnJUcRFBt84kYjdXboETcZCj4auO1OSZCqQrW7I8J2r8A/QuQSl63VugclyCkaNCCcrPoLNhdV8euYYo+V4npL1gEDmYqOV9IsthTXERQYzIclHRk9ZS+D4JqgpgPjxRqtxCT8/YV52HK8dqqC1o5vQIH+jJXmWs3ug9ZLHH56ccWEV4J6oq8HBuKU6p+DMu0Yr6Rfzs+M4ePoSF6+YL6bfZUrWQfJNEOGF6rVupq2zm7eP1zE/Ox4/Px/pnJixCBDTJtQuyImnrdPGrhMDCOc3CyXrISAE0uZ49DLOGJBooEhENovIGsfiUVW+TOpsCAjVESkmZH5OPDYF20tqjZbiWerPQdVR/dRsQnaduEBrZ/cHbkefYEiMrmRs0kjEm1NHEBkSMPgDSZTSv0+psyEo3KOXcsaAfBtYAfwA+FmP5cYkKAzG3qktvAm9ejmJkSRFhbJlsPuCS+0G3qTzH1sKq4kICeDm1BFGS/kwWUug+hhcPmO0EpcJ9PfjzqxYtpcM8vYG1ceg4axXHp6cLab4kcXjynyZrCXQWKGfcE2GiPYFv3PiAs3tXUbL8Rwl6yE6A6LTjFbiMl3dNrYV1zAnK5ZAfx8rPe/4UTJpj5D5OfHUt3Ry8Iz5mmQ5TekGED9dgsbDXB51r+EAACAASURBVPPbKSK77a9NItLYY2kSkRssnfkqMhbqP1CpWd1YcXR0DWJfcOtlXXbGpO6rQ2cuc7mlk3lGJg9eixFjIWacad1YszJiCPL3G9wJtSXrtKsxPNrjl7qmAVFKzbS/RiilInssEUqpSI8r82XCR+gqpSadTJw2ejhDQwMHbzjv8S267IxJ3Vdbi2oI8vfj9swBlN7xJFmL4cweU9aFGxIcwIy0EWwpGqStbi+f0S4sLz08OZMHMlZEgu3v7xCRL4hIlOel+TiZi3U44+XTRitxmQC7L3hHSe3g9AWXrNP1fxInG63EZZRSbC2u4da0EQwJ9tHGn1lLTF0Xbl62rgtXWtNktBT343Ateil03RkH6yqgW0TSgD8AY4C/eVSVGciy/4FMGo01LztucPqCO9t0uZnMRaZsXXui9gpnLrYwL9uHoq+uJsHkdeHGxQKwdTBGY5Ws0y7GEWO9cjln7jCbvezI3cAvlFJfAhI8K8sEDE+F2BzTurFmZcQQFOA3+ArMnXobOptN675yRMfNHefDBsTPPkF7cocu2GcyYiNDmJQSNfhcuC2XtGvRi3N/zhiQThF5AHgEcDxymCsF21NkLdYZn80X+97XxxgSHMCMsSPYWjzIfMEl63Xp8TGeq//jSbYW1ZA3Moq4yBCjpVyfrMW6UF+5OQMy52XHcayygaoG8xnAa3LCMffnvcoLzhiQR4FbgO8rpU6JyBjgr56VZRIyF4OywQnLF+wT2Gy61EbaHF2C3GRUN7RxtKKB+b7svnIw+jZtqEvNOQJ3lMffNphGISXrISJBuxi9hDN5IEVKqS8opf5u/3xKKfVDz0szAR/0CDHnTTTofMGVh+y9P8wZvru12NH7wwQGJCBYN+kq3aQNt8lIix1CanT44HFjGTT3Z75ZRl9CxPS+4Ikjoz744TI9petB/CF9ntFK+sXWohpGjwgzvveHs2QugeZaqDzY974+yLzsOPaWX6SxbRD0CDn1jp77y/Tuw5NlQAaKyX3B83PiyK8YJL7gkg0w2l5y32Q0tXXy3skLzMuOQ8RHiif2Rfo88Asw7Qh8XnYcnd2KnaWDIKG21Ji5P8uADBTT+4K1u8T0vuCLJ+FCqdefwNzF28fr6OxWvpl9fi1Co3SPHJNWZJiUMowR4UHmz0q32XT+hwFzf84kEmaIyPMiskVEdjgWd1xcRBaKSKmIlInI071sFxH5pX17vohMdvZYr2FyX/DYmCGMiQ5na7HJq/M6noK9GIHiTrYW1TA8PIgpo0w2espaAheOw4Uyo5W4jL+fMGdcLDtLa+noMt+9+wHnDxs29+fMCORV4DDwdeBrPZYBISL+wG+ARUA28ICIZF+12yIg3b48BjzjwrHe4wNf8CHDJPQXEWHuuFjeO3mBJjP7gks3QNx4iEoxWonLdHbbeKukljuzYvH3ld4fzuIo2GfSEfi87Hia2rrYf8p8ZVk+oHSDYXN/zhiQLqXUM0qp/UqpQ47FDdeeBpTZ29N2AC8Dy6/aZznwZ6XZC0SJSIKTx3oPhy/YxDdRZ7fi7eMm9QU3X4Bz+0w7+jhw6hKNbV2+nTx4LaJSdHdCk1ZkmJkWTUigH1uLTNzewMC5P2cMyFoR+VcRSRCR4Y7FDddOAs71+FxhX+fMPs4cC4CIPCYiB0XkYF2dh34gHb5gk95EU0YNY7iZfcHHN+l8HLO2ri2qITjAj1kZnq+e6hEyl2gDfsV8DyChQf7MTItha1GNORNqL5VDXbFhc3/OGJBH0C6rPcAh++KOuL3exupX/wWvtY8zx+qVSj2nlJqqlJoaE+PB6qaZi/Uk7sWTnruGh/D3E+7MiuWtklo6zVhcsWQDRCZDQp7RSlxGKcXWohpmpkUTFuSjxRP7ImsxoLQhNyHzs+M439BG4XkTdqlwPLR6ofdHbziTSDimlyXVDdeuAEb2+JwMnHdyH2eO9S4fFFc0qxsrjkYz+oI7WnQeTuYinZdjMoqrmqisb/Xt4ol9ET8Bho40bTTWneNiEcGcI/DSDRCXC8NGGXJ5Z6KwAu0l3F+zL0+KiDtqYR0A0kVkjIgEAfcDV/daXwM8bI/GuhloUEpVOXmsd4lK0ZO4Jr2JbkuPJjjAhI12Tr0NXa2mnf/YWlSDCMwx4/yHgw8Sat/SBt1kRA8JZkrKMPN995svwtn3DHXdOuPCegaYAvzWvkyxrxsQ9gq/TwKbgWLgFaVUoYg8ISJP2HfbAJQDZcDzwL9e79iBahowWYu1L7j5gtFKXCYsKIDb0qPN5wsuWQ/BkTBqptFK+sXW4momjYwiJsJ8tbs+ROZibcjLdxqtpF/My46jqKqRissmMoAnNuu5PwMfnpwxIDcppR5RSu2wL48CN7nj4kqpDUqpDKXUWKXU9+3rnlVKPWt/r5RSn7dvH6+UOni9Yw3HUVzRpL7gedlxVNa3UlxlkuKKtm79f50+DwKCjFbjMufrWymobDRX8uC1GD0TgoeaOBLRhAm1JeshMgkSJhomwRkD0i0iH3QnEZFUoNtzkkxMQp6ezDVpNNadWXHm8gVXHITmOtNGX22z1yAz9fyHA/9AbchLN2nDbjJSY4YwNibcPHXhOlt9Yu7PGQPyNeAtEdkpIm8DO4CveFaWSelZXNGEvuCYiGAmpwxji1li4kvX6/ybtLlGK+kXW4tqSI0JN0/xxL7IXAQtF6DigNFK+sW87Hj2lV+iocUECbXlb+safAY/PDkThbUdnQn+BfuSqZR6y9PCTEuWwxdszv+i+dlxFJ5vpLLeBMUVSzZo10lolNFKXKahtZP3Tl4cHKMPB+nzwC/QtJGI83Pi6LIp3io1QVmfknV67m+0sY3TrmlARORO++s9wBIgDRgLLLGvs+iNUTP1H9akbizT+IIvnICLJ0xbPHFnaS1dNmWO3h/OEjJUV4MtWQ9mCsSwMzFZBzP4vAvXMfeXNtfwub/rjUBut7/e1ctizobT3iAgSD+JHTe3L9jn3Vgl9u7KJg7fjR4SzMSRJiue2BeZi+HSSV1g0WT4+em6cDtLa2nv8uF71zH35wON065pQJRS37K//a5S6tGeC/A978gzKVlLtC/43H6jlfSL+Tkm8AWXbNDRJ0OTjVbiMu1d3ewsrWPuOBMWT+yLTPMn1DZ3dPPeyYtGS7k2PjT358wk+qpe1r3mbiGDijS7L9jEIY0+7QtuqtYTtT7wBNYf9pZf4kp71+Ca/3AwNAkSJ5vWgNw6NpqwIH/fdmOVbIAxs3xi7u96cyBZInIvMFRE7umx/AsQ4jWFZiQkElJvh+J1li/YE5RuBJRpDcjWomrCgvyZkWbS4ol9kbVEt7ltrDJaicuEBPozK10XV7TZfPDerTuu5/585Lt/vRFIJnquI4oPz39MBj7reWkmJ2sJXD4FdSVGK3EZ7QuO811fcMl6GDYaYo1rAdNfbDbFtqJaZqXHEBLob7Qcz+D4cTNpWZ/5OXHUNrWTX9lgtJSP4pj785Hcp+vNgay2z3csvWoO5AtKqT1e1GhOMuzVMR1/cJMxP0f7gvf4mi+4vUnXv8pcYsriiccqG6hubBuc7isHMVkwPNW0bqw5WXH4+wmbC30wkKRkvXYRRiYarQRwbg7kCRH5wNkmIsNE5AUPahocRCZA0lTT3kS3jh1BeJA/Wwp9zI1Vtg26O3xmCO8qmwurP2ilOmgR0X+fU+9Am/lKpA8NC+Tm1OFs8TUD0lilXYM+9N13xoBMUErVOz4opS4DkzwnaRCRtQTOvw8NFUYrcZngAH/uyIpla1EN3b7kCy5ZD2EjYOR0o5X0iy1FNdycOpyoMPPV7nKJrKVg64SyrUYr6Rfzs+M5WddMWe0Vo6X8E4dLMMt3siicMSB+IvJBsLq9G6FJO994GccfunSjsTr6yYKceC5caef9s5eNlqLp6oDjWyBjIfib7yt4su4KZbVXmD8Yiif2RfJNEBZt2hG4w8XoU4EkJeth+FiIyTRayQc4Y0B+BuwRke+JyPfQnQl/7FlZg4SYDBiRbtp5kDsyYwj0F7b4yk10Zje0N/jUEN4VHO7AQT3/4cDPX9fGOr4FutqNVuMyiVGhTEge6jvzIG0N2iWY5Vtzf87UwvozsBKoAWqBe5RSf/G0sEFD1hI4vRta6/ve18eIDAnk1rHRbC6s9o0eIcVrITAMxt5ptJJ+sbmwmgnJQ0mMCjVaincYdxd0NOkfPhOyICeeI+fqqWlsM1oKnNiqXYI+5L4C50YgACXA68Bq4IqIpHhO0iAjaynYuuD4ZqOV9Iv5OXGcudhCaY3BPUJsNp1AlTYXAs33A1zT2MaRc/WDq/ZVX4y5HYKGaMNvQub7khurZB2Ex0LyVKOVfAhnWtr+G3r0sRVYB6y3v/YbERkuIltF5IT99SMFgURkpIi8JSLFIlIoIl/sse3bIlIpIkfsi28ERfdG0hSISIASc95E87J1jxDDo7EqD8KVav1Ua0IcbsAFOTfA/IeDwBBIn68nf01YFy4tdghjosONd+F2tmlXYNYS7Rr0IZwZgXwRXcI9Ryk1wd4ZcMIAr/s0sF0plQ5st3++mi7gK0qpccDNwOdFpGfm2P8qpSbaF9/NWPLz06OQE9tM2SMkNiKEySnDjPcFF6/V9X/S5xuro59sKaxmTPQg6v3hLOOW6sJ/5/YZrcRlRIT5OXG8d/ICDa0G1oUrfws6m/X/pY/hjAE5B7g7JXM58KL9/YvAiqt3UEpVKaUO2983oXufJ7lZh3cYt1T3CDm53Wgl/cLRI+TcJYMMoFLagIy53Sfq/7iKo/fH/Jw4xIcmQL1C2jzwD9JlfUzIgpx4OrsVb5UYWBeueK1uFzx6lnEaroEzBqQc2Cki/ykiX3YsA7xunFKqCrShAK6bVSUio9G5Jz0fY54UkXwReaE3F1iPYx8TkYMicrCurm6AsvvJqBkQOszUNxFg3FC+tkiXhfHBJzBn2FFSQ5dN3VjuKwchkZA6W7twfSEQw0UmJkcRHxnCpgKDRuDdXdoFmLnQ8N4fveGMATmLnv8IAiJ6LNdFRLaJSEEvy3JXBIrIEHRF4KeUUo601mfQza0mAlXoUONeUUo9p5SaqpSaGhMT48ql3Yd/oK5dc3yjzmUwGaOjw8mKj2CzUTdR8TpATNs8auOxauIjQ5iYbL7Rk1sYtxTqz0J1vtFKXMbPT1iQE8fO47W0dHR5X8CZd6H1ss9FXzlwJoz3O0qp7wA/B37W43Nfx81VSuX2sqwGakQkAcD+2uv4UEQC0cbjJaXU6z3OXaOU6lZK2YDngWnO/GMNZdxdOpb79C6jlfSLhbnxHDhzidomA0IaS9bqzPMI80UwNbd38fbxOhbmxuM32Hp/OEvmYhA/847Ac+Np67TxznEDPBjFayEgFNLmeP/aTuBMFFauiLwPFACFInJIRHIGeN01wCP294+gw4Ovvq4AfwCKlVI/v2pbQo+Pd9u1+TapsyEw3LQhjYtyE1DKgGisy6eh+php3VdvH6+jvct2Y7qvHIRHQ8otpv3uTxs9nGFhgWz09gjcZtPhu2lzICjcu9d2EmdcWM8BX1ZKjVJKjQK+gn7qHwg/BOaJyAlgnv0zIpIoIo6IqhnAQ8CdvYTr/lhEjolIPjAb+NIA9XiewBDImK/LEZgwpDEjbgip0eHe9wU7fnR8dAjfFxsLqhkRHsS0McONlmIs45ZBXbHuZW8yAvz9mJ8dz45iL7c3qDwETVX6/85HccaAhCul3nJ8UErtBAZkDpVSF5VSc5RS6fbXS/b155VSi+3vdyulxB46/KFwXaXUQ45wYqXUMseEvM+TtRSaa03Z6lZEWJgbz3vlF7nc7MV5nKLVunXt8DHeu6abaOvsZkdxDfNz4gZf61pXceTvFH3E2WAKFubG09TexZ4yL7Y3KF6jQ9czfDd03akoLBH5hoiMti9fB055WtigJGMB+Aeb9iZalJtAt02xtdhLbqyGCt26Ntt3n8Cux7tlF2ju6L6x3VcOhibpAosm/e7fmjaCiOAA743AldL/V2Nm6QhOH8UZA/IpIAZdyuR1IBp41JOiBi3BEdqfWbxG+zdNRm5SJElRod67iRzuq3EuBe75DJsKqokICeDWsYO0da2rZC/XkViXyo1W4jLBAf7cOS6WrcU1dHV74d6tOgr1ZyD7IylyPsX1eqI7CiY+bO9CONm+PGXvCWLRH7JXQGOlLs1hMhxurN0nLtDU5oXM3KLVEJcL0Wmev5ab6ey2sbW4hnnj4ggKcLbk3CDH4csvWmOsjn6yMCeeS80d7Dt1yfMXK3oTxN/n5/6u982eIiKjgE/ZuxAO77l4S+CgI3Ohzsw16VB+UW48Hd02dng6M7exCs7u1U+tJmRv+UXqWzpZkGu5rz5g2ChInGTa7/4dmbGEBvqz/piHp1w/cF/dBuEjPHutAXI9A/IssAnIAg5dtZjv8dlXCBmqy5EXrTZlZu7klGHERQazwdM3Uck6QJnWgKzPryI8yJ/bMwxKXvVVspfD+cM6sdBkhAZpN9bmgmrPurGqj2k3n4+7r+A6BkQp9Ut7IcMXlFKpSqkxPZZUL2ocfGQvh4ZzUHnYaCUu4+cnLMpNYGdpHVfaPZiZW7QaYrJ8qvuas3R229hUWM287DhCAn2reqrhONxYJs0JWTo+gYvNHez3pBuraLVOvDRB5WlnMtE/5w0hNxSZi8AvEIreMFpJv1g6IYH2LhvbPRWNdaVWl3Aw6ejjvZPafbV4fELfO99ojBgL8eNN78Za56kRuFJ6/mP0TJ2A6eNYs3tGEDoMUu8wtRsrPjKEdfkeuomK14Ky+XQC1fVYn1/FkOAAZlnuq97JXq7LuzdUGK3EZUKD/JnjSTdWbRFcLDOF+wosA2IcOSu0H/j8+0YrcRk/P2Hx+ATeLq3zTDRWwesQnQlxA62Y430s95UT5NyjXwvfNFZHP1niSTdW4ZumcV+BZUCMI3OxzjItNKkbKy+Bjm4b29ztxmqs0u6r3HvAhL0z3i3TzYeWWO6razNiLCTkQeHrfe/rg9yRGUtYkAfcWErp34NRM2DIdTtc+AyWATGKsOE6GqvwDVMmFU4aGUVSVCjr3e3GKnoTUP98SjUZ6/OriAgO4LYM3/dfG0ruvbrW0yXzFbUIDfLnziwPuLGqj8HFE/rhySRYBsRIclfqaKwKc9bGWjw+nneOu7ndZ8EqiBsPMRnuO6eX6OiysdnuvgoOsNxX1yXnbv1q0lHI0gnajbW33I1urILXtFfCRJUXLANiJFmLISBE/2iakCUTErUby12dCi+f0bWvTPQE1pPdZXU0tnVZ0VfOEJUCydOgwJwu3DsyYxkSHMCao5XuOaFSeu4vdbbPJw/2xDIgRhIcoQssFr6hW1eajLzkoSQPC2XN0fPuOaFjPsjxdGoyVh85z9DQQCv6ylly74GaY1B33GglLhMS6M+CnHg2FlS7p8R7xQHtjRi/cuDn8iKWATGa3Huhuc6UnQpFhGV5iewuu8CFK+0DP2Hh65A0xZSl21s6uthSWMPi8QlW7StnyV4BiGndWMsmJtLU1sXOUjd0Kjz2mvZGZC7ue18fwpBvur2e1lYROWF/7bVesYictjeOOiIiB1093hSkz4egCNO6sVZMSqLbpgY+mX7xpK5Amnuve4R5ma1FNbR2drN8YqLRUsxDZIJOmCtYZcp8qBljRzAiPIg1RwY4Ard169F3+nwIiXSPOC9h1KPS08B2pVQ6sN3++VrMtjeTmtrP432bwFDIWqJLvHe54Sney2TERZAVH8HqIwP0BR97DRDTJFBdzZoj50kYGsK00VadUZfIvQcuHNcRSCYjwN+PJRMS2FZcM7CyPqd36UZzJnx4MsqALAdetL9/EXD1V2Ogx/sW41dCWwOUbTdaSb9YMSmJw2frOXuxpX8nUAry/6GfRocmuVecF7jc3MHbx+tYlpeI343eedBVslfosj75/zBaSb9YPjGR9i4bWwoH0COnYBUEDdHzoSbDKAMS52hDa3+9VtaMAraIyCEReawfxyMij4nIQRE5WFfnBl+lJ0i9A0KHw7FXjVbSL+7K026bfo9CKg/BpZMw4T43qvIe649V0WVTLLPcV64TNly7bo69pl05JmNyyjCSokJZ3V83VmebLmmUtUR7I0yGxwyIiGwTkYJeFleCnGcopSYDi4DPi8gsV3UopZ5TSk1VSk2NifHR6Bj/QD0KKVkPrfVGq3GZpKhQpo0ZzptHKlH98WUffVlPIJq0de2aI+dJix1CdoK5/Nc+Q959cKUayncarcRlRIRlE3UgycX+BJIc36S9D3n3u1+cF/CYAVFKzVVK5fayrAZqRCQBwP7aa3cipdR5+2st8AYwzb7JqeNNRd790N1u2iqlKyYmcbKumcLzja4d2N2ph/CZi3SvFJNRWd/K/tOXWJ6XiJiw9IpPkL4AgodC/itGK+kXyycm0m1TrO1POPvRlyEiAcbc7n5hXsAoF9Ya4BH7+0eAj/xqiki4iEQ43gPzgQJnjzcdiZMhOkN/oUzI4vHxBPqL626ssm3QegkmmPMJ7M339b93+UTzzd34DIEhurho8VroaDZajctkxUeSnRDJqsMufvev1EHZVpjwcfAzZ+UCowzID4F5InICmGf/jIgkisgG+z5xwG4ROQrsB9YrpTZd73hTI6LnAM7ugcunjVbjMlFhQdyRGcubR867Vh8o/x8QNgLS5nhOnIdQSrHqUAXTxgwnZUSY0XLMzYT7oLNZu3FNyL1TkjlW2cDxmibnDypYBbYu0z48gUEGRCl1USk1RymVbn+9ZF9/Xim12P6+XCmVZ19ylFLf7+t40+OYRDbpUH7llGTqmtp554STwQptDVCyQYcv+gd6VpwHOHy2nvILzayckmy0FPOTcgsMTTHtCHz5xEQC/IRVh1zocZL/MsRPgLhszwnzMFbKrC8RNRJG3wZH/27KxKo7s2IZER7EqwedvImKVut5H5NGX712qILQQH+r9pU78PODCR+D8regaQAhsQYRPSSYOzJjef39SudG4LUluhdQ3gOeF+dBLAPia+Q9AJfKdW0ckxHo78eKSUlsK67hUnNH3we8/xKMSNPlS0xGW2c3646eZ1FuPEOCA4yWMzjIe0B3ojTpKGTllCTqmtrZVXah753zXwbxN13tq6uxDIivkb0MAkLhyEtGK+kXK6ck09mtWNPXZHrdcTi3FyY9ZMrGUZsLq2lq77LcV+4kOh1G3gzv/8WkI/A4hoUF9u3GsnXD0X/oeT+TNI66FpYB8TWCI3REyrFV0H7FaDUuMy4hktykSF7t6yZ6/8+694FJh/CvHaogKSqUm1PNU3rbFEx+WPcEP/ue0UpcJijAj2V5iWwpqqGh5To9csq2QdN5mPRJ74nzEJYB8UUmPwIdTfbufOZj5eRkCs83UnStnJDuTu2myFgIEXHeFecGqhvaeLfsAvdOTrJKl7ibnBW6uOjhvxitpF+snDKSji4ba/KvkxNy+M8QHgMZi7wnzENYBsQXSbkZojPh0It97+uDLJ+YRKC/8Oqhc73vcHyTLmE/6SHvCnMTrx06h03BPZMt95XbCQrXBRaL3oQ2F5NSfYDcpEjGJUTy931ne6/K0FQNpRth4oMQEOR9gW7GMiC+iIgeylfsh9pio9W4zLDwIOZlx/HG+5W0dfZS3+jwX2BIPKTN9b64AdJtU/x9/zlmpI1gdHS40XIGJ5Mfhs4WU7Y4EBEenJ5CUVUjRysaPrrDkZdAdWsvwyDAMiC+St79ukqpSUchn5g+ivqWTjYcu6pPSON5nX078UHwN1/00tvHa6msb+UT00cZLWXwkjQFYsbpyXQTsmJiImFB/vxt35kPb7DZtPtq1EwYMdYYcW7GMiC+Sng0jFuqw/0624xW4zK3jh1BanQ4f9171U105CUdqmnSCcSX9p4lJiKYednmm7sxDY4ReOUhqCk0Wo3LRIQEsiwvkbVHq2hs6zGZfnqXrjIxZXCMPsAyIL7N5Eeg9TKUrDNaics4hvKHz9b/czK9uwsO/gnGzDLlE1hlfStvldZy39SRBPpbt45HybtfV2g+8HujlfSLB6en0NrZzer3e4SzH34RQqJgnDmrTveGdRf4MmNuh2Gj4cAfjFbSL1ZOSSY4wI+XHEP54xuhsQKmPW6ssH7yj/1nUcD900YaLWXwEzYcclfqaD0TtjiYkBxFblIkLzkm06/U6mKReffr4pGDBMuA+DJ+fnDTZ3SBxap8o9W4TFRYEEsnJPLm+5W65ef+52DoSB2+azI6u228fOAcd2TEkDzMKpzoFaZ9Vk+mH/270Ur6xQPTUiipbuL9c/Vw6E/Q3aHv50GEZUB8nUmfhMAw2P87o5X0i0/enEJzRzc7dr0Dp96BqZ8y5eT59uIaapvarclzb5I4EZKnwf7n9QS0yVg+MYkhwQG89O4J7UVIm6uz7QcRlgHxdUKH6WFv/qvQfNFoNS4zcWQUOYmRsP95lH+wnhw1IS/sPk1SVCh3ZPpoV8vByrTHdLvj8h1GK3GZIcEBfHzqSLoLV+uOi9OfMFqS27EMiBmY9riuWnv4T0YrcRkR4TM3jWBO+3ZqRy3R0WUm4+i5evafvsSjM0YTYE2ee5fs5RAeq0chJuTRGaN52G8Tl0JSYKz5et70hXU3mIHYLEidDft/r8uAmIylvE24tPOb5juNltIv/rD7FEOCA7jvJmvy3OsEBMHUR+H4Zl2l2mSMbClmsl8Zv2ufS2uX+QpE9oUhBkREhovIVhE5YX8d1ss+mSJypMfSKCJP2bd9W0Qqe2xb7P1/hZeZ/oQuwFa81mglrtHdReD+Z6mOGM+fzwynpNpc5SnO17ey/lgV9980kogQ8zW9GhRMeVQX3tz7jNFKXGffs3QHDuGvrTNYddiFZlMmwagRyNPAdqVUOrDd/vlDKKVKlVITlVITgSlAC/BGj13+17FdKbXh6uMHHenzYdgYnN+tLAAAFcBJREFUeO835ip1XfQmXD5NxNyvEhroz+93nTJakUu8uOc0AP8yY7ShOm5oIhMg7z6dxX3FyW6XvkBDJRS+gd/kT5KaFM8L757CZjPRvesERhmQ5YCjRseLwIo+9p8DnFRKneljv8GLnx/c+m9QeVBHM5kBpWD3LyA6g/Dxy/j41GRWH6mkptEcmfVX2rv42/6zLMqNt0J3jebWL0JXu7miEff8ClDILZ/n0zPHUF7XzNvHTWQAncAoAxKnlKoCsL/21VXlfuDqYPAnRSRfRF7ozQXmQEQeE5GDInKwrs7kf7yJn9BFCHf91GglzlG2HWqOwYynwM+PT80cQ7dNffBU7+v848A5mtq6+MxtqUZLsYjJgKwlOpeovcloNX1zpU7nfky4D6JSWDw+gYShIfx2Z1nvVXpNiscMiIhsE5GCXpblLp4nCFgGvNpj9TPAWGAiUAX87FrHK6WeU0pNVUpNjYkxeQhmYIgehZx6B86ZoOXt7v+FyCQY/zEARo0IZ0FOPH/de+bDNYJ8kLbObn739kmmjxnOxJFRRsuxAJj5JWhr0D/Mvs7e30JXm9aMbjb1xO1jOXD6Mu+Vmy8c/1p4zIAopeYqpXJ7WVYDNSKSAGB/rb3OqRYBh5VSNT3OXaOU6lZK2YDngWme+nf4HFP+BUKH+/4o5Nx+OLMbbnnyQ30PPj87jca2Ll7Y7dtzIX/ff5bapnaempthtBQLB8lTYfRteh6wq91oNdemtV7X8MpZ8aHEwftuGklcZDD/t+2EgeLci1EurDWAoyTlI8Dq6+z7AFe5rxzGx87dQIFb1fkywUPg5s/ppkzVx4xWc212/UwnQV6VOJibNJSFOfH8Ydep67f9NJC2zm6e2XmSm1OHc8tYq2WtTzHzS9BUBUf+ZrSSa7P/eWhvhJlf/tDqkEB/nrh9LPtOXWLvIBmFGGVAfgjME5ETwDz7Z0QkUUQ+iKgSkTD79tevOv7HInJMRPKB2cCXvCPbR5j2Wd328x0fHYWc3asN3C1PaoN3FU/NS6epvYvnd/lmXP/f9unRxxfnWKMPn2PsnZB8E7z9Y+hsNVrNR2m/ot1X6QsgYcJHNj8wLYWYiGB+uX1wjEIMMSBKqYtKqTlKqXT76yX7+vNKqcU99mtRSo1QSjVcdfxDSqnxSqkJSqlljgn5G4bQYXDzEzpEtvKw0Wo+jFKw7dswJE6PlHohKz6SJRMS+OO7p7jU3OFdfX3Q1tnNM29bow+fRQTmflvnRO1/zmg1H2XPr6D1Etz+H71uDgn05/FZqew5eZEDpy95WZz7sTLRzcqtX4CwaNjyDd/KCzmxBc6+p2+goGu3fH1qTjotnd08945vjUJe2neWOmvuw7cZPRPS5sGun/tWqfematjzS8i5G5KnXHO3T0wfRfSQYH68qcT0EVmWATErIZFwx9N6ovr4ZqPVaGw22PYdGJ7aZ9HE9LgIluUl8uKe01Q1+IYr4nJzB7/cfoKZadHcnGqNPnyaOd+Etnr9g+0rvPUDXWpozjevu1tokD9fnpfBgdOX2VhQ7SVxnsEyIGZmyr/AiDTY+k3d7c9ojr0KtYVw59fBv++yH1+dn4lNKX6wocQL4vrm51uPc6W9i28szTZaikVfJEzQ4eHv/VY/+RtNbYnu4X7TZ/QDVB/cd9NIsuIj+MGGYto6u70g0DNYBsTM+Adqf/CFUjjyV2O1tF+B7d+F+AmQfbdTh4wcHsbjt49l7dHz7DM4KqWkupGX9p3hk9NTyIyPMFSLhZPM/i+wdelRr9Fs+xYEDYFZX3Nqd38/4ZtLs6m43MoL7/p2SPv1sAyI2claCiNvhh3/DS0GTsrt/B/drnbxT3XZFSf53O1jSYoK5VtrCunqNqZpkFKK76wpIjI0kC/Ns+Y+TMPwVJ1Ye/RvcGqXcTpObNNRhzO/BOHOuz5vTYtmXnYcv9lRRm2TOcr7XI1lQMyOCCz5KbRehi1fN0ZD1VEdujjlUUiZ7tKhoUH+/L8l4yipbuJv+896SOD12VxYzXvlF/nyvAyiwoL6PsDCd5j1NRg2GtY9ZUxyYXuTvnZ0BtzyeZcP/6/F4+jotvHDjb7hxnUVy4AMBuLH63pTR17S9ae8ia0b1n5RR4TN/Va/TrEoN55bx47gp5tLvV5o8XJzB99cXUhWfAQPTkvx6rUt3EBQGCz5GVws06VzvM3270JDBSz7NQQEu3z4mOhwHp81ltcPV7KtqKbvA3wMy4AMFmZ9TT8FrX1Kz0d4iwO/h/Pvw8L/0fkp/UBE+N6KXDq6bXz11aNeK3mtlOLrqwu43NLBTz+WZ3UbNCtpcyF3pa5+cMGLCXpn3tNZ59Mfd3nk3ZMvzEknKz6Cp18/5nN5UX1h3TGDhcAQWPYraDinn4q8QW2xThocOwdy7x3QqcbGDOHrS7LZdeICf/JStd41R8+zPr+Kp+ZmkJs01CvXtPAQC34AgaHw+me948rqbIM1/wZDR8Kd3xjQqYIC/Pj5xyfS0NrBN1abqyqTZUAGEyk366eh/b+DojWevVZ7E/zjIR15suK3ei5mgHxiegpzx8Xyw00lHu9ceL6+la+/WcCUUcN4fJZVrt30RMTBimf0aHjzf3n2WkrB+q/AxRNw1y96LdfjKtmJkTw1N+P/t3fnYVJVZx7Hvz+algbpBkGFZmlEBQUUNXYQxIgRohgVcRdFIejj6DMmLkPimoREJ+IyOpO4RGRUhkUCgriLECEQlJkGgQZkERG0BQEFZJGlod/541y0HizALqq6uqvez/PU01X33jr3vTRdb51z7jmHN0pX8+q8VUkIsmp4Ask0Pf4AzYthws2hhpAKZqHfY/3HcNlzkN80KcVK4qFLO1KQl8utL87lm52pGduyY9dubh09h90VxmNXeNNVxjj+/DBDQ8lQKB174OMTVTI03Dbf7U44tnvSiv2XM4/mlKKG3D2ulEWra8bSz/6Xk2ly8+DK4WEakdFXh7uzkq1kKCwYF6rurX+S1KIb16/Df1xxEh+t3cwto+ZQnuRbeysqjIFjSylZsYHBl3akVeN9T7fiaqDuv4Oi08MXnLUpuLNpxT/h7bug7XnQ7XsrcR+U2jm1ePqaU8nPy+X6F0pYWwNW7vQEkokKmsEV/wMbP4OXroddSeyYWzgB3roT2vYMd36lQLe2R3B/7xN4d/Fa7hk/P6nzBT00cTGvzVvFnT2Pp9dJzZJWrqsmcnJDrfiQejDyMtiwInllr/8ExvSDw1rDJc9UarzTD9W0QR7/3b+YjdvKuX7YrJTVwpPFE0imKuocbm/8+O8wug/s/Obgy1w4AV4aEBb2uXRoSv6A9rjmtFbc2r0NY2eX8cjEJUkp84UZn/DMP5bTt3MRN3Xzfo+MVVAIfceFfroXLkhOElm7GJ4/L4x8v2oU5KXuposOzRrwlz6nsHDV19wyag7bdh78VCfJKCMeTyCZ7NR+cOGfw9iQEZeE5UATFZs8+o6DOqmf7uO2Hm3o06mIp6Z+zG8nLGDnrsSas3ZXGH96cxGDXvuQHu2aMOjCDigJnf6uGis8Cfq9mpwk8vkHIXlYBfzirbA+e4p1b9eEB3qfyJQla7lqyPsHNVL9nYVfcMZD7zJ7ZfKbsz2BZLpT+4UqfdkseP78ynesl2+HiffC2P5VmjwgdKo/0PsEbjzzaIbPXMnVz86s9B/S5u3l3DCshCHTlnNdl1Y83fdH3mmeLWKTyJCzQr9dZZjBgvEwrFe402rA29Ck6ibavPq0IoZcW8zSNVu4+Mn3WLpmc6XeX767gj+9uYgbh8+mWcO6HJlf+YGOB6J0zEcv6XJgENAO6GRms/ZxXE/gv4AcYKiZ7Vm5sBHwN+AoYAVwhZkdML0WFxfbrFlxT5X5Ppoc7pHfsSnMH3Tmb0I78f6smgMv3wTrFkPxADjngf2u8ZFKr85bxZ0vlZKfV5tfn3scvU9pTu5+EsHuCuO1eat4bNJSPt+4jUG9OnBt51ZVGLGrNr5cBi/fCJ/Phg6XhKbdeo32/571n8CbA2HZZCg8Gfq8GPoW02B+2dcMGFbC19vK+cXpR3HzWccccMqd+WVf88fXF1KyYgN9Oxdx3/ntycvNSTgGSbPNrPh729OUQNoBFcAzwMB4CURSDrCUsKRtGVAC9DGzDyU9DKw3s8GS7gIOM7P4S4DFyOoEArD1qzD1+9wRUNACTrw0LL3Z8jTIqR2O2bYhNFeVjoFP34P8QrjoiTDaN80Wrd7EHWPmsWj1Jpo1yOOGnxzNGW0Op6hRPfJycyjfXcHydVuZ+9kGhkxbzsfrttKusIDfX9je1/fIdrt3wYzHYepgqJUbbvnteCUc89Pvlh7Y/jV8/C4sfQcWjg/HnX1fWEK6VuIfvsmwZtN2Hn57CePnlJFfpzb9u7amy9GN6diiAYfWqU1FhbFuyw4+WLmB52Z8QsmKDeTXqc0DF5/ARSc3P+jzV6sE8u3JpansO4F0AQaZ2bnR67sBzOxBSUuAs8xstaRCYKqZHXeg82V9AtljxQyY9nD4WVEOufVAtcIa0xZ1tjVuAyddGdY3SHCKklQwM6YuWcdTU5dRsiJUOiVokp/HV1t3UL47/H9u26Q+t/doy7kdmlKrlvd3uMiaD6Hk2dA0tT1azTDnEKhdF8q3hk7yvIZhluuz701brWNfFn+xiYffXsK7i9cCUEtwZH4eX27Zwa5oCqAWh9Wl/+lHceWPW5Kfd+B1eX6ImphALgN6mtkN0etrgdPM7BZJG82sYcyxG8ws7qecpBuBGwGKiopOXblyZQqupIbavgmWT4FPZwIKY0hy64XBUYUnJ2V0eSotWr2JpWs2s3zdVj5b/w1HFNShfWEBxzctoM2R9T1xuH3btROWTYIv5ocvTrt2hObZY3tAix9/VyOvpjZs3cncso3M/XQjn234hqYFeRQ2rEvrxofS5ZjG5CT5/36VJxBJk4F4Q5TvNbNXomOmsu8Ecjlw7l4JpJOZ/bIyCSSW10Ccc67y9pVAUpZmzexgG83LgJYxr1sAeyaJWSOpMKYJa+1Bnss551wlVef7GUuANpJaSzoEuArYM0Pgq0C/6Hk/4JU0xOecc1ktLQlE0sWSyoAuwBuSJkbbm0l6E8DMdgG3ABOBRcAYM1sYFTEY+Jmkjwh3aQ2u6mtwzrlsl9ZO9KrmfSDOOVd5++oDqc5NWM4556oxTyDOOecS4gnEOedcQjyBOOecS0hWdaJLWgfUxKHohwNfpjuIKpRt1wt+zdmipl5zKzM7Yu+NWZVAaipJs+LdAZGpsu16wa85W2TaNXsTlnPOuYR4AnHOOZcQTyA1w5B0B1DFsu16wa85W2TUNXsfiHPOuYR4DcQ551xCPIE455xLiCeQGkTSQEkm6fB0x5Jqkh6RtFhSqaSXJTU88LtqJkk9JS2RtEzSXemOJ9UktZQ0RdIiSQsl3ZrumKqCpBxJcyS9nu5YksUTSA0hqSVh6vpP0x1LFZkEnGBmHYGlwN1pjiclJOUATwLnAe2BPpLapzeqlNsF/JuZtQM6A/+aBdcMcCthaYqM4Qmk5ngc+A2QFXc9mNk70ZowADMJK1Jmok7AMjNbbmY7gdHARWmOKaXMbLWZfRA930z4UG2e3qhSS1IL4HxgaLpjSSZPIDWApF7A52Y2L92xpMkA4K10B5EizYHPYl6XkeEfprEkHQWcAvxveiNJuf8kfAGsSHcgyZSyNdFd5UiaDDSNs+te4B7gnKqNKPX2d81m9kp0zL2EJo+RVRlbFVKcbVlRy5RUHxgH3GZmm9IdT6pIugBYa2azJZ2V7niSyRNINWFmPeJtl3Qi0BqYJwlCU84HkjqZ2RdVGGLS7eua95DUD7gA6G6ZO2CpDGgZ87oFsCpNsVQZSbmE5DHSzManO54U6wr0kvRzIA8okDTCzPqmOa6D5gMJaxhJK4BiM6uJM3r+YJJ6Ao8B3cxsXbrjSRVJtQk3CXQHPgdKgKvNbGFaA0shhW9Cw4D1ZnZbuuOpSlENZKCZXZDuWJLB+0BcdfUEkA9MkjRX0l/THVAqRDcK3AJMJHQmj8nk5BHpClwLnB39budG385dDeM1EOeccwnxGohzzrmEeAJxzjmXEE8gzjnnEuIJxDnnXEI8gTjnnEuIJxCXkSRtiX4eJWlqFZ53qqTiFJXdX9ITlTj+JknXpSIW58BHojuXscwsI8fOuOrDayAu0+0G1sO3tZHpkj6IHqdH2y+WNFlBoaSlkppKOkLSOEkl0aPr3oVLqitpdLRuyd+AujH7zpH0fnSusdHcT0gaLOnD6D2Pximzk6T3orUj3pN0XMzulpLejtYP+X3Me66LypsnaXi0bZCkgdHzX8Wcc3S0rVvMQL45kvKj7b+OrrdU0h+ibYdKeiMqf4GkKw/y9+IygZn5wx8Z9wC2xNlWD8iLnrcBZsXsG0EYEf460CfaNgo4I3peBCyKU+YdwHPR846EiR+LgcOBacCh0b47gd8BjYAlfDeIt2GcMguA2tHzHsC46Hl/YDXQmJCoFkTn6hCVeXh0XKPo5yDCtBkQ5teqE3tO4DWga/S8PqFF4hxgCGGSx1rRv8eZwKXAszExNkj379gf6X94E5bLJrnAE5JOJtRM2sbs+yXhA3mmmb0YbesBtI8msYQwCV6+hTUs9jgT+DOAmZVKKo22dyYsEDUjev8hwPvAJmA7MFTSG4QP6L01AIZJakOYmTc3Zt8kM/sKQNJ44IzoWl6yaH40M1sfp8xSYKSkCcCEaNsM4DFJI4HxZlYm6RxCEpkTHVOfkGynA49Kegh43cymxzmHyzKeQFw2uR1YA5xE+Ha9PWZfc8JaDU0k1TKziuiYLma27QDlxpsPSIQP+z7f2yF1IkyeeBWh1nP2XofcD0wxs4uj9TKm7udcFp3rQHMSnU9Idr2A30rqYGaDoyT2c2CmpB5RWQ+a2TNx4j41OvZBSe+Y2R8PcE6X4bwPxGWTBsDqKDlcC+TAtzPiPg9cTZjQ8I7o+HcIH/BEx50cp8xpwDXR/hMIzVgQVlHsKunYaF89SW2jfpAGZvYmcBsQr8wGhJl5ITRbxfqZpEaS6gK9CbWIvwNXSGocnatR7Bsk1QJamtkUwqJGDYH6ko4xs/lm9hAwCzieMKnjgJj+muaSjpTUDPjGzEYAjwI/ihO3yzJeA3HZ5ClgnKTLgSnA1mj7PcB0M5suaS5QEn0z/xXwZNQsVZuQLG7aq8yngeejY+YC/wdgZusk9QdelFQnOvY+YDPwiqQ8wrf92+PE+TChCesO4N299v0TGA4cC4wys1kAkv4d+Iek3YTmp/4x78kBRkhqEJ3zcTPbKOl+ST8lNIF9CLxlZjsktQPej5retgB9o/M9IqkCKAdujv9P7LKJz8brnHMuId6E5ZxzLiGeQJxzziXEE4hzzrmEeAJxzjmXEE8gzjnnEuIJxDnnXEI8gTjnnEvI/wOCK5GMGmXJXwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline  \n",
    "#ignorez la ligne ci-dessus. c'est juste une commande de notre éditeur de texte\n",
    "\n",
    "x=np.linspace(-5,5,100)  # nous définissons une liste (array) avec Numpy \n",
    "plt.plot(x,np.sin(x))  # on utilise la fonction sinus de Numpy\n",
    "plt.plot(x,np.cos(x))  \n",
    "plt.ylabel('fonction sinus')\n",
    "plt.xlabel(\"l'axe des abcisses\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changer le style des courbes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f8a9eea7810>,\n",
       " <matplotlib.lines.Line2D at 0x7f8a9eea7a10>,\n",
       " <matplotlib.lines.Line2D at 0x7f8a9eea7790>]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU1d3H8c8vEzZZZDFssgtUwQUUbQsqgqWgotjHpYgiIoUHFYs+bqBWramtVltxawVBwKooBRcQwYUdAZFNZRHZhAQGEgxL2BIyOc8fM4SEhC0zyZ2ZfN+v17xm5p47c38j5jtnzj33XnPOISIi8SXB6wJERCTyFO4iInFI4S4iEocU7iIicUjhLiIShxK9LgDgjDPOcE2aNPG6DBGRmLJkyZIdzrmkotqiItybNGnC4sWLvS5DRCSmmNmmY7VpWEZEJA4p3EVE4pDCXUQkDincRUTikMJdRCQOKdxFRDziz/TTcUxHtu3dFvH3VriLiHgkeU4y8zbPI3l2csTfW+EuIuIBf6afkUtHkutyGb18dMR77wp3EREPPPzFwxzKPQRAwAUi3ntXuIuIlDJ/pp9xK8blPc8OZEe8965wFxEpZYOnDSbgAgWWRbr3rnAXESll09ZNK7QsO5DN/NT5EdtGVJw4TESkrJi5cSaZ2Zk83+V5Hmz/YIlt54Q9dzN708zSzGxFvmXPm9kPZvadmX1oZtXztQ01s3VmtsbMupZU4SIiscY5xyNfPkLDag0ZdMmgEt3WyQzLjAG6HbXsC+Bc59z5wI/AUAAzawX0BFqHXvMvM/NFrFoRkRg2YdUEvtn6DcmdkqmYWLFEt3XCcHfOzQEyjlr2uXMuJ/R0IdAg9LgH8J5zLss5txFYB1wSwXpFRGLSocAhHp3xKOfVPo/bzr+txLcXiTH3O4H3Q4/PJBj2h6WGlhViZgOAAQCNGjWKQBkiItFrxJIRrMtYx5ReU/AllPyARlizZczsMSAHeOfwoiJWc0W91jk3wjnXzjnXLimpyKtEiYjEhcysTJ6e8zQdG3fkquZXlco2i91zN7M+QHfgSufc4QBPBRrmW60BsLX45YmIxL5/LPgHafvSmHzLZMyK6gNHXrF67mbWDXgEuM45tz9f0ySgp5lVMLOmQAtgUfhliojEpu17t/PC/Be4qdVNXHJm6e2CPGHP3czGAVcAZ5hZKvAkwdkxFYAvQt9CC51zA51zK81sPLCK4HDNPc4ddRiWiEgZ8vTsp8kKZPFM52dKdbsnDHfn3C1FLB51nPWfAUr3U4iIRKG1P69lxNIRDLhwAC1qtSjVbev0AyIiJeSxGY9RwVeBJzo+UerbVriLiJSARVsW8d9V/+XB9g9Sp0qdUt++wl1EJMIOn2agduXaPPDrBzypQScOExGJsKnrpjLrp1m8etWrVK1Q1ZMa1HMXEYmgQG6AIV8O4awaZ9H/ov6e1aGeu4hIBL393dt8n/Y979/4PuV95T2rQz13EZEIOZhzkD/N/BPt6rfjxlY3elqLeu4iIhHy6qJXSdmTwtjrx5Jg3vad1XMXEYmAnQd28te5f6Vb8250atrJ63IU7iIikfDsvGfZdXAXz/3mOa9LARTuIiJhS9mdwktfv0TvC3pzfp3zvS4HULiLiITtyVlP4nA8fcXTXpeSR+EuIhKGFWkrGPvtWO695F4aV2/sdTl5FO4iIsXkz/TTcUxHKperzNBLh3pdTgEKdxGRYrpryl1kHMigdVJrap1Wy+tyClC4i4gUw5Y9W5i0ZhIA327/lm17t3lcUUEKdxGRYrj1g1txBC8fHXABkmcne1xRQQp3EZFTtDJtJbM3zc57nh3IZvTy0VHVe1e4i4icopv+e1OhZdHWe1e4i4icgkVbFrF6x+pCy7MD2cxPne9BRUXTicNERE5SIDfAXVPuon7V+vxwzw+eXYjjZCjcRURO0vAlw1nqX8q4G8ZFdbCDhmVERE5K2r40HpvxGJ2bdub3rX/vdTkndMJwN7M3zSzNzFbkW1bTzL4ws7Wh+xr52oaa2TozW2NmXUuqcBGR0vTIl4+wL3sfr139GmbmdTkndDI99zFAt6OWDQGmO+daANNDzzGzVkBPoHXoNf8yM1/EqhUR8cBXm79izPIxPPDrBzj7jLO9LueknDDcnXNzgIyjFvcAxoYejwWuz7f8PedclnNuI7AOuCRCtYqIlLqc3Bzu/vRuGp3eiMcvf9zrck5accfc6zjn/ACh+9qh5WcCKfnWSw0tK8TMBpjZYjNbnJ6eXswyRERK1quLXuW77d8xrOswKpev7HU5Jy3SO1SLGohyRa3onBvhnGvnnGuXlJQU4TJERMK3NXMrT8x8gquaX8X1Z19/4hdEkeKG+3YzqwcQuk8LLU8FGuZbrwGwtfjliYh458HPHyQ7kM3LV70cEztR8ytuuE8C+oQe9wE+zre8p5lVMLOmQAtgUXglioiUvhkbZzBuxTge6fAIzWs297qcU3bCg5jMbBxwBXCGmaUCTwLPAuPNrB+wGbgJwDm30szGA6uAHOAe51yghGoXESkR2YFsBn06iKbVmzLk0iFel1MsJwx359wtx2i68hjrPwM8E05RIiJeGrZwGKt3rOaTWz6hUrlKXpdTLDpCVUQkn5TdKfx59p/p8YseXNPyGq/LKTaFu4hIPvd/dj/OOV7q9pLXpYRF4S4iEvLZus+YuHoij1/+OI2rN/a6nLAo3EVEgIM5Bxk0dRAta7XkgV8/4HU5YdMpf0VEgBfmv8C6jHV8ftvnVEis4HU5YVPPXUTKvI07N/LM3Ge4qdVNdDmri9flRITCXUTKvMHTBuMzH//s+k+vS4kYDcuISJnlz/TT5T9dWJm+kue7PE+Dag28Lili1HMXkTLriVlPsDJ9JTUq1mDwLwd7XU5EKdxFpEzyZ/oZs3wMAPsP7efnAz97W1CEKdxFpEwaPG0wObk5ADgcybOTPa4oshTuIlLm/LTzJyasmpD3PDuQzejlo9m2d5uHVUWWwl1Eypwbxt+AO+o6QgEXiKveu8JdRMqUr1O/Zum2pYWWZweymZ8634OKSoamQopImbH/0H5u/+h2Gp3eiO/v+p5qFap5XVKJUbiLSJnx2PTH+PHnH/my95dxHeygYRkRKSNm/TSLYV8PY9DFg7iyWZHXGoorCncRiXuZWZn0/bgvzWs259nfPOt1OaVCwzIiEvce+PwBNu/ezNy+c6lcvrLX5ZQK9dxFJK5NXTuVN5a+wUPtH6J9w/Zel1NqFO4iErcyDmTQb1I/Wie15s9X/NnrckqVhmVEJG79ceofSd+fzie9PomLC3CcirB67mZ2v5mtNLMVZjbOzCqaWU0z+8LM1obua0SqWBGRkzVx1UTe+f4d/nT5n7iw3oVel1Pqih3uZnYm8EegnXPuXMAH9ASGANOdcy2A6aHnIiKlZvve7QycMpCL6l3E0EuHel2OJ8Idc08EKplZInAasBXoAYwNtY8Frg9zGyIiJ805x8ApA8nMyuSt371FOV85r0vyRLHD3Tm3BXgB2Az4gd3Ouc+BOs45f2gdP1C7qNeb2QAzW2xmi9PT04tbhohIAW9/9zYf/fARz3R+hlZJrbwuxzPhDMvUINhLbwrUByqb2W0n+3rn3AjnXDvnXLukpKTiliEikid1Tyr3Tr2XSxtdyn2/us/rcjwVzrDMb4CNzrl059wh4AOgPbDdzOoBhO7Twi9TROT4nHP0m9SPQ7mHGNNjDL4En9cleSqccN8M/MrMTjMzA64EVgOTgD6hdfoAH4dXoojIiQ1fMpzP13/OC11e4KyaZ3ldjueKPc/dOfe1mU0AlgI5wDJgBFAFGG9m/Qh+AdwUiUJFRI5lfcZ6Hvz8Qbo068LAdgO9LicqhHUQk3PuSeDJoxZnEezFi4iUuEBugL4f9yUxIZFR140iOJAgOkJVRGKWP9PPpaMvZcPODYy9fiwNT2/odUlRQ+eWEZGYdf9n97Nh5waanN6E3uf39rqcqKJwF5GY9NPOnxi/cjwA2/ZtY/u+7R5XFF0U7iISk7qP647DAZDrckmenexxRdFF4S4iMefVRa+yMn1l3vPsQDajl49m295tHlYVXRTuIhJTVqSt4L5p92EUnBUTcAH13vNRuItIzNiTtYcbxt+AYXlDModlB7KZnzrfo8qij6ZCikhMcM5x58d3sj5jPTP6zODyxpd7XVJUU7iLSEwYtnAYE1dP5O+/+buC/SRoWEZEot68zfN4+MuHuf7s63mw/YNelxMTFO4iEtW2793Ozf+9mSbVmzCmxxidXuAkaVhGRKJWTm4Ot0y8hZ0HdzL11qmcXvF0r0uKGQp3EYlaT8x8gpk/zWR0j9FcUPcCr8uJKRqWEZGoNGnNJP4272/0v7A/d7S5w+tyYo7CXUSizoadG7j9w9u5sN6FvHzVy16XE5MU7iISVQ4cOhA8UMmMCTdNoGJiRa9LikkacxeRqHLv1HtZvm05k2+ZTNMaTb0uJ2ap5y4iUePNZW8yatkoHr30Ubq37O51OTFN4S4iUWH5tuXc8+k9dG7amac7Pe11OTFP4S4intt1cBc3jL+BmpVqMu6GcfgSfF6XFPM05i4insp1ufT5qA+bd29m9h2zqV25ttclxQWFu4h4xp/pp8ObHdi4ayMvdn2R9g3be11S3NCwjIh4ZuCUgWzctZGzapzF4F8O9rqcuBJWuJtZdTObYGY/mNlqM/u1mdU0sy/MbG3ovkakihWR+LEwdSGT1kwCYEvmFl3gOsLC7bm/BExzzp0NXACsBoYA051zLYDpoeciInl27N9B17e75j3XBa4jr9jhbmbVgMuBUQDOuWzn3C6gBzA2tNpY4PpwixSR+HHg0AG6vd2NPVl78pbpAteRF07PvRmQDow2s2VmNtLMKgN1nHN+gNB9kbu+zWyAmS02s8Xp6elhlCEisSKQG+DWD25liX8JiQkF53PoAteRFU64JwIXAv92zrUF9nEKQzDOuRHOuXbOuXZJSUlhlCEiscA5x/999n98+MOHnFn1THJycwq06wLXkRXOVMhUINU593Xo+QSC4b7dzOo55/xmVg9IC7dIEYl9Ly58kZcXvcx9v7yPF7u96HU5ca/YPXfn3DYgxcx+EVp0JbAKmAT0CS3rA3wcVoUiEvPGrxzPA58/wI2tbuQfXf/hdTllQrgHMd0LvGNm5YENQF+CXxjjzawfsBm4KcxtiEgMm7NpDr0/7E2Hhh34z+/+Q4Lp8JrSEFa4O+eWA+2KaLoynPcVkfiwOn01Pd7rQdPqTfm458c6N3sp0leoiJQIf6afq965igq+Cky9dSq1TqvldUllis4tIyIRl5mVSfdx3dmxfwez7pili254QOEuIhF1KHCImyfczLfbvmXSLZNoV7+okVspaQp3EYkY5xx3TbmLaeumMaL7CK5ucbXXJZVZGnMXkYhJnpPMqGWjePyyx+l/UX+vyynTFO4iEhFjlo/hyVlPcvsFt+syeVFA4S4iYft8/ef0n9yfLs268Ma1b2BmXpdU5mnMXUSKzZ/pp/u47vyw4wdaJ7Vmws0TKO8r73VZgnruIhKGh794mKX+pRjGlF5TqFahmtclSYjCXUSK5btt3/HO9+8AkJObgy/B53FFkp/CXUROmT/TT8cxHXE4ABxO52KPMgp3ETklW/Zs4dLRl7Ira1feMl1JKfoo3EXkpKXsTqHjmI6k7E6hXEK5Am26klJ0UbiLyEnZtGsTHcd0JH1/Ok2qN+FQ7qEC7bqSUnTRVEgROaGNOzfSaWwndmft5sveX3LxmRd7XZKcgMJdRI5rfcZ6Oo3txN7svUy/fToX1rvQ65LkJCjcReSY1v68lk5jO3Ew5yAz+sygTd02XpckJ0nhLiJFWrNjDZ3GdiInN4eZfWZyXp3zvC5JToHCXUQKWZW+is5jO+NwzOwzk9a1W3tdkpwizZYRkQJWpK3gijFXYGbM6jNLwR6jFO4ikufbbd/SaWwnyvnKMavPLM5JOsfrkqSYFO4iAsAy/zI6v9WZiokVmX3HbH5xxi+8LknCoHAXERZvXUzntzpTpXwVZt8xm+Y1m3tdkoQp7B2qZuYDFgNbnHPdzawm8D7QBPgJuNk5tzPc7YhI5Pkz/Vzz7jWsy1hHrdNqMbPPTJpUb+J1WRIBkei5DwZW53s+BJjunGsBTA89F5EodM+n97Bs2zIAZt8xW8EeR8IKdzNrAFwDjMy3uAcwNvR4LHB9ONsQkZIxZvkYPvzhQwAO5R7SFZTiTLg992HAw0BuvmV1nHN+gNB97aJeaGYDzGyxmS1OT08PswwROVnOOV6Y/wJ9P+6LEbzWaa7L1Rkd40yxw93MugNpzrklxXm9c26Ec66dc65dUlJSccsQkVOQHcim/+T+PPTFQyRYQt7FNnQ+9vgTTs+9A3Cdmf0EvAd0NrO3ge1mVg8gdJ8WdpUiEraMAxl0fbsro5aN4qJ6F5GYUHA+hc7HHl+KHe7OuaHOuQbOuSZAT2CGc+42YBLQJ7RaH+DjsKsUkbD8+POP/Grkr5ifMp+3rn+LgAuQHcgusI7Oxx5fSuLcMs8C482sH7AZuKkEtiEiJ2nmxpncMP4GfAk+Ztw+gw6NOtD7gt5elyUlLCLh7pybBcwKPf4ZuDIS7ysi4Rm5dCR3TbmLlrVaMvmWyTSr0czrkqSU6AhVkTgUyA3w4OcP0n9yfzo37cz8O+cr2MsYnfJXJM7szd7LrR/cyqQ1k7jn4nsY1m1YoZ2nEv/0Ly4SR1J2p3DtuGv5Pu17XrnqFQZdMsjrksQjCneROPHNlm+47r3r2Je9jym9ptCteTevSxIPacxdJIb5M/10HNORN5a8weVjLqdiYkUW9FugYBf13EVi2dOzn2buprnM2TSH9g3b8+HvP6R25SLP+CFljHruIjFqXcY63lj6Bg6Hz3y88z/vKNglj8JdJAZ9s+UbLhpxEQEXAMCX4OP5r573uCqJJgp3kRgSyA3wt7l/49ejfs2erD15y3XiLzmawl0kRqTsTuHKt67k0RmP0qR6k0LnX9eJvyQ/hbtIDJiwagIXvH4Bi7cuZnSP0VQtX1Un/pLj0mwZkSi2N3svf5z6R0YvH83F9S/m3RvepXnN5tzR5g6vS5Mop3AXiVLfbPmGXh/0Yn3Geh699FGeuuIpyvnKeV2WxAiFu0iUCeQG+PtXf+eJWU9Qr0o9ZvaZSccmHb0uS2KMwl0kiqTsTqH3h72ZvWk2N7e+mdeveZ0alWp4XZZEWN26sH174eV16sC2CE14UriLRIkJqyYwYPKA4LTGHqPpc0EfzMzrsqQEFBXsx1teHAp3EQ/5M/3c9N+baFCtAe+vfL/ATlORcCjcRTx076f38lXKVwA8dtljPNnxSe00lYjQPHcRD+w6uIs7P7qTiT9MBKCCrwKDLhmkYJeIUbiLlKJcl8uby96k5SstGf3taBIs+CfocDq6VCJK4S5SSpZsXUKHNzvQb1I/GldvTAVfBXJdLqBzw5Q1deqc2vLiULiLlLCf9//MwE8GcvEbF7Nx50bGXj+WdvXa4XAF1tO5YcqObdvAucK3SE2DhDDC3cwamtlMM1ttZivNbHBoeU0z+8LM1obuNUlXyqRAboDhi4fT8tWWjFw6ksG/HMyaQWu4/YLbWbhloc4NIyUqnNkyOcADzrmlZlYVWGJmXwB3ANOdc8+a2RBgCPBI+KWKxI6FqQsZ9OkglviX0LFxR169+lXOrX1uXvuy/13mYXVlV2kcPBQtih3uzjk/4A89zjSz1cCZQA/gitBqY4FZKNyljEjbl8aQL4cwevlo6letz7gbxvH71r/XwUhRojQOHooWERlzN7MmQFvga6BOKPgPfwEUed0vMxtgZovNbHF6enokyhApdYcvUJ26J5VXvn6Flq+05O3v3ubh9g+zZtAaep7bU8Eungj7ICYzqwJMBO5zzu052f+RnXMjgBEA7dq1cydYXSQqJc9JZu6mubR5vQ0/H/iZLs268PJVL3P2GWd7XZqUcWGFu5mVIxjs7zjnPggt3m5m9ZxzfjOrB6SFW6RINJq3eR4jlozA4cg4kMHIa0dyZ9s71VOXqBDObBkDRgGrnXP/zNc0CegTetwH+Lj45YlEnxVpK7hl4i1cNvqyvAtUl/OVY6l/qYJdokY4Y+4dgN5AZzNbHrpdDTwLdDGztUCX0HORmLfMv4wbxt/Aef8+j0lrJpGYcOSHrw5Cig2lcfBQtAhntsw84FjdlCuL+74i0ebr1K/5y9y/8MmPn3B6hdP50+V/InVPKu98/06B9Q4fhPTaNa95VGn0ipYpiPE23fF4dFZIkWOYu2kuyXOS+WLDF9SsVJO/dPoLgy4ZxOkVT6ft8LY6COkUlKUpiNFC4S6Sj3OO6RunkzwnmTmb5lC7cm3+/pu/c9fFd1GlfJW89XQQkkQ7hbuUaf5MPz0n9uS9G95j2bZlJM9JZmHqQupXrc+wrsPof1F/Tit3mtdlipwyhbuUaU/Pfpq5m+Zy/uvns2P/Dhqf3ph/X/Nv+rbpS4XECl6XJ1JsCncpkzIOZPCvRf9i+JLhOBw/7/+ZF3/7Ivdcco8umCFxQeEuZUauy2X2T7MZuWwkE1dNJCuQhYUmfJXzlWNtxtq4C/ZomaVSp86x65CSofO5S9zbmrmVv879Ky1faUnntzrz6dpP6XVuLyr4KuSdUz1e56lHyyyV0jh/uRSkcJe4lJObw6Q1k7hu3HU0erERj814jIanN+Tt373N1v/bSsVyFXWxDIlrGpaRmHZ4tsv7N75P3Sp1WZ+xnlHLRjFm+Rj8e/3UrVKXh9o/xJ1t76RFrRZ5r1uQukDz1CWuKdwlpiXPSWbe5nn0/qA3ARdg5k8zSbAErm5xNX9o+weubnF1kePomqcu8U7hLjHpUOAQH67+kBFLRpDrcvly45c0rNaQv3T6C3e0uYMzq53pdYkinlK4S8zYeWAnU9dNZfKPk5m6diq7s3bntSUmJNK9ZXceu/wxDyssKBpmqmiWStllznl/nYx27dq5xYsXe12GRKH1GeuZ/ONkJq2ZxJxNcwi4ALUr1+bKplcycfXEAuPmlRIrsWHwBupWqethxUcc7+y/UfBnJ3HAzJY459oV1abZMuKpw5epOzwFMZAbYEHKAoZ+OZRz/3UuzV9pzv2f3U/avjQe7vAwC/otwP+An+oVqxd6L812ETlCwzLiqcM7RPt+1Jf6VevzydpPSNuXhs98dGzSkf4X9ufaX1xLsxrNCrxOs11Ejk/hLqVu/6H9fLPlG6atm8bwJcPJdblMWz+NquWrck3La7iu5XV0a96NGpVqHPM9jjfbJRrGukW8pnCXErc1cytfbf6K+Snz+SrlK5ZtW0ZObk6BdRITEul1Xi9e7/562NuLlqMyRbykHaoSlqMPIsrJzWFF2opgmKfO56vNX7Fp9yYAKiZW5JIzL6F9g/ack3QO//vJ/3Iw52Dee0Vqh2i07MjUL4gYlp0Nu3dDVlbwlp0dvG/eHKpUga1bYdmyI8sPr/M//wO1asHixfDJJwVfm5UFf/0rJCXBxInw5ptQtSq8916xyzzeDlX13CUsj894nLmb5nLtu9dSvVJ1FqYuZG/2XgDqValHh0YduO9X99G+YXva1G1DeV95AO6ecje5LrfAe8XbZeoU4MfhHOzbVzgcq1eH2rWDz+fPLxyObdtC69aQkQEjRxYO35tvhg4dYP16GDKkYFt2Njz1FHTpAgsWQM+eBduysuCjj+Caa2DqVLj++sJ1z5oFHTvCzJlw222F2y+8MBjuS5bAn/8M5cpB+fJQoULwNnRoMNz37Svxn5IK9zLu6J73sew8sJPVO1azKn1V3u377d+zde9WABb7F+Pb0ZrAhj6Q0h5S2uPf1ZgJGHOL6Klqh2gpyM0tHJ4JCVC/frD9229hz56C4XbGGXDZZcH2MWOCIZr/9a1bw623BtsHDoRduwpuo2tXeOihYHifey4cPFjw/QcOhOeeC4Zb1aqFa/7Tn+Dpp2HnTujcuXD7c88dCfdHHgkuMzsSnm3aBMM9OxtWrSoYrKedBj5f8DU1a8IVVxxpO7xes9CO+/PPh1deKdzeqlWwvWtX+Prrgu9fvnzwiwngD3+A/v2D/72LcvvtwVsJ0rBMGXf3lLsZvmQ4Ay8ayGvXvEb6vvS88M4f5v69/rzXVEqsxDlJ55CZlcmGnRsIuADlfeXJXvAH+LToXndp/m9WqsMyzkEgUDAA69QJFrFlS/BbLX+45eQEe4YAs2fD6tUFX5uYGOxxArz+OixaVDA8a9YMhi7A3XfD3LmFhw3mzg22/+pXwQDKr317+Oqr4OPWrYMBmN9vfwuffRZ83LgxbN58pK1cObjxRnj33eDztm1h//6CAde9e7B3CnDLLcEwzR+OV1wR7BHn5MCLLxYOx/PPh/POC36e+fMLvrZChWCvt3r14BfXgQPBZYllt496vGEZhXuM82f6afxgTw69+z7sLdjzLmpsN5AbIG1fGql7Uvlu+3cMnDKQnNwcEiyB6hWrk3EgI2/dKuWr0CqpVfB2Rqu8x42rN2b73u00e7lZgTFzDlWClzYUqgMiEKr5e6GVKgX/4PfuhZSUQj/N697ame1phXtMdarsY9ujL8Oddwb/48ybFxzvPPqn/7//HRwwf/vtYO/t6J/2y5cHf3o/+SQkJxf+cPv3B2scPBhefrlgm88XDDYI1jF6dMH26tWDvVaAAQOCwwP5w61hQ5g0Kdj+1FPw3XcFw7FRI3j88WD76NHB/wHyt9evf+TLZd684GfKH6DVqwdDHYK948TE4PJy5Y7dCxXPaMy9hERih9nJDoscS/KcZA7VnQeXJ8O0l6DKNqiWAtVS2V4tlQc+SyU1M5XUPcHb1sythWaqQPDC0HVOq83jHYbSqtbZtKp3AQ2q1MdSUo4E254s2OGHMxNIXvFcoTFzLBCso6je+113HXmfvn3hyithzZrgz/Sjhw5eeAGuvTbYA73qqiM93sMmTw72EKdPL3JcdNvMmcEe4rvvHhlCANgLPEqwd1qnDqxdC+PGFe4dHgx9YVWoADVqFP5pfvin/WWXBYP08PKj2/v1C37Oo1/vXLBn/8IL8MwzBdvz90JHjIgYk04AAAeFSURBVDj+P/5TTx2/vW/f47dfeunx22vWPH67RLUS67mbWTfgJcAHjHTOPXusdYvTc88L1ip+uLEnTAj2XE91JkI44WpWePuHHfc/6+E/buDuD/ox/PvRDGzZi9faPBYMtwoVCLRswa6Du9g5exoZGVvYeXAXO7N2sTN7NzurJLKzUW22ZG7h/RXvkYsDBziDhIIbrpTro8HB8sHb/kQa7PPRoMVFnPa7mxn4yUCyAllH1j0EG16Cun+4L/iTed++4MyAoz3+OG0bfMLybcsLt/nbwPDCc9BdUu0jAZacDL16wY8/Bscmj/5pPmhQMHg2bIDXXiscvj16wFlnBYc95s4tHJ7nnRfsge7ZA+npR9rzr3O8sRuRGFHqwzJm5gN+BLoAqcA3wC3OuVVFrV+ccM/727zmbrhoOCwemNdjLPCRsrKK3ivfqhUkJHD3O70Yvu49Btbqxmt17wy2BwJHdnZMmRKc8pSVhcs6SCA7i0A5H4G/PkPlqjnQ9X5oMxq+7wXzhkLiQSh3gM9nHOBAzgEOvvg8B1Z/zwEOcYAcDpLDgXpncODO29mxfwf/WTaGQAIk5MI56bC3Auys7GNPucBxP3/FxIokkMD+Q/vBgNwE8LeFpQNgT4O8W277m7ADBwuGY5cu3N10FaOWjSqwU7O88/EHu4jX2v8lOKMgEIC33iocvs2bB8M1Jwd++CFvuTVpfMx6o2D0TyTueBHuvwaecs51DT0fCuCc+1tR6xc73JvMgD6/AXPBXmtGM3CJ/MJ+xJ3VDHw+3I4dkJGRd80dF/pScM2akuMCpOzaHFzmIGkfYJCTAIHq1QjkBghkHSTgAuQkHHltJFRKrESuy83rORvQKPEMOlY9lxpVkqjRrDU1KtWgxo591PBVpkblWtQ4rRY1qiZRo0Z9dlbkpMa8j/XP23Z42yJ73m3qtin2uc41r1ukdHkx5n4mkJLveSrwy6OKGgAMAGjUqFHxtnLhqGDiHg53gG1taHO2Qe1WWPnykLgDK58BCQmYzwcJPsyXAGc2ZJF/MWaGw5Fgxhl1m3JF3V/iSyyP7/TT8VkiPgeJvkR8vnL4EhLxmQ9fgg+f+Rgy+mM4cxH4AhDwwcYr4Zt74FAl5s6sRKXESlQqV4mKiRXzHldKrER5X3m27d1Gs5ePnC/FAWns47k7x53U8FByEfPEjzvmfZSSuFiFAlwkepRUuBfVxy3Qh3TOjQBGQLDnfspbqOKHcz4IjmdA8L7aVhg9jPf+e+Jw9Gf6afZys+B4NZCL46eDfp7o8c+TCld/pp8h9Z4KBjsE7xvPhY/Gwt66XHqC76vkOclhHcRT1DxxErOh4ZF54jpnt0jZVVLhngo0zPe8AbA1olvomAx2jJ4rJw7HcMM1ec6xt19nSfHC+VQO4jluzzv807OISIwrqXD/BmhhZk2BLUBPoFckN5DYZAE5iYV7rolNTy4cww3XBakLgj3lo7bf5rr5LJty4tfrGp4iUpJKcirk1cAwglMh33TOPXOsdXUQk4jIqfPkICbn3KfApyX1/iIicmw6nlhEJA4p3EVE4pDCXUQkDincRUTiUFSc8tfM0oFNYbzFGcCOCJUTC8ra5wV95rJCn/nUNHbOJRXVEBXhHi4zW3ys6UDxqKx9XtBnLiv0mSNHwzIiInFI4S4iEofiJdxPcMmauFPWPi/oM5cV+swREhdj7iIiUlC89NxFRCQfhbuISByK6XA3s25mtsbM1pnZEK/rKWlm9qaZpZnZCq9rKS1m1tDMZprZajNbaWaDva6ppJlZRTNbZGbfhj7zn72uqTSYmc/MlpnZJ17XUlrM7Ccz+97MlptZRE+NG7Nj7qd6Ee54YGaXA3uBt5xz53pdT2kws3pAPefcUjOrCiwBro/zf2cDKjvn9ppZOWAeMNg5t9Dj0kqUmf0f0A6o5pzr7nU9pcHMfgLaOecifuBWLPfcLwHWOec2OOeygfeAHh7XVKKcc3OADK/rKE3OOb9zbmnocSawmuA1euOWC9obeloudIvNXthJMrMGwDXASK9riRexHO5FXYQ7rv/oyzozawK0Bb72tpKSFxqiWA6kAV845+L9Mw8DHgZyT7RinHHA52a2xMwGRPKNYzncT3gRbokfZlYFmAjc55zb43U9Jc05F3DOtSF4/eFLzCxuh+HMrDuQ5pxb4nUtHujgnLsQuAq4JzT0GhGxHO4lfxFuiQqhceeJwDvOuQ+8rqc0Oed2AbOAbh6XUpI6ANeFxp/fAzqb2dvellQ6nHNbQ/dpwIcEh5sjIpbDPe8i3GZWnuBFuCd5XJNEWGjn4ihgtXPun17XUxrMLMnMqoceVwJ+A/zgbVUlxzk31DnXwDnXhODf8Qzn3G0el1XizKxyaJIAZlYZ+C0QsZlwMRvuzrkcYBDwGcGdbOOdcyu9rapkmdk4YAHwCzNLNbN+XtdUCjoAvQn25paHbld7XVQJqwfMNLPvCHZivnDOlZnpgWVIHWCemX0LLAKmOOemRerNY3YqpIiIHFvM9txFROTYFO4iInFI4S4iEocU7iIicUjhLiIShxTuIiJxSOEuIhKH/h/J9RgLYUd7EAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline  \n",
    "\n",
    "t1=np.linspace(0,5,10)\n",
    "t2=np.linspace(0,5,20)\n",
    "plt.plot(t1, t1, 'r--', t1, t1**2, 'bs', t2, t2**3, 'g^-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un histogramme et un affichage de texte sur le graphique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Rectangle' object has no property 'normed'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-34-bb1e9336f944>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m#  histogramme des donnees\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbins\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnormed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfacecolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'r'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.8\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxlabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Donnees'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Probabilite'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mhist\u001b[0;34m(x, bins, range, density, weights, cumulative, bottom, histtype, align, orientation, rwidth, log, color, label, stacked, data, **kwargs)\u001b[0m\n\u001b[1;32m   2608\u001b[0m         \u001b[0malign\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0malign\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morientation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morientation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrwidth\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrwidth\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlog\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2609\u001b[0m         color=color, label=label, stacked=stacked, **({\"data\": data}\n\u001b[0;32m-> 2610\u001b[0;31m         if data is not None else {}), **kwargs)\n\u001b[0m\u001b[1;32m   2611\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/matplotlib/__init__.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1563\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1564\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1565\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msanitize_sequence\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1566\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1567\u001b[0m         \u001b[0mbound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_sig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbind\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mhist\u001b[0;34m(self, x, bins, range, density, weights, cumulative, bottom, histtype, align, orientation, rwidth, log, color, label, stacked, **kwargs)\u001b[0m\n\u001b[1;32m   6817\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mpatch\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   6818\u001b[0m                 \u001b[0mp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 6819\u001b[0;31m                 \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   6820\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mlbl\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   6821\u001b[0m                     \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_label\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlbl\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mupdate\u001b[0;34m(self, props)\u001b[0m\n\u001b[1;32m   1004\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1005\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_setattr_cm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meventson\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1006\u001b[0;31m             \u001b[0mret\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0m_update_property\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mprops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1007\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1008\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mret\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m   1004\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1005\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_setattr_cm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0meventson\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1006\u001b[0;31m             \u001b[0mret\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0m_update_property\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mprops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1007\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1008\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mret\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.7/site-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36m_update_property\u001b[0;34m(self, k, v)\u001b[0m\n\u001b[1;32m   1000\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mcallable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1001\u001b[0m                     raise AttributeError('{!r} object has no property {!r}'\n\u001b[0;32m-> 1002\u001b[0;31m                                          .format(type(self).__name__, k))\n\u001b[0m\u001b[1;32m   1003\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1004\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Rectangle' object has no property 'normed'"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "mu, sigma = 100, 15\n",
    "#generation de 10000 nombres aleatoires\n",
    "x = mu + sigma * np.random.randn(10000)  \n",
    "\n",
    "bins = 30\n",
    "\n",
    "#  histogramme des donnees\n",
    "plt.hist(x, bins, normed=1, facecolor='r', alpha=0.8)\n",
    "plt.xlabel('Donnees')\n",
    "plt.ylabel('Probabilite')\n",
    "plt.title('Histogramme')\n",
    "plt.text(60, .025, r'$\\mu=100,\\ \\sigma=15$')\n",
    "plt.axis([40, 160, 0, 0.03])\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions : "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D'abord, nous demandons d'écrire un script qui trace un graphique de la pression (en kPa) en fonction du temps (en heures). N'oubliez pas d'indiquer les étiquettes sur les axes.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Sur le même graphique tracer aussi trois lignes (en couleurs differentes) l'une représentant la valeur moyenne ( $\\mu$ ) de la pression et les deux autres la valeurs moyennes plus / moins l'écart type ( $\\sigma$ ):\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\mu = \\frac{1}{N} \\Sigma_{i=1,N} x_i  \\qquad \\sigma=\\sqrt{\\frac{1}{N} \\Sigma_{i=1,N} (x_i - \\mu)^2}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "Deuxièmement, nous demandons également de construire un histogramme, mais  cette fois de la vitesse (en Km/h).\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Partie 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utiliser les fonctions en Python\n",
    "\n",
    "Vous savez déjà ce qu'est une fonction mathématique d'une variable réelle.\n",
    "Considérons par exemple la fonction f(x) suivante :\n",
    "\n",
    "f : x ---> 2 x + 1\n",
    "\n",
    "\n",
    "pour la définir en Python :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#definition d'une fonction\n",
    "def f(x):\n",
    "    return 2 * x + 1\n",
    "\n",
    "#utilisation de la fonction\n",
    "print(f(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avez-vous remarqué qu’à la deuxième ligne, on n’a pas commencé à écrire au début de la ligne? De la même façon que pour les structures de contrôle 'if' ou 'for', nous devons appliquer la règle d'indentation.\n",
    "Cette indentation est indispensable pour que l'interpréteur Python comprenne la fin d'un bloc de définition d'une fonction.\n",
    "\n",
    "Le principe de définition de fonctions est intéressant pour deux raisons :\n",
    "\n",
    "1) cela nous permet de ne pas répéter un calcul long à taper,\n",
    "\n",
    "2) Python possède un type spécial dédié au fonctions, que l’on peut donc manipuler, mettre dans des listes pour les étudier les unes à la suite des autres. \n",
    "\n",
    "Par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( f(1) , f(2) , f(3) , f(4) , f(5) , f(6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( type(f))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definition d'une seconde fonction\n",
    "def hi(name):\n",
    "    print(\"hello \" + name + \" from Python!!!\")\n",
    "\n",
    "#exemple d'utilisation    \n",
    "hi(\"Mark\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#definition  d'une trosieme fonction\n",
    "from random import choice\n",
    "def lettre():\n",
    "    return choice('abcdefghijklmnopqrstuvwxyz')\n",
    "\n",
    "#exemple d'utilisation \n",
    "lettre()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#definition d'une liste de fonctions\n",
    "mes_fonctions = [f,hi,lettre]\n",
    "\n",
    "#utilisation\n",
    "mes_fonctions[1](\"Dominique\")\n",
    "\n",
    "mes_fonctions[2]()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Script 5 : calcul des forces sur un ballon de football"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](kick.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les forces sur un ballon de football en vol suite à un coup de pied d'un joueur sont deux: la force de la pesanteur (le poids $F_P$) et la force de  traînée exercée par le frottement de l'air sur le ballon ($F_T$). Leurs expressions sont les suivantes : \n",
    "\n",
    "$$F_P = M\\ g$$\n",
    "\n",
    "$$F_T = 0.5 \\ C_D \\ \\rho \\ u^2\\ S $$\n",
    "\n",
    "Où $M$ est la masse du ballon, $g$ l'accélération de gravité, $C_D$ le coefficient de traînée, $\\rho$ la masse volumique de l'air, $u$ la vitesse du ballon et enfin $S$ la section du ballon $S=\\pi\\ R^2$ (avec R le rayon).\n",
    "\n",
    "Nous demandons d'écrire un script qui tout d'abord demande à l'utilisateur d'entrer les valeurs du rayon du ballon (en mètres), de la masse du ballon (en kg) et de la vitesse du ballon ainsi que l'unité de mesure pour cette dernière (soit \"m/s\" ou \"km/h\").\n",
    "Ensuite le script devra calculer les forces $F_P$ et $F_T$, afficher les deux valeurs ainsi que leur rapport $F_T/F_P$.\n",
    "\n",
    "On demande de faire tout cela  à l'aide de quatre fonctions :\n",
    "\n",
    "1) une fonction qui convertit  la vitesse de \"km/h\" en \"m/s\" si besoin\n",
    "\n",
    "2) une fonction qui calcule la surface $S$ du ballon  à partir du rayon $R$\n",
    "\n",
    "3) une fonction qui calcule $F_T$\n",
    "\n",
    "4) une fonction qui calcule $F_P$\n",
    "\n",
    "Les données du problème sont l'accélération de gravité $g=9.81 \\, m /s^2$, la masse volumique de l'air $\\rho = 1.2 \\, kg/m^{-3}$,  le coefficient de trainée $C_D=0.2$. \n",
    "Tourner le script plusieurs fois et dire ce qui change dans le rapport $F_T/F_P$ pour des valeurs de vitesse croissantes (p.ex. $u=10 \\, km/h$, $u=120 \\, km/h$) et à masse et rayon fixes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Script 6 : étude de la fonction de transfert du système ressort - amortisseur (suspension) d’un  automobile\n",
    "\n",
    "L’objet de ce script est d'illustrer à l'aide de Python les rôles respectifs joués par le ressort et l’amortisseur d’un système automobile. \n",
    "Pour ce faire, nous étudions un ressort couplé à un amortisseur en parallèle. \n",
    "\n",
    "Comme dans la figure ci-dessous:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](masse-ressort-amortisseur.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'équation vérifiée par le système est la suivante :\n",
    "\n",
    "$$ \\ddot{x} + \\frac{\\omega_0}{Q} \\dot{x} + \\omega_0^2\\ x = \\frac{F}{m} \\cos( \\omega t) $$\n",
    "\n",
    "Ici $m$ est la masse de la roue, $F$ et $\\omega$ sont respectivement l'intensité de la force appliquée (qui modélise l'effet des ondulations du sol sur la roue) et sa pulsation , $\\omega_0$ la pulsation caractéristique du ressort ($\\omega_0=\\sqrt{k/m}$) et enfin $Q$ est un coefficient appelé coefficient de qualité. Ici on négligera le poids de la roue. \n",
    "\n",
    "Un système très amorti a un $Q$ faible. À l'inverse, un $Q$ élevé correspond à un système peu amorti. Pour fixer les idées, le $Q$ d'une voiture avec des amortisseurs en bon état est légèrement supérieur à 1.\n",
    "\n",
    "De la solution de l'équation du système ressort-amortisseur on trouve la fonction de transfert qui décrit la réponse du système en fonction de la pulsation $\\omega$. \n",
    "\n",
    "En particulier la fonction de transfert (le module de cette fonction pour la précision) s'écrit :\n",
    "\n",
    "$$ T(\\omega) = \\frac{F}{m \\ \\omega_0^2} \\frac{1}{\\sqrt{ \\left( 1 - \\omega^2/\\omega_0^2 \\right)^2 +  Q^{-2} \\ \\omega^2/\\omega_0^2 }} $$\n",
    "\n",
    "ou en utilisant la pulsation adimensionnée u = ω/ω0 :\n",
    "\n",
    "$$ T(u) = \\frac{F}{m \\ \\omega_0^2} \\frac{1}{\\sqrt{ \\left( 1 - u^2 \\right)^2 +  u^{2}/ \\      Q^2}} $$\n",
    "\n",
    "Nous demandons d'écrire un script qui trace un graphique du module de la fonction de transfert $T(u)$ en fonction de la pulsation adimensionnée $u$ (dans l'intervalle $[0,2]$) pour toutes les valeurs de $Q$ dans l'intervalle $[0,10]$ avec rapport entre une valeur de $Q$ et la valeur précédente de $\\delta Q = 2.0$ (facteur de redoublement).\n",
    "\n",
    "Prendre la valeur suivante pour l'amplitude de la fonction de transfert  $$ \\frac{F}{m \\omega_0^2} = 2 $$ \n",
    "\n",
    "##### Ça pourrait être utile : \n",
    "\n",
    "#### La boucle while \n",
    "\n",
    "Le but de la boucle \"while\" est de répéter certaines instructions tant qu’une condition est respectée. On n’est pas donc obligé de savoir au départ le nombre de répétitions à faire.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_repetitions = 3\n",
    "i = 1\n",
    "\n",
    "while i <= nb_repetitions :\n",
    "    print(\"Et \"+str(i)+\"!\")\n",
    "    i = i+1\n",
    "print(\"Zéro!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L’instruction \"break\" sert, non pas à interrompre le programme, mais à sortir de la boucle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_repetitions = 3\n",
    "i = 1\n",
    "\n",
    "while i <= nb_repetitions :\n",
    "    print(\"Et \"+str(i)+\"!\")\n",
    "    i = i+1\n",
    "    if i==3: \n",
    "        break\n",
    "print(\"Zéro!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Création d'une légende sur un graphique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Création d'une array numpy : Temps = Abscisses \n",
    "t = np.linspace(0,10,400)    \n",
    "\n",
    "# Fonction U dépendant d'un paramètre Q\n",
    "def U(t,Q):\n",
    "    return np.exp(-2/Q*t)*np.cos(2*pi*t)  \n",
    "\n",
    "# Plot1 avec Q = 2 et édition du label correspondant\n",
    "Q=2.0\n",
    "plt.plot(t,U(t,Q),label=\"Q=\" + str(Q)) \n",
    "\n",
    "# Plot2 avec Q = 10 et édition du label correspondant\n",
    "Q=10.0\n",
    "plt.plot(t,U(t,Q),label=\"Q=\" + str(Q)) \n",
    "\n",
    "# Appel de la légende\n",
    "plt.legend(loc='upper right')    \n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Script 7 : Préparation des données d'entrée pour une machine-outil à contrôle numérique\n",
    "\n",
    "Les machines-outil d'usinage à contrôle numérique peuvent être contrôlées à travers un fichier de données d'entrée. Ce fichier contient toutes les spécifications géométriques de l'objet à usiner et il a souvent la forme d'une matrice en deux dimensions, dans laquelle chaque élément identifie une coordonnée spatiale (x, y) alors que la valeur de l'élément contient l'information sur l'usinage (par exemple dans une fraiseuse \"$0$\" signifie couper et \"$1$\" signifie  garder tel qu'il est). \n",
    "\n",
    "Nous considérons ici une machine-outil fraiseuse avec résolution du dixième de millimètre, et une surface de travail de $(10 \\times 10) cm^2$. Nous voulons découper de la pièce brute une bielle à partir d'un bloc de métal de dimensions $(10 \\times 10) cm^2$ (l'épaisseur du bloc n'a pas d' importance ici).\n",
    "\n",
    "La géométrie de la bielle est montrée dans la figure ci-dessous :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](bielle.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Détails de la géométrie de la bielle:\n",
    "\n",
    "- le grand anneau a rayon interne $r_1 = 10.0\\ mm$, rayon externe $r_2 = 16.0\\ mm$ , position du centre $x_1 = 50.0 \\ mm$ , $y_1 = 20.0 \\ mm$.\n",
    "\n",
    "- le petit anneau a rayon interne $r_3 = 3.0\\ mm$ , rayon externe $r_4 = 11.2\\ mm$ , position du centre $x_2 = 50.0 \\ mm$ , $y_2 = 75.0 \\ mm$.\n",
    "\n",
    "- la barre de liaison a longueur $l=30.0\\ mm$ , hauteur $h = 10.0\\ mm$ et centre géométrique en $x_3 = 50.0 \\ mm$, $y_3 = 50.0 \\ mm$. \n",
    "\n",
    "On demande d'écrire un script qui crée la matrice pour usiner la bielle en figure.\n",
    "\n",
    "Cette matrice devra avoir $1000$ x $1000$ éléments, chaque élément correspondant à $(0.1 \\times 0.1) mm^2$, et la valeur des éléments doit être soit $0$ si le matériau doit être enlevé (ou bien complètement fraisé dans ce cas) soit $1$ s'il doit être gardé comme il est.\n",
    "\n",
    "a) Montrer à travers un graphique la matrice que vous avez obtenu\n",
    "\n",
    "b) Tracer aussi un graphique de la section longitudinale centrale de la bielle.\n",
    "\n",
    "##### Cela pourrait vous être utile :\n",
    "\n",
    "#### Créer et manipuler un tableau multidimensionnel avec numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "#définition d'une matrice avec numpy\n",
    "tableau = np.array ([[0 ,1 ,2] ,[1,2,3], [4,6,12], [44 ,55 ,56]]) \n",
    "\n",
    "print(tableau)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# copier un element du tableau, tableau[num. ligne][num. colonne]\n",
    "n=tableau[3,0] \n",
    "\n",
    "print(n) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Noter que l'indice de gauche indique toujours le nombre de la ligne tandis que l'indice de droite indique le numéro de la colonne. \n",
    "\n",
    "Ce système d'indexage (dite convention \"row-major order\" ou \"ligne par ligne\") n'est pas toujours intuitif :\n",
    "dans le cas d'une matrice $A[i, j]$ qui contient des informations spatiales l'indice à gauche ( $i$ ) identifie la coordonnée verticale $y$ et l'indice de droite ( $j$ ) identifie la coordonnée horizontale $x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=tableau[:,0] # copier une colonne du tableau\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d=tableau[:2,:2] # copier une colonne du tableau\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tableau = tableau + 2  #ajouter 2 aux éléments du tableau\n",
    "print(tableau)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tableau2 = np.zeros((4,3))  #définition d'une matrice composée de zéros\n",
    "\n",
    "print(tableau2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Représenter graphiquement une matrice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#création d'une matrice aléatoire de 80x50 elements\n",
    "my_mat = np.random.random((50, 80)) \n",
    "\n",
    "# représentation graphique\n",
    "plt.matshow(my_mat) \n",
    "\n",
    "# définition des marqueurs en x\n",
    "plt.xticks(range(0,80,10)) \n",
    "# définition des marqueurs en y\n",
    "plt.yticks(range(0,50,10)) \n",
    "\n",
    "plt.colorbar()\n",
    "\n",
    "plt.show()        \n",
    "\n",
    "# représentation graphique en blanc et noir\n",
    "plt.matshow(my_mat,cmap='Greys') \n",
    "plt.colorbar()\n",
    "plt.show()        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lire un fichier Excel avec Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un fichier Exel (.xlsx) est disponible ici : https://www.dropbox.com/s/nu24hm7kbj08pfr/stock.xlsx?dl=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.read_excel (r'stock.xlsx')\n",
    "print (df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=df.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data[0][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data[0,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data[0,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Créer un fichier Excel avec Python\n",
    "Write https://pythonbasics.org/write-excel/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import openpyxl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "df = pd.DataFrame([[11, 21, 31], [12, 22, 32], [31, 32, 33]],\n",
    "                  index=['one', 'two', 'three'], columns=['a', 'b', 'c'])\n",
    "\n",
    "print(df)\n",
    "#         a   b   c\n",
    "# one    11  21  31\n",
    "# two    12  22  32\n",
    "# three  31  32  33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_excel('pandas_to_excel.xlsx', sheet_name='new_sheet_name')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}