Lecture-5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteration Tools\n",
    "\n",
    "* itertools.accumulate(iterable[, func])\n",
    "\n",
    "* itertools.chain(*iterables)\n",
    "\n",
    "    `my_list = list(chain(['foo', 'bar'], cmd, numbers))`\n",
    "    \n",
    "* itertools.chain.from_iterable(iterable)\n",
    "\n",
    "    `list(chain.from_iterable([cmd, numbers]))`\n",
    "    \n",
    "* itertools.compress(data, selectors)\n",
    "``` python\n",
    "letters = 'ABCDEFG'\n",
    "bools = [True, False, True, True, False]\n",
    "print(list(compress(letters, bools)))  \n",
    "``` \n",
    "\n",
    "* itertools.dropwhile(predicate, iterable)\n",
    "```python\n",
    "    def less_than_five(x):\n",
    "        return x < 5 \n",
    "    print(list(dropwhile(less_than_five, [1, 4, 5, 1, 6])))\n",
    "    print(list(dropwhile(lambda x: x > 5, [6, 7, 8, 9, 1, 2, 3, 10])))\n",
    "```\n",
    "    \n",
    "* itertools.filterfalse(predicate, iterable)\n",
    "\n",
    "* itertools.groupby(iterable, key=None)\n",
    "\n",
    "The key argument is a function, or if none is specified, defaults to the identity function which returns the element unchanged\n",
    "```python\n",
    "    from itertools import groupby\n",
    "    vehicles = [('Ford', 'Taurus'), ('Dodge', 'Durango'),\n",
    "                ('Chevrolet', 'Cobalt'), ('Ford', 'F150'),\n",
    "                ('Dodge', 'Charger'), ('Ford', 'GT')]\n",
    "    sorted_vehicles = sorted(vehicles)\n",
    "    for key, group in groupby(sorted_vehicles, lambda make: make[0]):\n",
    "        for make, model in group:\n",
    "            print('{model} is made by {make}'.format(model=model, make=make))\n",
    "        print (\"**** END OF GROUP ***\\n\")\n",
    "```        \n",
    "        \n",
    "* itertools.islice(iterable, start, stop[, step])\n",
    "\n",
    "\n",
    "* itertools.starmap(function, iterable)  **?????????**\n",
    "\n",
    "    The difference between map() and starmap() parallels the distinction between function(a,b) and function(*c).\n",
    "\n",
    "* Defining functions with *args\n",
    "\n",
    "* itertools.takewhile(predicate, iterable)\n",
    "\n",
    "    opposite of the dropwhile iterator\n",
    "      \n",
    "* itertools.tee(iterable, n=2)\n",
    "\n",
    "\n",
    "* itertools.zip_longest(*iterables, fillvalue=None)\n",
    "    \n",
    "    If the iterables don’t happen to be the same length, then you can also pass in a fillvalue\n",
    "    \n",
    "    \n",
    "    \n",
    "* itertools.combinations(iterable, r)\n",
    "\n",
    "* itertools.combinations_with_replacement(iterable, r)\n",
    "\n",
    "* itertools.product(*iterables, repeat=1)\n",
    "\n",
    "* itertools.permutations(iterable, r=None)\n",
    "\n",
    "\n",
    "\n",
    "* Calling functions with *args\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# iterator don't require load the content to memory \n",
    "# until it access the content\n",
    "# that's why it save memory\n",
    "\n",
    "it = iter(\"NYU\") # iter() is a built-in funciton"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<str_iterator object at 0x0000000004CF24E0>\n",
      "<enumerate object at 0x0000000004CE8A68>\n",
      "<enumerate object at 0x0000000004CE8A68>\n"
     ]
    }
   ],
   "source": [
    "print(it)\n",
    "print(enumerate(it))\n",
    "print(enumerate(it))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 N\n",
      "1 Y\n",
      "2 U\n"
     ]
    }
   ],
   "source": [
    "for n, char in enumerate(it): # enumerate() is a built-in funciton, \n",
    "    print(n, char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# it now should print nothing\n",
    "# but why???\n",
    "# enumerate() return a so-call enumerate object\n",
    "# https://www.codecademy.com/en/forum_questions/5087f2d786a27b02000041a9\n",
    "# https://docs.python.org/3/library/functions.html#enumerate\n",
    "for n, char in enumerate(it):\n",
    "    print(n, char)\n",
    "\n",
    "for n, char in enumerate(it): # the second for loop will print nothing\n",
    "    print(n, char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-a1cc91b7bc73>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mit\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__next__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "it.__next__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from itertools import count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "13\n",
      "16\n",
      "19\n",
      "22\n",
      "25\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "for i in count(10 , 3):\n",
    "    if i > 30:\n",
    "        break;\n",
    "    else:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "from itertools import islice\n",
    "for i in islice(count(10), 5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x\n",
      "y\n",
      "z\n",
      "x\n",
      "y\n",
      "z\n",
      "x\n",
      "y\n",
      "z\n",
      "x\n"
     ]
    }
   ],
   "source": [
    "from itertools import cycle\n",
    "for item in islice(cycle('xyz'), 10):\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "a\n",
      "b\n",
      "abcd\n",
      "abcd\n",
      "abcd\n",
      "abcd\n",
      "abcd\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-9b64722b7fc9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mc\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mit_repeat\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# repeat v.s. cycle => finite iterator v.s. infinite iterator\n",
    "\n",
    "from itertools import repeat\n",
    "my_str = 'abcd'\n",
    "it_cycle = cycle(my_str)\n",
    "it_repeat = repeat(my_str, 5)\n",
    "\n",
    "for c in range(6):\n",
    "    print(next(it_cycle))\n",
    "\n",
    "for c in range(6):\n",
    "    print(next(it_repeat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo\n",
      "bar\n",
      "ls\n",
      "['/some/dir', 'aha!', 0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "# What will happen if we change the underlying data after generate a iterator ?\n",
    "#     The iterator will reflect all the changes for those not-visited element\n",
    "\n",
    "# Actually if there is a way to reset the iterator to the beginning, all changes on underying data\n",
    "# will be dynamically reflect, cuz' the iterator access the data as required, it only keep a \n",
    "# reference (I guess) of all its underlying data. \n",
    "\n",
    "my_list = ['foo', 'bar']\n",
    "numbers = list(range(5))\n",
    "cmd = ['ls', '/some/dir']\n",
    "\n",
    "from itertools import chain\n",
    "\n",
    "my_list_iter = chain(['foo', 'bar'], cmd, numbers)\n",
    "\n",
    "print(next(my_list_iter))  \n",
    "print(next(my_list_iter))\n",
    "print(my_list_iter.__next__()) \n",
    "\n",
    "cmd.append('aha!')\n",
    "print(list(my_list_iter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# What are the python iteration class methods next() and __next__() for, and what is the difference?\n",
    "# dir(my_list_iter.__next__)\n",
    "# dir(my_list_iter.next())\n",
    "# dir(next)\n",
    "# Python 3.0 provides a built-in function, next, that automatically calls an object’s __next__ method\n",
    "\n",
    "# They are just the same thing: \n",
    "#       http://stackoverflow.com/a/7223218"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cobalt is made by Chevrolet\n",
      "**** END OF GROUP ***\n",
      "\n",
      "Charger is made by Dodge\n",
      "Durango is made by Dodge\n",
      "**** END OF GROUP ***\n",
      "\n",
      "F150 is made by Ford\n",
      "GT is made by Ford\n",
      "Taurus is made by Ford\n",
      "**** END OF GROUP ***\n",
      "\n",
      "*******************************\n",
      "Taurus is made by Ford\n",
      "**** END OF GROUP ***\n",
      "\n",
      "Durango is made by Dodge\n",
      "**** END OF GROUP ***\n",
      "\n",
      "Cobalt is made by Chevrolet\n",
      "**** END OF GROUP ***\n",
      "\n",
      "F150 is made by Ford\n",
      "**** END OF GROUP ***\n",
      "\n",
      "Charger is made by Dodge\n",
      "**** END OF GROUP ***\n",
      "\n",
      "GT is made by Ford\n",
      "**** END OF GROUP ***\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from itertools import groupby\n",
    " \n",
    "vehicles = [('Ford', 'Taurus'), ('Dodge', 'Durango'),\n",
    "            ('Chevrolet', 'Cobalt'), ('Ford', 'F150'),\n",
    "            ('Dodge', 'Charger'), ('Ford', 'GT')]\n",
    " \n",
    "sorted_vehicles = sorted(vehicles)\n",
    " \n",
    "for key, group in groupby(sorted_vehicles, lambda make: make[0]):\n",
    "    for make, model in group:\n",
    "        print('{model} is made by {make}'.format(model=model, make=make))\n",
    "    print (\"**** END OF GROUP ***\\n\")\n",
    "    \n",
    "    \n",
    "print(\"*******************************\")\n",
    "# If unsorted, the result will be totally different\n",
    "# According to Python Docs: \n",
    "#     https://docs.python.org/3/library/itertools.html#itertools.groupby\n",
    "#     Generally, the iterable needs to already be sorted on the same key function.\n",
    "#     The operation of groupby() is similar to the uniq filter in Unix. \n",
    "#     That behavior differs from SQL’s GROUP BY which aggregates common elements regardless of their input order\n",
    "for key, group in groupby(vehicles, lambda make: make[0]):\n",
    "    for make, model in group:\n",
    "        print('{model} is made by {make}'.format(model=model, make=make))\n",
    "    print (\"**** END OF GROUP ***\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}