{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutoriel d'introduction à Python\n",
    "\n",
    "**[Commande de base]** Dans l'environnement notebook, il faut taper SHIFT + RETURN pour exécuter le contenu d'une *boite*\n",
    "\n",
    "**[Autres commandes]** Les menus ci-dessus (associés à des raccourcis claviers) permettent de créer de nouvelles boites, d'en supprimer et de les inverser.\n",
    "\n",
    "Vérifiez toujours que vous êtes en python **3** (en haut à gauche) dans le cadre des TME"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types de base python et commande d'affichage\n",
    "Les variables ont un type (entier, réel, etc...), mais ce type est inféré par python et non déclaré"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 1 # python sait qu'il s'agit d'un entier, la valeur est stockée dans a\n",
    "print(a) # affichage\n",
    "a = 45 # la valeur précédente est perdue, a vaut maintenant 45\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = 18.5 # création d'un réel\n",
    "b = b + a # récupération, manipulation, etc...\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# chaine de caractères: on peut utiliser les \" ou les '\n",
    "s  = \"Bonjour et bienvenu à la formation continue\"\n",
    "s2 = 'une autre chaine'\n",
    "print(s)\n",
    "# une chaine de caractères est un tableau...\n",
    "# récupération du 3ème caractère (Attention, les indices commencent à 0)\n",
    "print(\"Le 3ème caractère est : \", s[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Principal risque avec les notebooks:\n",
    "\n",
    "La pile python dépend de l'ordre d'execution des boites... Garre aux mauvaises surprises.\n",
    "\n",
    "L'exemple ci-dessous illustre ce risque:\n",
    "1. exécution de A puis B puis C: affichage = 2\n",
    "1. exécution de B puis A puis C OU A puis B puis de nouveau A puis C: affichage = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# boite A\n",
    "v=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# boite B\n",
    "v=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# boite C\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les fonctions mathématiques avancées\n",
    "\n",
    "Pour plus d'informations:\n",
    "* https://docs.python.org/3/library/math.html\n",
    "* https://docs.python.org/3/library/random.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "0.5000000000000001\n",
      "0.7239620887242425\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "# récupération de valeurs et opérateurs spécifiques\n",
    "# ... Pour lesquels il faut charger des bibliothèques spécifiques\n",
    "import math \n",
    "\n",
    "print(math.pi)\n",
    "theta = math.pi/3 # une variable comme une autre, nous sommes libre du choix des variables\n",
    "print(math.cos(theta))\n",
    "\n",
    "# générer des nombres aléatoires\n",
    "import random\n",
    "r = random.random() # entre 0 et 1\n",
    "print(r)\n",
    "r2 = random.randint(2, 33)\n",
    "print(r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les listes et les dictionnaires\n",
    "\n",
    "Les listes et dictionnaires jouent un role très important en python, nous allons étudier cela maintenant\n",
    "\n",
    "Toutes les informations sur: https://docs.python.org/3/tutorial/datastructures.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# création d'une liste:\n",
    "maliste = [] # equivalent de maliste = list()\n",
    "print(maliste)\n",
    "# ajout d'un élément\n",
    "maliste.append(12)\n",
    "# fusion de deux listes\n",
    "listefus = maliste + [4, 6, 8]\n",
    "print(listefus)\n",
    "# récupération de la longueur d'une liste:\n",
    "print(len(listefus))\n",
    "# modification d'une valeur dans la liste:\n",
    "listefus[0] = -1\n",
    "print(listefus)\n",
    "# suppression d'une valeur dans la liste (par indice)\n",
    "listefus.pop(1)\n",
    "print(listefus)\n",
    "# suppression d'une valeur dans la liste (par valeur)\n",
    "listefus.remove(8)\n",
    "print(listefus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Opérateur sur les listes\n",
    "print(sum(listefus))\n",
    "# trouver tous les éléments uniques d'une liste => créer un set (= ensemble de valeur unique)\n",
    "print(set([2,15,3,9,2,15,15,15]))\n",
    "# ordonner\n",
    "li = [2,15,3,9,2,15,15,15]\n",
    "li.sort()\n",
    "print(li)\n",
    "# compter un élément d'une liste:\n",
    "print([2,15,3,9,2,15,15,15].count(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ATTENTION, les listes sont des objets != type de base:\n",
    "a = 2\n",
    "b = a\n",
    "a = 18 # aucun impact sur b\n",
    "print(a,b)\n",
    "\n",
    "li_a = [2, 4, 6, 8]\n",
    "li_b = li_a # il n'y a qu'une liste... partagée entre deux variables\n",
    "li_b.append(12) # modification de l'objet partagé\n",
    "print(li_a)\n",
    "\n",
    "# Pour eviter cela\n",
    "li_c = li_a.copy()\n",
    "li_c.append(42)\n",
    "print(li_a) # li_a inchangée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# dictionnaire = table de hash\n",
    "# construction\n",
    "mondico = {'champ1': 23, 'champ2': [12, 9.5]}\n",
    "# Récupération d'une valeur\n",
    "print(mondico['champ1'])\n",
    "# ajout d'un champ\n",
    "mondico['champ3'] = 65\n",
    "print(mondico)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boucles et tests\n",
    "\n",
    "Pour écrire des algorithmes, nous devons faire des boucles sur des structures de données et tester des grandeurs...\n",
    "\n",
    "Pas d'accolades en python: les blocs de code sont délimités par des tabulations (ou 4 espaces)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Comment marche un if\n",
    "i=0\n",
    "if i<30:\n",
    "    i = i + 10;\n",
    "    print(\"i est inferieur a trente\")\n",
    "else:                                 # le else est optionnel \n",
    "    print(\"i est superieur a trente\")\n",
    "\n",
    "i=0\n",
    "if i==1:\n",
    "    print(\"cas 1\")\n",
    "elif i==2:\n",
    "    print(\"cas 2\")\n",
    "\n",
    "#Egalité référentielle\n",
    "l1 = l2 = [1,2]\n",
    "# ou bien\n",
    "l1 = [1,2]\n",
    "l2 = l1\n",
    "\n",
    "print(l1 is l2) # True\n",
    "\n",
    "# ou bien\n",
    "l1 = [1,2]\n",
    "l2 = [1,2]\n",
    "\n",
    "print(l1 is l2) # False\n",
    "\n",
    "# appartenance à une liste\n",
    "a = 12\n",
    "li = [8,10,12,14]\n",
    "if a in li:\n",
    "    print(\"trouvé !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Construction d'un boucle for:\n",
    "for i in range(10): # sol 1: range => i va prendre les valeurs entre 0 et 9\n",
    "    print(i) # ATTENTION: l'indentation donne la portée de la boucle\n",
    "print('===') # je suis sorti de la boucle (parce que mon code est revenu à gauche)\n",
    "# vous pouvez tester le décalage de cette dernière commande pour voir la différence\n",
    "\n",
    "li = [12, 43, 90, 1, 6] \n",
    "for i in li:        # sol 2: parcours des valeurs d'une liste\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# les autres boucles\n",
    "i = 0\n",
    "while i<10: # tant que i inférieur à 10\n",
    "    i = i+1\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opérateurs logiques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "True and False\n",
    "# False\n",
    "not False\n",
    "# True\n",
    "True or False\n",
    "# True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les boucles de compréhension\n",
    "\n",
    "On peut s'amuser à créer des boucles directement dans les listes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# création de listes en utilisant des boucles imbriquées:\n",
    "a = [n for n in range(10)]\n",
    "m = [[n+m*10 for n in range(5)] for m in range(5)]\n",
    "print(a)\n",
    "print(m)\n",
    "\n",
    "# les creations complexes... Par exemple: tous les entiers jusqu'à 20 sauf ceux qui divisent 2 ou 3\n",
    "a = [n for n in range(20) if n%2 != 0 and n%3 !=0]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Définition de nouvelle fonction\n",
    "\n",
    "Pour pouvoir refaire plusieurs fois des opérations complexes, il faut factoriser le code dans une fonction puis faire appel à cette fonction plusieurs fois.\n",
    "\n",
    "Par exemple, le calcul d'un angle entre 2 vecteurs en 2 dimensions:\n",
    "$$ \\widehat{\\vec{u},\\vec{v}} = \\mbox{acos}\\left (\\frac{\\vec{u}\\cdot \\vec{v}}{\\|\\vec{u}\\|\\|\\vec{v}\\|}\\right), \\qquad \\vec{u}\\cdot \\vec{v} = u_{x}v_{x} + u_{y}v_{y}, \\qquad \\|\\vec{u}\\| = \\sqrt{u_{x}u_{x} + u_{y}u_{y}}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5707963267948966\n",
      "Help on function calcul_angle in module __main__:\n",
      "\n",
      "calcul_angle(u, v)\n",
      "    Manuel de la fonction\n",
      "    Calcul de l'angle entre le vecteur u et le vecteur v\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# travail amont : bien identifier les entrées et les sorties\n",
    "# je veux travailler sur deux vecteurs (qui seront ici des listes de 2 valeurs)\n",
    "def calcul_angle(u, v):\n",
    "    \"\"\"                  \n",
    "    Manuel de la fonction\n",
    "    Calcul de l'angle entre le vecteur u et le vecteur v. u et v dans R^2\n",
    "    \"\"\"\n",
    "    return math.acos( (u[0]*v[0]+u[1]*v[1]) / (math.sqrt(u[0]*u[0]+u[1]*u[1]) * math.sqrt(v[0]*v[0]+v[1]*v[1])))\n",
    "\n",
    "# test\n",
    "print(calcul_angle([0,1], [2, 0]))\n",
    "\n",
    "help(calcul_angle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Usage de fonctions définies dans un fichier .py\n",
    "\n",
    "Il est possible de mixer du python classique avec un usage notebook. Celà devient même essentiel quand les programmes se complexifient.\n",
    "\n",
    "1. Avec n'importe quel éditeur, créer le fichier `mesfonctions.py` contenant le code suivant:\n",
    "```python\n",
    "# fichier mesfonctions.py\n",
    "import numpy as np\n",
    "def gererate_ones(n):\n",
    "    return np.ones(n)\n",
    "```\n",
    "1. Sauver le fichier `mesfonctions.py dans le même répertoire que le notebook\n",
    "1. Exécuter le code de la boite ci-dessous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "from mesfonctions import *\n",
    "\n",
    "a = gererate_ones(12)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices d'applications\n",
    "\n",
    "* Créer et afficher une liste contenant les entiers de 1 à 20\n",
    "* Créer et afficher les 10 premiers termes de la série de Fibonacci\n",
    "    * u[0] = 1, u[1] = 1, u[n] = u[n-2] + u[n-1]\n",
    "* Créer une fonction qui affiche aléatoirement\n",
    "    * \"Boujour\" une fois sur 3 \n",
    "    * \"Au revoir\" deux fois sur 3\n",
    "    * Tester 10 fois cette fonction\n",
    "*  Créer une fonction qui estime la valeur de la racine carrée de x en utilisant la suite de Newton:\n",
    "    * u_0 = x/2, u_t = (u_t−1 + x / u_t−1)/2\n",
    "    * cette fonction prendra en argument le nombre d'itérations à effectuer\n",
    "    * tester cette fonction sur plusieurs valeurs et vérifier vos résultats avec math.sqrt(x)\n",
    "* Soit une liste de notes d'étudiants (50 notes entre 0 et 20):\n",
    "    * Génération : [random.randint(0,21) for i in range(50)]\n",
    "    * Créer une nouvelle liste comptant combien de note de chaque niveau apparaissent dans la liste (table de contingence)\n",
    "    * Créer une nouvelle liste correspondant à la probabilité d'observation de chaque note\n",
    "        * il s'agit simplement de diviser la table de contingence par le nombre de notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}