{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "627f100d-de61-4400-adfd-c91f971571af"
    }
   },
   "source": [
    "# zip\n",
    "\n",
    "Zip() construit un itérateur qui agrège des éléments de chacun des iterables.\n",
    "\n",
    "Renvoie une séquence de tuples, où le tuple n contient l'élément n de chacun des arguments, séquence ou objet iterable. La séquence s'arrête lorsque la plus petite séquence itérative est épuisée. Avec un seul argument séquentiel, elle renvoie un itérateur de tuples à 1 élément. Sans arguments, elle retourne une séquence vide.\n",
    "\n",
    "Zip () est équivalent à:\n",
    "\n",
    "    def zip(*iterables):\n",
    "        # zip('ABCD', 'xy') --> Ax By\n",
    "        sentinelle = object()\n",
    "        items = [iter(it) for it in iterables]\n",
    "        while items:\n",
    "            resultat = []\n",
    "            for it in items:\n",
    "                elem = next(it, sentinelle)\n",
    "                if elem is sentinelle:\n",
    "                    return\n",
    "                result.append(elem)\n",
    "            yield tuple(resultat)\n",
    "        \n",
    "Zip() ne doit être utilisé avec des entrées de longueur inégale que lorsque vous ne vous souciez pas des valeurs de fin de tableau qui n'ont pas de correspondance, et qui donc disparaitront.\n",
    "\n",
    "Voyons cela en action dans quelques exemples:\n",
    "\n",
    "## Exemples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "nbpresent": {
     "id": "4118fcae-7f57-4148-8b36-8c39bbb90f31"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 4), (2, 5), (3, 6)]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "y = [4,5,6]\n",
    "\n",
    "list(zip(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "52807d2f-df45-4fef-ae3d-f5e7783e8e3d"
    }
   },
   "source": [
    "Remarquez comment les tuples sont renvoyés. Que se passe-t-il quand une séquence est plus longue que l'autre?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "nbpresent": {
     "id": "81d588f9-8dcf-4b07-8c7a-99a0fe4dc22f"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 4), (2, 5), (3, 6)]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "y = [4,5,6,7,8]\n",
    "\n",
    "list(zip(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "d29384c8-06aa-48a5-9aaa-967a516c3c2f"
    }
   },
   "source": [
    "Remarquez comment le zip est défini par la longueur de la plus courte des séquences en entrée. Il est généralement conseillé de ne pas utiliser zip avec des séquences de longueur inégale à moins d'être absolument certain que vous n'avez pas besoin de tous les appariements.\n",
    "\n",
    "On peut avoir plus de deux itérables en entrée, par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 4, 7), (2, 5, 8), (3, 6, 9)]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "y = [4,5,6]\n",
    "z = [7,8,9]\n",
    "\n",
    "list(zip(x,y,z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C'est un moyen très efficace pour construire un dictionnaire à partir de deux listes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "clef = ['chat', 'chien']\n",
    "valeur = ['miaou', 'ouaf']\n",
    "\n",
    "d = dict(zip(clef, valeur))\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que se passe-t-il si nous utilisons des dictionnaires en entrée ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "nbpresent": {
     "id": "9e91f977-1d00-4e79-84f9-cdcca23acce4"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('c', 'f'), ('b', 'e'), ('a', 'd')]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {'a':1, 'b':2, 'c':3}\n",
    "d2 = {'d':4, 'e':5, 'f':6}\n",
    "\n",
    "list(zip(d1,d2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "ed07b68b-1d30-424c-85f1-78f193a354ff"
    }
   },
   "source": [
    "C'est logique parce que réaliser les itérations dans un dictionnaire ne s'applique que sur les clefs. Il faudrait appeler des méthodes pour mélanger les clés et les valeurs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "nbpresent": {
     "id": "9a11d66c-fb20-4932-bad4-470dae9cf29a"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('d', 1), ('c', 2)]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(d2,d1.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "1bdb7739-7ae3-4ca9-8eaa-daa8d00c3ed7"
    }
   },
   "source": [
    "Bravo ! Pour terminer, utilisons zip pour échanger les clés et les valeurs des deux dictionnaires:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "90cbfa34-b990-40a5-aa2b-c8648bcfb874"
    }
   },
   "outputs": [],
   "source": [
    "def echangiste(d1,d2):\n",
    "    dsortie = {}\n",
    "    \n",
    "    for d1clef,d2valeur in zip(d1,d2.values()):\n",
    "        dsortie[d1clef] = d2valeur\n",
    "    \n",
    "    return dsortie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "nbpresent": {
     "id": "e965da74-68a4-4a00-8e30-d30db4483456"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 5, 'b': 4}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "echangiste(d1,d2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "ec32fb2a-977f-4604-9735-2b2f179f6b0b"
    }
   },
   "source": [
    "Bravo ! Vous pouvez utiliser zip pour économiser beaucoup de lignes de code dans de nombreuses situations ! Vous devriez maintenant avoir une bonne connaissance de zip() et de quelques cas d'utilisation possibles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "eaec4037-c294-4284-8c88-61ab23a60cf8"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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": 0
}