{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les listes\n",
    "- Les listes sont des objets **mutables**.\n",
    "- Les éléments sont eux-mêmes mutables. **Il faut se méfier des copies de listes.**\n",
    "- Les élémenst sont indexés. **Le premier index est 0.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I) Définition d'une liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) Définition exhaustive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 'a', 3.7, 'hou']\n",
      "Liste de longueur 4\n"
     ]
    }
   ],
   "source": [
    "ma_liste=[3,\"a\",3.7,\"hou\"]\n",
    "print(ma_liste)\n",
    "print(f\"Liste de longueur {len(ma_liste)}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) À l'aide d'un range()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# une liste d'entiers : de 0 à 9 (attention pas de 10 !!!!!)\n",
    "L=list(range(10))\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "# une liste des entiers de 2 à 7  (attention pas de 8 !!!!!)\n",
    "L=list(range(2,8))\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c) À l'aide d'une compréhension\n",
    "C'est une méthode très efficace à recommander."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "#liste de carrés\n",
    "L=[x**2 for x in range(1,11)]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255, 272, 289, 306, 323, 340, 357, 374, 391, 408, 425, 442, 459, 476, 493]\n"
     ]
    }
   ],
   "source": [
    "#liste de multiples de 17\n",
    "L=[x for x in range(500) if x%17==0]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### d) À l'aide l'instruction append()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 3, 4, 1, 2, 5, 3, 1, 1, 3, 2, 1, 5, 3, 4, 3, 2, 1, 6]\n"
     ]
    }
   ],
   "source": [
    "# Liste d'entiers aléatoires entre 1 et 6\n",
    "from random import randint\n",
    "\n",
    "\n",
    "L=[]\n",
    "for k in range(20):\n",
    "    L.append(randint(1,6))\n",
    "print(L)\n",
    "\n",
    "# équivalent en comprésention : L=[randint(1,6) for k in range(20)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711]\n"
     ]
    }
   ],
   "source": [
    "# La suite de Fibonacci\n",
    "L=[1,1]\n",
    "for k in range(20) :\n",
    "    L.append(L[k]+L[k+1]) # on rajoute petit à petit les valeurs\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### e) En tant que sous-liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['c', 'd', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "# à partir de l'élément [2]\n",
    "ma_liste=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "L=ma_liste[2:]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b']\n"
     ]
    }
   ],
   "source": [
    "# jusquá l'élément [1]\n",
    "ma_liste=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "L=ma_liste[:2]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['c', 'd', 'e']\n"
     ]
    }
   ],
   "source": [
    "# entre les éléments [2] et [4]\n",
    "ma_liste=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "L=ma_liste[2:5]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "# tous les éléments\n",
    "ma_liste=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "L=ma_liste[:]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'c', 'e']\n"
     ]
    }
   ],
   "source": [
    "# tous les éléments de 2 en 2\n",
    "ma_liste=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "L=ma_liste[::2]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['f', 'e', 'd', 'c', 'b', 'a']\n"
     ]
    }
   ],
   "source": [
    "# tous les éléments à l'envers\n",
    "ma_liste=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "L=ma_liste[::-1]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 7, 10, 13, 16, 19]\n"
     ]
    }
   ],
   "source": [
    "# à partir de l'élément [1] de 3 en 3\n",
    "ma_liste=list(range(20))\n",
    "L=ma_liste[1::3]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## II) Différentes façons de copier une liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) Copie en surface (shallow copy)\n",
    "Cette solution rapide suffit pour les listes simples, mais pas pour les listes de listes par exemples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L1 = [1, 2, 3]\n",
      "L2 = [1, 2, 3]\n",
      "Après modification de L2, L1 reste inchangée :\n",
      "L1 = [1, 2, 3]\n",
      "L2 = [18, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Copie d'une liste simple\n",
    "L1=[1,2,3]\n",
    "L2=L1[:]\n",
    "print(f\"L1 = {L1}\")\n",
    "print(f\"L2 = {L2}\")\n",
    "L2[0]=18\n",
    "print(\"Après modification de L2, L1 reste inchangée :\")\n",
    "print(f\"L1 = {L1}\")\n",
    "print(f\"L2 = {L2}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L1 = [[1, 1], 2, 3]\n",
      "L2 = [[1, 1], 2, 3]\n",
      "Après modification de L2, L1 aussi a changé :\n",
      "L1 = [[18, 1], 2, 3]\n",
      "L2 = [[18, 1], 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Exemple d'une liste de liste\n",
    "L1=[[1,1],2,3]\n",
    "L2=L1[:]\n",
    "print(f\"L1 = {L1}\")\n",
    "print(f\"L2 = {L2}\")\n",
    "L2[0][0]=18\n",
    "print(\"Après modification de L2, L1 aussi a changé :\")\n",
    "print(f\"L1 = {L1}\")\n",
    "print(f\"L2 = {L2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## b) Copie en profondeur (deep copy)\n",
    "Cette fois-ci, les deux listes seront indépendantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L1 = [[1, 1], 2, 3]\n",
      "L2 = [[1, 1], 2, 3]\n",
      "Après modification de L2, L1 reste inchangée :\n",
      "L1 = [[1, 1], 2, 3]\n",
      "L2 = [[18, 1], 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Exemplde d'une liste de liste\n",
    "import copy\n",
    "L1=[[1,1],2,3]\n",
    "L2=copy.deepcopy(L1)  # à noter que L1[:] revient à faire copy.copy(L1)\n",
    "print(f\"L1 = {L1}\")\n",
    "print(f\"L2 = {L2}\")\n",
    "L2[0][0]=18\n",
    "print(\"Après modification de L2, L1 reste inchangée :\")\n",
    "print(f\"L1 = {L1}\")\n",
    "print(f\"L2 = {L2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## III) Accès aux éléments de la liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) Lecture d'une valeur\n",
    "Attention, le premier indice d'une liste est 0 !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L[0]=a\n",
      "L[1]=5\n",
      "L[2]=9\n"
     ]
    }
   ],
   "source": [
    "L=[\"a\",5,9]\n",
    "print(f\"L[0]={L[0]}\")\n",
    "print(f\"L[1]={L[1]}\")\n",
    "print(f\"L[2]={L[2]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) Changement d'une valeur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[14, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "# une liste simple\n",
    "L=[1,5,7]\n",
    "L[0]=14\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2], [800, 4]]\n"
     ]
    }
   ],
   "source": [
    "#une liste de listes\n",
    "L=[[1,2],[3,4]]\n",
    "L[1][0]=800\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IV) Suppression d'éléments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) Fonction pop()\n",
    "Cette fonction enlève un élément de la liste et renvoie ce qui a été supprimé.\n",
    "\n",
    "À noter qu'on ne peut enlever qu'un seul élément."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c\n",
      "['a', 'b', 'd', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "# on enlève l'élément [2]\n",
    "L=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "a=L.pop(2)\n",
    "print(a)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f\n",
      "['a', 'b', 'c', 'd', 'e']\n"
     ]
    }
   ],
   "source": [
    "# on enlève le dernier élément\n",
    "L=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "a=L.pop()\n",
    "print(a)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "['b', 'c', 'd', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "# on enlève le premier élément\n",
    "L=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "a=L.pop(0)\n",
    "print(a)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) Fonction del()\n",
    "Cette fonction permet de supprimer un ou plusieurs éléments.\n",
    "\n",
    "Elle ne renvoie pas les valeurs supprimées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'd', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "# on enlève l'élément [2]\n",
    "L=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "del L[2]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b']\n"
     ]
    }
   ],
   "source": [
    "# on enlève à partir de l'élément [2]\n",
    "L=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "del L[2:]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'L' 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-18-53b351c568f3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mL\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"a\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"b\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"c\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"d\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"e\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"f\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mL\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mL\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 'L' is not defined"
     ]
    }
   ],
   "source": [
    "# détruit la liste\n",
    "L=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "del L\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c) Fonction remove()\n",
    "Cette fonction supprime le premier élément de valeur donnée.\n",
    "\n",
    "Elle ne renvoie pas la valeur supprimée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'W', 'c', 'W', 'd']\n"
     ]
    }
   ],
   "source": [
    "# on enlève le premier \"W\" uniquement\n",
    "L=[\"a\",\"b\",\"W\",\"c\",\"W\",\"d\"]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### d) Par compréhension\n",
    "Voici un moyen de supprimer toutes les occurences d'une valeur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "# on enlève tous les \"W\"\n",
    "L=[\"a\",\"b\",\"W\",\"c\",\"W\",\"d\"]\n",
    "L=[el for el in L if el!=\"W\"]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## V) Ajouter des valeurs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) Fonction append()\n",
    "Cette fonction ajoute un élément en fin de liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
     ]
    }
   ],
   "source": [
    "L=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "L.append(\"g\")\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) Fonction extend()\n",
    "Cette fonction permet d'ajouter tous les éléments d'une liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']\n"
     ]
    }
   ],
   "source": [
    "L=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "A=[\"g\",\"h\",\"i\"]\n",
    "L.extend(A)\n",
    "# ou L=L+A\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c) Fonction insert()\n",
    "Cette fonction permet d'insérer un élément particulier à une position donnée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "# on insert à la position[2] la valeur \"c\"\n",
    "L=[\"a\",\"b\",\"d\",\"e\",\"f\"]\n",
    "L.insert(2,\"c\")\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### d) Insertion / remplacement de plusieurs éléments\n",
    "On insère ou on remplace  des éléments dans une liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'X', 'Y', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "# insertion à l'élément [2] sans suppression\n",
    "L=[\"a\",\"b\",\"c\",\"d\"]\n",
    "L[2:2]=[\"X\",\"Y\"]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'X', 'Y', 'Z', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "# insertion à l'élément [2] après suppression de [2] et [3]\n",
    "L=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]\n",
    "L[2:4]=[\"X\",\"Y\",\"Z\"]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Format de la Cellule Texte Brut",
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}