{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Découverte de Python\n",
    "\n",
    "Dans ce cours autour de la programmation Python et de l'algorithmie, nous verons beaucoup de petits morceaux de programmes. \n",
    "\n",
    "Il est vivement recommander de ne pas faire **que** les questions poser mais aussi d'**expérimenter** par soi même."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Base de Ipython\n",
    "\n",
    "Dans les encadrés, on peut lancer des commandes Python et écrire des petits programmes.\n",
    "\n",
    "La combinaison de touche **shift+entré** permet de faire executer par l'ordinateur la ou les commandes tapées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boujour\n"
     ]
    }
   ],
   "source": [
    "print 'Boujour'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Modifier la commande précédente pour qu'elle n'affiche plus bonjour mais votre nom puis executer cette commande."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La touche **entré** permet de passer à la ligne pour écrire d'autres commandes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bonjour\n",
      "monde\n"
     ]
    }
   ],
   "source": [
    "print(\"bonjour\")\n",
    "print('monde')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Modifier le programme précédent pour qu'il affiche:\n",
    "\n",
    "    Bonjour\n",
    "    \n",
    "    tous\n",
    "    \n",
    "    le \n",
    "    \n",
    "    monde"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les commandes commençant par un dièze, ne seront pas executées. On appelle cela des commentaires. Nous les utiliserons pour expliquer ce que l'on fait."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bonjour\n"
     ]
    }
   ],
   "source": [
    "# la commande suivante affiche Bonjour\n",
    "print('bonjour')\n",
    "# Quand on veut afficher quelque chose, on utilisera la commande print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les variables\n",
    "\n",
    "Les variables sont des *tirroirs* où l'on stockera des nombres, des mots, des phrases ou des choses plus compliqués. C'est ce que l'on appelle **assigner** une **valeur** à une variable ou **stocker** une valeur dans une variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "un_nombre = 10\n",
    "print(un_nombre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Modifier le programme précédent pour stocker 2 dans **un_nombre** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour stocker des mots ou des phrases, il faut les mettre entre guillemets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "un_mot = \"Coucou\"\n",
    "une_phrase = \"ceci est une phrase\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Modifier le programme précédent pour changer le contenu des variables puis ajouter deux lignes pour afficher ce que contiennent ces variables (avec la commande **print**)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opérations\n",
    "\n",
    "Un ordinateur ne sais **que** calculer. On peut donc lui faire faire toutes les opérations classiques "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "print(2 + 3)\n",
    "print(4*5 + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ces simples calculs ne sont pas très interessants. La programmation devient réellement efficace quand on travail non plus avec des nombres que l'on définit par avance mais avec des nombres stockés dans des variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# On définit 3 variables\n",
    "a = 2\n",
    "b = 10\n",
    "c = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "120\n",
      "50.666666666666664\n"
     ]
    }
   ],
   "source": [
    "# On peut afficher des calculs avec elles\n",
    "print(a * b)\n",
    "print(a * b + c)\n",
    "print(a / 3 + c * 0.5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# On peut aussi stocker le résultat d'un calcul dans une variables\n",
    "d = a + b\n",
    "print(d)\n",
    "print(a)\n",
    "a = a + 1 \n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Modifier les valeurs initiales de *a*, *b* et *c* puis executer les 3 blocks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice avec les suites\n",
    "\n",
    "Nous allons commencer à voir comment utiliser un programme pour calculer les permiers termes d'une suite.\n",
    "\n",
    "Soit $u_n$ la suite définie par\n",
    "$$u_0 = 100$$\n",
    "et \n",
    "$$ u_{n+1} = 0.4u_n + 10$$\n",
    "On veut calculer $u_3$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.0\n"
     ]
    }
   ],
   "source": [
    "# Premiere valeur de la suite (initialisation): u0\n",
    "u = 100\n",
    "# On lui applique la relation de récurrence pour avoir la deuxième valeur u1\n",
    "u = 0.4*u+10\n",
    "# On recommence jusqu'à atteindre u3\n",
    "u = 0.4*u+10\n",
    "u = 0.4*u+10\n",
    "# On affiche la valeur obtenue\n",
    "print(u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Modifier le programme précédent pour calculer $u_5$\n",
    "\n",
    "* Dans le cadre suivant reprendre le programme précédent pour calculer $v_5$ pour la suite $v_n$ définie par\n",
    "$$v_0 = 10$$\n",
    "et \n",
    "$$ u_{n+1} = 5u_n -3$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boucles\n",
    "\n",
    "Le problème c'est que si l'on veut calculer $u_{100}$, il faudra recopier un grand nombre de fois la formule de récurence ce qui n'est pas très astucieux...\n",
    "\n",
    "Pour éviter d'avoir à recopier plusieurs fois la même chose. Quand il a des répétitions à faire, nous utilisons des **boucles**.\n",
    "\n",
    "Pour faire des boucles on utilise l'instruction *for*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bonjour\n",
      "bonjour\n",
      "bonjour\n",
      "bonjour\n",
      "bonjour\n",
      "bonjour\n",
      "bonjour\n",
      "bonjour\n",
      "bonjour\n",
      "bonjour\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(\"bonjour\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction **range** va enumérer les nombres de 0 jusqu'à la valeur entre parenthèses.\n",
    "\n",
    "* Transformer le programme pour qu'il repète 20 fois le mot bonjour\n",
    "* Remplacer \"bonjour\" par i pour voir les valeurs prises par i\n",
    "\n",
    "On remarquera qu'à la fin de la ligne **for**, il y a deux points puis que ce qui doit être répété est indenté (avec la touche **tab**).\n",
    "\n",
    "Dans l'exemple suivant nous allons faire plusieurs choses dans la boucle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "bonjour\n",
      "1\n",
      "bonjour\n",
      "2\n",
      "bonjour\n",
      "3\n",
      "bonjour\n",
      "4\n",
      "bonjour\n",
      "5\n",
      "bonjour\n",
      "6\n",
      "bonjour\n",
      "7\n",
      "bonjour\n",
      "8\n",
      "bonjour\n",
      "9\n",
      "bonjour\n",
      "fin de la boucle\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "un_mot = \"bonjour\"\n",
    "un_nombre = 2\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "    print(un_mot)\n",
    "    un_nombre = un_nombre + 1\n",
    "print(\"fin de la boucle\")\n",
    "print(un_nombre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* recopier le programme précédent puis l'adapter pour calculer $u_{100}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* écrire un programme qui calcule le n-ième terme de la suite $(w_n)$ définie par\n",
    "$$w_0 = 3$$\n",
    "et\n",
    "$$w_{n+1} = -2u_n + 2$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ecrire un programme qui calcule le n-ième terme de la suite (t_n) définie par\n",
    "$$w_0 = 1$$\n",
    "et\n",
    "$$ w_{n+1} = w_n^{n} + 1$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}