{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Qu'est ce qu'une variable ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stockage de l’information"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* temporaire: perte d’information après fermeture du programme\n",
    "* à long terme: données destinées à être réutilisées plus tard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Une variable désigne une adresse mémoire de l'ordinateur"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* On affecte une étiquette (nom de variable) à cette adresse mémoire\n",
    "* La variable possède un type: entier, réel, caractères, chaîne, booléen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Syntaxe générale  et affectation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* nom_de_variable = expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention l'expression à droite du signe égal est évaluée, ensuite et seulement ensuite, python (l'interpréteur plus exactement) affecte au nom de variable la valeur obtenue (on parlera plutôt d'objet). Lors de la première affectation on utilisera le terme **initialisation** de la variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2 # la ligne complète est appelée instruction\n",
    "b = 3\n",
    "c = a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'ensemble des variables définies à un instant donné de l'exécution d'un programme est appélé **état**. Lors de l'évaluation de l'expression les noms de variables sont remplacés par leurs valeurs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le signe égal *=* n'a pas la même signification qu'en mathématiques. Par exemple lors d'une affectation l'instruction n'est pas symétrique. Vouloir échanger l'ordre des éléments provoquera une erreur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2 #correct\n",
    "2 = a #incorrect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une autre bizarrerie du symbole = Que vaut x dans l'exemple ci-dessous ? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 0\n",
    "x = x + 1 #Mathématiquement cette équation n'a pas de sens\n",
    "x = x + 1 #par contre cette instruction est très utilisée en programmation\n",
    "x = x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi écrire (**opération-affectation**)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a += 2\n",
    "a *= 3\n",
    "b /= 2\n",
    "b -= 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour afficher des résultats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Affectation parallèle** : toutes les expressions sont évaluées avant la première affectation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x, y = 2, 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que se passe-t-il dans l'affectation suivante ? Pourquoi ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "xx, yy = 2, xx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enigme : comment échanger le contenu de deux variables ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2\n",
    "b = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comment nommer une variable ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Pas d'espace \n",
    "* Pas de mots clé du langage\n",
    "* Ne pas commencer par un chiffre\n",
    "* Pas d'accent\n",
    "* Donner un nom explicite\n",
    "* Attention les noms de variables sont sensibles à la casse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typage dynamique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans la majorité des langages on déclare le nom et le type de la variable. C'est le **typage statique**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# en langage Java ou C on écrit\n",
    "int a = 2015;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python le typage se fait à l'exécution. C'est le **typage dynamique**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un **nom de variable** est en fait une **référence** vers un **objet python**. Chaque objet possède un type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# en langage Python on écrit\n",
    "a = 2015"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'int'>\n"
     ]
    }
   ],
   "source": [
    "print type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'str'>\n"
     ]
    }
   ],
   "source": [
    "a = \"2015\"\n",
    "print type(a)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Les types les plus utilisés**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Float : nombre à virgule flottante\n",
    "* Integer : entier\n",
    "* Long : un entier très grand\n",
    "* String : chaîne de caractères\n",
    "* Boolean : 2 valeurs possibles uniquement --> True ou False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un objet possède des fonctionnalités qui dépendent de son type, la fonction native $dir$ permet d'avoir la liste de ces fonctionnalités."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2\n",
    "print(dir(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"coucou\"\n",
    "print(dir(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**On peut obtenir des informations sur une des fonctionnalités avec la primitive : *help***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(a.count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour appeler les fonctions liées à un objet on utilise le nom de l'objet suivi d'un point et du nom de la fonction:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\text{nomObjet}.\\text{fonction()}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Par exemple l'étiquette $a$ (ci-dessus) référence un objet de type chaîne de caractères. Il est alors possible d'utiliser la fonction $count$ pour obtenir le nombre d'occurence d'une *sous chaîne* contenu dans la chaîne \"coucou\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(a.count(\"co\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = u\"L'informatique c'est fantastique\"\n",
    "print a.count(\"i\")\n",
    "print a.count(\"i\",0,11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remarque : ** Pour une même valeur le type d'une variable peut dépendre de la méthode de calcul lors de l'évaluation de l'expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Peut-on changer le type d'un objet ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2.3\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = int(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exemple : évaluer la valeur et le type des variables suivantes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 3\n",
    "n1 = a/2\n",
    "n2 = float(a/2)\n",
    "n3 = float(a)/2\n",
    "n4 = a/float(2)\n",
    "n5 = a/2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Un module pour générer des nombres aléatoires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random as rd\n",
    "print rd.randint(0, 6) #[0,6]\n",
    "print rd.random() #[0,1[\n",
    "print rd.uniform(0, 6) #[0,6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les objets suivants sont-ils les mêmes ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un nom de variable est une référence vers un objet python qui possède un identifiant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print \"id(a) = \",id(a)\n",
    "print \"id(b) = \",id(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2**24\n",
    "b = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print id(a), id(b)\n",
    "print a is b\n",
    "print a==b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2**24\n",
    "b = 2**24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print id(a), id(b)\n",
    "print a is b\n",
    "print a==b"
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}