variable-ref_partagee.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nécessite l'installation de metakernel \n",
    "# !conda install -c conda-forge metakernel\n",
    "from metakernel import register_ipython_magics\n",
    "register_ipython_magics()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affectation de variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Affectation de variable : nombre entier \"quelconque\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True False\n",
      "139947832083376 139947832083376 139947832082832\n"
     ]
    }
   ],
   "source": [
    "a = 1255\n",
    "b = a\n",
    "c = 1255\n",
    "print(a == b == c, a is b, a is c)\n",
    "print(id(a), id(b), id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Affectation de variable : cas particulier, nombre entier petit !\n",
    "Python enregistre \"les petits entiers\" de manière unique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True True\n",
      "94746010445504 94746010445504 94746010445504\n"
     ]
    }
   ],
   "source": [
    "a = 150\n",
    "b = a\n",
    "c = 150\n",
    "print(a == b == c, a is b, a is c)\n",
    "print(id(a), id(b), id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Affectation de variable : chaîne de caractères \"quelconque\"\n",
    "Cela se passe comme pour les entiers assez grands."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True False\n",
      "139947832506656 139947832506656 139947832506344\n"
     ]
    }
   ],
   "source": [
    "a = 'je suis une longue chaîne'\n",
    "b = a\n",
    "c = 'je suis une longue chaîne'\n",
    "print(a == b == c, a is b, a is c)\n",
    "print(id(a), id(b), id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Affectation de variable : cas particulier, chaîne courte !\n",
    "Python enregistre aussi les courtes chaînes, comme les petits entiers, de manière unique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True True\n",
      "139947832119112 139947832119112 139947832119112\n"
     ]
    }
   ],
   "source": [
    "a = 'je'\n",
    "b = a\n",
    "c = 'je'\n",
    "print(a == b == c, a is b, a is c)\n",
    "print(id(a), id(b), id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Affectation de variable : liste Python (list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True False\n",
      "139947832184200 139947832184200 139947832184328\n"
     ]
    }
   ],
   "source": [
    "a = [i for i in range(100)]\n",
    "b = a\n",
    "c = [i for i in range(100)]\n",
    "print(a == b == c, a is b, a is c)\n",
    "print(id(a), id(b), id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Affectation de variable : liste Python (list) : pas de cas particulier\n",
    "Même une liste vide est différente d'une autre chaîne vide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True False\n",
      "139947832184008 139947832184008 139947832184136\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "b = a\n",
    "c = []\n",
    "print(a == b == c, a is b, a is c)\n",
    "print(id(a), id(b), id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Affectation de variable : cas particulier de None\n",
    "C'est un objet à part et unique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True True\n",
      "94746010304752 94746010304752 94746010304752\n"
     ]
    }
   ],
   "source": [
    "a = None\n",
    "b = a\n",
    "c = None\n",
    "print(a == b == c, a is b, a is c)\n",
    "print(id(a), id(b), id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Affectation, puis réaffectation de variable : avec des objets non mutables (ex des entiers)\n",
    "On peut réaffecter a sans modifier b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1255\n",
      "False False\n",
      "1000 1255\n"
     ]
    }
   ],
   "source": [
    "a = 1255\n",
    "print(a)\n",
    "b = a\n",
    "a = 1000\n",
    "print(a == b, a is b)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Affectation, puis modification de variable : avec des objets mutables (ex des listes Python)\n",
    "b et a référencent le même objet list.\n",
    "\n",
    "En modifiant l'objet list en utilisant la variable a, on affecte directement le contenu de la variable b, puisque b référence le même objet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "True True\n",
      "[0, 1, 2, 3, 4, 1000, 6, 7, 8, 9] [0, 1, 2, 3, 4, 1000, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "a = [i for i in range(10)]\n",
    "print(a)\n",
    "b = a\n",
    "a[5] = 1000\n",
    "print(a == b, a is b)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualisons tout cela avec Python Tutor pour mieux comprendre.\n",
    "*Remarque* : si vous ne pouvez pas activer Python tutor parce que le module metakernel n'est pas installé, ouvrez dans un autre onglet Python Tutor online et recopiez chaque extrait de code \"à la main\".\n",
    "\n",
    "http://www.pythontutor.com/visualize.html#mode=edit\n",
    "\n",
    "**Bien prendre le temps d'exécuter chaque instruction pas à pas et s'assurer de comprendre ce qu'il se passe à chaque étape !**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"100%\"\n",
       "            height=\"500\"\n",
       "            src=\"https://pythontutor.com/iframe-embed.html#code=a%20%3D%20%5B1%2C%202%2C%203%5D%0Ab%20%3D%20a%0Ac%20%3D%20%5B1%2C%202%2C%203%5D%0Aa%5B1%5D%20%3D%201000%0Aa%20%3D%20%5B0%5D%20%2A%203%0Aa%20%3D%20%5B1%20for%20i%20in%20range%283%29%5D%0A&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&py=3&rawInputLstJSON=%5B%5D&curInstr=0&codeDivWidth=350&codeDivHeight=400\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f4824d2b5c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor\n",
    "a = [1, 2, 3]\n",
    "b = a\n",
    "c = [1, 2, 3]\n",
    "a[1] = 1000\n",
    "a = [0] * 3\n",
    "a = [1 for i in range(3)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables et fonctions : \n",
    "1. variables locales ou globales, contexte d'exécution, espace de noms global ou local.\n",
    "2. références partagées\n",
    "\n",
    "Commencer par exécuter la série de ceules suivantes en essayant de **prévoir** et comprendre les sorties. Ensuite décommenter la ligne #%%tutor et visualiser toutes les exécutions pas à pas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Une fonction s'exécute dans son contexte d'exécution \"personnel\". Une variable apparaissant dans son espace de noms propre est indépendante d'une variable définie dans l'espace de noms global."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = 5\n",
    "def f():\n",
    "    a = 1\n",
    "    return a\n",
    "resultat = f()\n",
    "print(a)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Si une fonction ne  trouve pas une variable dans l'espace de noms propre à son contexte d'exécution, elle la cherche dans l'espace de noms global.\n",
    " f peut évaluer (a+1) à partir de l'espace de noms global et l'affecter à la variable locale b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = 5\n",
    "def f():\n",
    "    b = a + 1\n",
    "    return b\n",
    "resultat = f()\n",
    "print(a)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ci-dessous ça coince parce que la fonction considère *en priorité* que a est une variable locale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'a' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-ea16b556fff4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mresultat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\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      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresultat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-14-ea16b556fff4>\u001b[0m in \u001b[0;36mf\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mf\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[0;32m----> 4\u001b[0;31m     \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mresultat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\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;31mUnboundLocalError\u001b[0m: local variable 'a' referenced before assignment"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = 5\n",
    "def f():\n",
    "    a = a + 1\n",
    "    return a\n",
    "resultat = f()\n",
    "print(a)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Ci-dessous ça fonctionne, mais la variable a dans la fonction est bien une variable locale, et la variable a de l'espace de noms global n'est pas affectée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = 5\n",
    "def f():\n",
    "    a = 1\n",
    "    a = a + 1\n",
    "    return a\n",
    "resultat = f()\n",
    "print(a)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  On peut \"avertir\" une fonction que les variables qui apparaissent dans son corps doivent être celles de l'espace de noms global (mot clef global en début de fonction)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = 5\n",
    "def f():\n",
    "    global a\n",
    "    a = 1\n",
    "    a = a + 1\n",
    "    return a\n",
    "resultat = f()\n",
    "print(a)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Une variable locale à une fonction n'est pas connue à l'extérieur de son contexte d'exécution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-3315cb2a7274>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresultat\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[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = 5\n",
    "def f():\n",
    "    x = 1\n",
    "    x = x + a\n",
    "    return x\n",
    "resultat = f()\n",
    "print(a)\n",
    "print(resultat)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Une nouvelle variable apparaissant dans une fonction peut être déclarée comme globale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = 5\n",
    "def f():\n",
    "    global x\n",
    "    x = 1\n",
    "    x = x + a\n",
    "    return x\n",
    "resultat = f()\n",
    "print(a)\n",
    "print(resultat)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Paramètre formel et paramètre effectif.\n",
    "Le paramètre qui apparaît dans la signature de la fonction est un paramètre formel, local à la fonction. Le paramètre effectif qui est passé à la fonction lors de son appel, n'est pas affecté par l'exéction de la fonction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'p' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-92d6d2b437f1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresultat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'p' is not defined"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = 5\n",
    "def f(p):\n",
    "    p = p + 1\n",
    "    return p\n",
    "resultat = f(a)\n",
    "print(a)\n",
    "print(resultat)\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oui, mais... !\n",
    "### Attention aux références partagées des objets mutables comme les listes.\n",
    "Si le paramètre effectif est une variable qui référence une liste, c'est l'objet liste qui est passé à la fonction. Et si la fonction modifie cette liste, alors l'objet est modifié pour toutes les variables qui le référence !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1000, 3]\n",
      "[1, 1000, 3]\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = [1, 2, 3]\n",
    "def f(x):\n",
    "    x[1] = 1000\n",
    "    return x\n",
    "resultat = f(a)\n",
    "print(a)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Les cellules suivantes sont plus facultatives, même si elles restent très instructives. Elles permettent de voir comment les méthodes des listes, ou les concaténations (opérateur +) ou même l'opérateur +=,  affectent différemment les listes, en place, ou avec une recopie préliminaire et création de nouvel objet.\n",
    "Python Tutor indispensable ici à mon avis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = [1, 2, 3]\n",
    "def f(x):\n",
    "    x = x + [4]\n",
    "    return x\n",
    "resultat = f(a)\n",
    "print(a)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = [1, 2, 3]\n",
    "def f(x):\n",
    "    x += [4]\n",
    "    return x\n",
    "resultat = f(a)\n",
    "print(a)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = [1, 2, 3]\n",
    "def f(x):\n",
    "    x.append(4)\n",
    "    return x\n",
    "resultat = f(a)\n",
    "print(a)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = [1, 2, 3]\n",
    "def f(x):\n",
    "    y = [4, 5]\n",
    "    x = x + y\n",
    "    return x\n",
    "resultat = f(a)\n",
    "print(a)\n",
    "print(resultat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "#%%tutor\n",
    "a = [1, 2, 3]\n",
    "def f(x):\n",
    "    y = [4, 5]\n",
    "    x.extend(y)\n",
    "    return x\n",
    "resultat = f(a)\n",
    "print(a)\n",
    "print(resultat)"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}