itertools.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import operator\n",
    "import numpy as np\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<i><b>Note:</b> All the functions in itertools return iterators.</i>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_grouper',\n",
       " '_tee',\n",
       " '_tee_dataobject',\n",
       " 'accumulate',\n",
       " 'chain',\n",
       " 'combinations',\n",
       " 'combinations_with_replacement',\n",
       " 'compress',\n",
       " 'count',\n",
       " 'cycle',\n",
       " 'dropwhile',\n",
       " 'filterfalse',\n",
       " 'groupby',\n",
       " 'islice',\n",
       " 'permutations',\n",
       " 'product',\n",
       " 'repeat',\n",
       " 'starmap',\n",
       " 'takewhile',\n",
       " 'tee',\n",
       " 'zip_longest']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(itertools)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### accumulate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns accumulated results of given binary functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,3,4,5,6,7,8,9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from accumulate: <itertools.accumulate object at 0x10d86ed20>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Output: [1, 3, 6, 10, 15, 21, 28, 36, 45]\n"
     ]
    }
   ],
   "source": [
    "acc = itertools.accumulate(lst, operator.add) ## same results as cumsum\n",
    "print(\"Output from accumulate: {}\".format(acc))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(acc)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from accumulate: <itertools.accumulate object at 0x10d8723c0>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Output: [1, 2, 6, 24, 120, 720, 5040, 40320, 362880]\n"
     ]
    }
   ],
   "source": [
    "acc = itertools.accumulate(lst, operator.mul) ## same results as cumprod\n",
    "print(\"Output from accumulate: {}\".format(acc))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(acc)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from accumulate: <itertools.accumulate object at 0x10d872fa0>\n",
      "Input: [4, 2, 1, 3, 7, 9, 6, 8, 5]\n",
      "Output: [4, 4, 4, 4, 7, 9, 9, 9, 9]\n"
     ]
    }
   ],
   "source": [
    "unsorted_lst = random.sample(lst, len(lst))\n",
    "acc = itertools.accumulate(unsorted_lst, max) ## cumulatively apply max on a list\n",
    "print(\"Output from accumulate: {}\".format(acc))\n",
    "print('Input: {0}\\nOutput: {1}'.format(unsorted_lst, list(acc)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from accumulate: <itertools.accumulate object at 0x10d873410>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Output: [1, 40, 60, 80, 100, 120, 140, 160, 180]\n"
     ]
    }
   ],
   "source": [
    "acc = itertools.accumulate(lst, lambda x, y: 20* + y) ## custum function\n",
    "print(\"Output from accumulate: {}\".format(acc))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(acc)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### chain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combines elements of each input iterable into single iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst1 = [[1,2,3], [4,5,6]]\n",
    "lst2 = ['ABCD', [1,2,3,4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from chain: <itertools.chain object at 0x10d87c350>\n",
      "Input: [1, 2, 3], [4, 5, 6]\n",
      "Output: [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "ch = itertools.chain([1,2,3], [4,5,6])\n",
    "print(\"Output from chain: {}\".format(ch))\n",
    "print('Input: {0}, {1}\\nOutput: {2}'.format([1,2,3], [4,5,6], list(ch)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from chain: <itertools.chain object at 0x10d87c150>\n",
      "Input: [[1, 2, 3], [4, 5, 6]]\n",
      "Output: [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "ch = itertools.chain(*lst1)  ## 1st level flattening of the list\n",
    "print(\"Output from chain: {}\".format(ch))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst1, list(ch)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from chain: <itertools.chain object at 0x10d87c750>\n",
      "Input: HELLO, WORLD\n",
      "Output: ['H', 'E', 'L', 'L', 'O', ',', ' ', 'W', 'O', 'R', 'L', 'D']\n"
     ]
    }
   ],
   "source": [
    "ch = itertools.chain(\"HELLO, WORLD\")  ## Since string is also an iterable, it separates each char\n",
    "print(\"Output from chain: {}\".format(ch))\n",
    "print('Input: {0}\\nOutput: {1}'.format(\"HELLO, WORLD\", list(ch)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from chain: <itertools.chain object at 0x10d865a50>\n",
      "Input: ABCD, EFGH\n",
      "Output: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']\n"
     ]
    }
   ],
   "source": [
    "ch = itertools.chain(\"ABCD\", \"EFGH\")  ## combined list of characters\n",
    "print(\"Output from chain: {}\".format(ch))\n",
    "print('Input: {0}, {1}\\nOutput: {2}'.format(\"ABCD\", \"EFGH\", list(ch)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from chain: <itertools.chain object at 0x10d865dd0>\n",
      "Input: ['ABCD', [1, 2, 3, 4]]\n",
      "Output: ['A', 'B', 'C', 'D', 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "ch = itertools.chain(*lst2)  ## also works with string and list of intergers\n",
    "print(\"Output from chain: {}\".format(ch))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst2, list(ch)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### combinations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns all possible combinations from an iterable of input size. This is combinations with <i>sampling without replacement</i>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.combinations object at 0x10d8701d0>\n",
      "Input: [1, 2, 3, 4, 5]\n",
      "Output: [(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]\n"
     ]
    }
   ],
   "source": [
    "comb = itertools.combinations(lst, 2)\n",
    "print(\"Output from combinations: {}\".format(comb))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(comb)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.combinations object at 0x10d850830>\n",
      "Input: [1, 2, 3, 4, 5]\n",
      "Output: [(1, 2, 3, 4), (1, 2, 3, 5), (1, 2, 4, 5), (1, 3, 4, 5), (2, 3, 4, 5)]\n"
     ]
    }
   ],
   "source": [
    "comb = itertools.combinations(lst, 4)\n",
    "print(\"Output from combinations: {}\".format(comb))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(comb)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.combinations object at 0x10d87f1d0>\n",
      "Input: [1, 2]\n",
      "Output: []\n"
     ]
    }
   ],
   "source": [
    "comb = itertools.combinations(lst[:2], 4)  ## As this is without replacement, not enough entries for input size 4\n",
    "print(\"Output from combinations: {}\".format(comb))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst[:2], list(comb)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### combinations_with_replacement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same as combinations but with <i>replacement</i>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations_with_replacement: <itertools.combinations_with_replacement object at 0x10d87f7d0>\n",
      "Input: [1, 2, 3, 4, 5]\n",
      "Output: [(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5), (5, 5)]\n"
     ]
    }
   ],
   "source": [
    "comb = itertools.combinations_with_replacement(lst, 2)\n",
    "print(\"Output from combinations_with_replacement: {}\".format(comb))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(comb)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations_with_replacement: <itertools.combinations_with_replacement object at 0x10d87fa10>\n",
      "Input: [1, 2, 3, 4, 5]\n",
      "Output: [(1, 1, 1, 1), (1, 1, 1, 2), (1, 1, 1, 3), (1, 1, 1, 4), (1, 1, 1, 5), (1, 1, 2, 2), (1, 1, 2, 3), (1, 1, 2, 4), (1, 1, 2, 5), (1, 1, 3, 3), (1, 1, 3, 4), (1, 1, 3, 5), (1, 1, 4, 4), (1, 1, 4, 5), (1, 1, 5, 5), (1, 2, 2, 2), (1, 2, 2, 3), (1, 2, 2, 4), (1, 2, 2, 5), (1, 2, 3, 3), (1, 2, 3, 4), (1, 2, 3, 5), (1, 2, 4, 4), (1, 2, 4, 5), (1, 2, 5, 5), (1, 3, 3, 3), (1, 3, 3, 4), (1, 3, 3, 5), (1, 3, 4, 4), (1, 3, 4, 5), (1, 3, 5, 5), (1, 4, 4, 4), (1, 4, 4, 5), (1, 4, 5, 5), (1, 5, 5, 5), (2, 2, 2, 2), (2, 2, 2, 3), (2, 2, 2, 4), (2, 2, 2, 5), (2, 2, 3, 3), (2, 2, 3, 4), (2, 2, 3, 5), (2, 2, 4, 4), (2, 2, 4, 5), (2, 2, 5, 5), (2, 3, 3, 3), (2, 3, 3, 4), (2, 3, 3, 5), (2, 3, 4, 4), (2, 3, 4, 5), (2, 3, 5, 5), (2, 4, 4, 4), (2, 4, 4, 5), (2, 4, 5, 5), (2, 5, 5, 5), (3, 3, 3, 3), (3, 3, 3, 4), (3, 3, 3, 5), (3, 3, 4, 4), (3, 3, 4, 5), (3, 3, 5, 5), (3, 4, 4, 4), (3, 4, 4, 5), (3, 4, 5, 5), (3, 5, 5, 5), (4, 4, 4, 4), (4, 4, 4, 5), (4, 4, 5, 5), (4, 5, 5, 5), (5, 5, 5, 5)]\n"
     ]
    }
   ],
   "source": [
    "comb = itertools.combinations_with_replacement(lst, 4)\n",
    "print(\"Output from combinations_with_replacement: {}\".format(comb))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(comb)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations_with_replacement: <itertools.combinations_with_replacement object at 0x10d8805f0>\n",
      "Input: [1, 2]\n",
      "Output: [(1, 1, 1, 1), (1, 1, 1, 2), (1, 1, 2, 2), (1, 2, 2, 2), (2, 2, 2, 2)]\n"
     ]
    }
   ],
   "source": [
    "comb = itertools.combinations_with_replacement(lst[:2], 4)  ## As this is with replacement\n",
    "print(\"Output from combinations_with_replacement: {}\".format(comb))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst[:2], list(comb)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### compress"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selects elements from the input list based on given masking list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,3,4,5,6,7,8,9]\n",
    "mask1 = [1,0,0,1,0,1,1,0,1]\n",
    "mask2 = [True,False,False,True,False,True,True,False,True]\n",
    "mask3 = [1,0,-2,4,0,3,7,0,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from compress: <itertools.compress object at 0x10c124cd0>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Mask: [1, 0, 0, 1, 0, 1, 1, 0, 1]\n",
      "Output: [1, 4, 6, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "comb = itertools.compress(lst, mask1)\n",
    "print(\"Output from compress: {}\".format(comb))\n",
    "print('Input: {0}\\nMask: {1}\\nOutput: {2}'.format(lst, mask1, list(comb)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from compress: <itertools.compress object at 0x10d883510>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Mask: [True, False, False, True, False, True, True, False, True]\n",
      "Output: [1, 4, 6, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "comb = itertools.compress(lst, mask2)\n",
    "print(\"Output from compress: {}\".format(comb))\n",
    "print('Input: {0}\\nMask: {1}\\nOutput: {2}'.format(lst, mask2, list(comb)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from compress: <itertools.compress object at 0x10d883850>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Mask: [1, 0, -2, 4, 0, 3, 7, 0, 2]\n",
      "Output: [1, 3, 4, 6, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "comb = itertools.compress(lst, mask3)  ## Also works because any non-zero number is considered as logical TRUE\n",
    "print(\"Output from compress: {}\".format(comb))\n",
    "print('Input: {0}\\nMask: {1}\\nOutput: {2}'.format(lst, mask3, list(comb)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns an iterator with sequence of numbers starting from given starting number and given step.\n",
    "\n",
    "$$\\{ni \\mid n_{i+1} = n_{i} + \\delta ; n_0=c\\}$$\n",
    "\n",
    "<b>IMP:</b> THIS FUNCTION DOES NOT HAVE END LIMIT. SO DO NOT USE THIS FUNCTION AS STANDALONE. USUALLY USE WITH map() AND zip()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rough implementation\n",
    "```py\n",
    "def count(start=0, step=1):\n",
    "    n = start\n",
    "    while True:\n",
    "        yeild n\n",
    "        n += step\n",
    "```\n",
    "As we can see there is noo termination condition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will run in infinite loop\n",
    "```py\n",
    "cnt = itertools.count(0, 2)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,3,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using with `map()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 9, 12]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(operator.add, lst, itertools.count(start=2, step=2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "using with `zip()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 2), (2, 4), (3, 6), (4, 8)]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(lst, itertools.count(start=2, step=2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using with comprehension for generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output of count: count(0)\n",
      "Output of generator <generator object <genexpr> at 0x10c2b15d0>: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "cnt = itertools.count(start=0, step=1)\n",
    "gen = (next(cnt) for _ in range(10))\n",
    "print(\"Output of count: {}\".format(cnt))\n",
    "print(\"Output of generator {0}: {1}\".format(gen, list(gen)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using with list and dictionary comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output of count: count(10)\n",
      "Output of list: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Output of count: count(5)\n",
      "Output of dict: {0: 0.7, 1: 0.14, 2: 0.53, 3: 0.16, 4: 0.54}\n"
     ]
    }
   ],
   "source": [
    "cnt = itertools.count(start=0, step=1)\n",
    "lst_comp = [next(cnt) for _ in range(10)]\n",
    "print(\"Output of count: {}\".format(cnt))\n",
    "print(\"Output of list: {}\".format(lst_comp))\n",
    "\n",
    "lst2 = np.round(np.random.rand(5), 2)\n",
    "cnt = itertools.count(start=0, step=1)\n",
    "dict_comp = {next(cnt):n for _, n in enumerate(lst2)}\n",
    "print(\"Output of count: {}\".format(cnt))\n",
    "print(\"Output of dict: {}\".format(dict_comp))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### cycle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cycle through the given iterable indefinitely. Therefore, this should also be used with complementory function for termination."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output of cycle: <itertools.cycle object at 0x10d88e730>\n",
      "Output of list: [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "cyc = itertools.cycle([1,2,3])\n",
    "lst = [next(cyc) for _ in range(100)]\n",
    "print(\"Output of cycle: {}\".format(cyc))\n",
    "print(\"Output of list: {}\".format(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output of cycle: <itertools.cycle object at 0x10d885d70>\n",
      "Output of list: ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A']\n"
     ]
    }
   ],
   "source": [
    "cyc = itertools.cycle(\"ABC\")\n",
    "lst = [next(cyc) for _ in range(100)]\n",
    "print(\"Output of cycle: {}\".format(cyc))\n",
    "print(\"Output of list: {}\".format(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dropwhile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drops elements from the iterable till the given logical condition is <i>TRUE</i> and returns everything afterward."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.dropwhile object at 0x10d885730>\n",
      "Input: [1, 3, 2, 4, 6, 2, 1, 3, 5]\n",
      "Output: [6, 2, 1, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "lst = [1,3,2,4,6,2,1,3,5]\n",
    "drp = itertools.dropwhile(lambda x: x<5, lst)\n",
    "print(\"Output from dropwhile: {}\".format(drp))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(drp)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can be used to get non-negetive numbers from a sorted list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.dropwhile object at 0x10d885820>\n",
      "Input: [-8, -2, -3, -1, 0, 1, 3, 5, 7]\n",
      "Output: [0, 1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "lst = [-8,-2,-3,-1,0,1,3,5,7]\n",
    "drp = itertools.dropwhile(lambda x: x<0, lst)\n",
    "print(\"Output from dropwhile: {}\".format(drp))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(drp)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can be used to get substring from a string after a character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.dropwhile object at 0x10c1f89b0>\n",
      "Old string: Hello,World\n",
      "New string: World\n"
     ]
    }
   ],
   "source": [
    "def match_char(s, match_char):\n",
    "    return s != match_char\n",
    "\n",
    "string = \"Hello,World\"\n",
    "char = \",\"\n",
    "drp = itertools.dropwhile(lambda s: match_char(s, char), string)\n",
    "new_string = \"\".join(drp).lstrip(char)\n",
    "print(\"Output from dropwhile: {}\".format(drp))\n",
    "print('Old string: {0}\\nNew string: {1}'.format(string, new_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### filterfalse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Return those elements from given iterable where given predicate in <i>FALSE</i> or <i>NONE</i>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.dropwhile object at 0x10c1f89b0>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Output: []\n"
     ]
    }
   ],
   "source": [
    "lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "fltr = itertools.filterfalse(lambda x: x%2, lst) ## Get all even numbers\n",
    "print(\"Output from dropwhile: {}\".format(drp))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(drp)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get alpha-numerics from a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.filterfalse object at 0x10d7e0810>\n",
      "Input: 1234 abcd123 1234def\n",
      "Output: ['abcd123', '1234def']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "string = \"1234 abcd123 1234def\"\n",
    "match_str = lambda s: not re.match(r\"([a-zA-Z]+\\d+)|(\\d+[a-zA-Z]+)\", s)\n",
    "fltr = itertools.filterfalse(match_str, string.split())\n",
    "print(\"Output from dropwhile: {}\".format(fltr))\n",
    "print('Input: {0}\\nOutput: {1}'.format(string, list(fltr)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### groupby"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Groups values based on given key. However, All elements to be grouped together must be consecutive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a : [('a', 1), ('a', 2)]\n",
      "b : [('b', 3), ('b', 4)]\n"
     ]
    }
   ],
   "source": [
    "lst = [(\"a\", 1), (\"a\", 2), (\"b\", 3), (\"b\", 4)]\n",
    "for key, group in itertools.groupby(lst, lambda x: x[0]): \n",
    "    print(key + \" :\", list(group)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a : [('a', 1), ('a', 2)]\n",
      "b : [('b', 3), ('b', 4)]\n",
      "a : [('a', 5)]\n"
     ]
    }
   ],
   "source": [
    "lst = [(\"a\", 1), (\"a\", 2), (\"b\", 3), (\"b\", 4), (\"a\", 5)] ## last \"a\" is separate as it is not with other \"a\"\n",
    "for key, group in itertools.groupby(lst, lambda x: x[0]): \n",
    "    print(key + \" :\", list(group)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A : ['A', 'A', 'A', 'A']\n",
      "B : ['B', 'B', 'B']\n",
      "C : ['C', 'C', 'C']\n",
      "D : ['D', 'D', 'D']\n"
     ]
    }
   ],
   "source": [
    "for key, group in itertools.groupby(\"AAAABBBCCCDDD\"): \n",
    "    print(key + \" :\", list(group)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 [1, 1, 1, 1, 1]\n",
      "2 [2, 2, 2]\n",
      "3 [3, 3, 3]\n",
      "4 [4]\n"
     ]
    }
   ],
   "source": [
    "for key, group in itertools.groupby(np.sort([1,2,3,1,3,1,4,3,2,1,2,1])): ## does not work on unsorted list\n",
    "    print(key , list(group)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 [1]\n",
      "2 [2]\n",
      "3 [3]\n",
      "1 [1]\n",
      "3 [3]\n",
      "1 [1]\n",
      "4 [4]\n",
      "3 [3]\n",
      "2 [2]\n",
      "1 [1]\n",
      "2 [2]\n",
      "1 [1]\n"
     ]
    }
   ],
   "source": [
    "for key, group in itertools.groupby([1,2,3,1,3,1,4,3,2,1,2,1]): ## does not work on unsorted list\n",
    "    print(key , list(group))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### islice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns elements based on given slicing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.islice object at 0x10d88b290>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Output: [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4,5,6,7,8,9]\n",
    "slc = itertools.islice(lst, 3)  ## Here 3 is stop position. Therefore, slice would be [:3]\n",
    "print(\"Output from dropwhile: {}\".format(slc))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(slc)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.islice object at 0x10d88b530>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Output: [4, 5]\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4,5,6,7,8,9]\n",
    "slc = itertools.islice(lst, 3, 5)  ## Here 3 is start and 5 is stop. Therefore, slice would be [3:5]\n",
    "print(\"Output from dropwhile: {}\".format(slc))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(slc)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.islice object at 0x10d88b230>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Output: [4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4,5,6,7,8,9]\n",
    "slc = itertools.islice(lst, 3, None)  ## Here 3 is start and None means till last. Therefore, slice would be [3:]\n",
    "print(\"Output from dropwhile: {}\".format(slc))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(slc)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.islice object at 0x10d88b9b0>\n",
      "Input: [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "Output: [4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4,5,6,7,8,9]\n",
    "slc = itertools.islice(lst, 3, None, 2)  ## Here 3 is start, None means till last 2 is step. Therefore, slice would be [3::2]\n",
    "print(\"Output from dropwhile: {}\".format(slc))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(slc)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### permutations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns all possible permutations from an iterable of input size. Default input size = $len(\\lt iterable \\gt)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.permutations object at 0x10d88bdd0>\n",
      "Input: [1, 2, 3, 4]\n",
      "Output: [(1, 2, 3, 4), (1, 2, 4, 3), (1, 3, 2, 4), (1, 3, 4, 2), (1, 4, 2, 3), (1, 4, 3, 2), (2, 1, 3, 4), (2, 1, 4, 3), (2, 3, 1, 4), (2, 3, 4, 1), (2, 4, 1, 3), (2, 4, 3, 1), (3, 1, 2, 4), (3, 1, 4, 2), (3, 2, 1, 4), (3, 2, 4, 1), (3, 4, 1, 2), (3, 4, 2, 1), (4, 1, 2, 3), (4, 1, 3, 2), (4, 2, 1, 3), (4, 2, 3, 1), (4, 3, 1, 2), (4, 3, 2, 1)]\n"
     ]
    }
   ],
   "source": [
    "perm = itertools.permutations(lst)\n",
    "print(\"Output from combinations: {}\".format(perm))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(perm)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.permutations object at 0x10d88bd70>\n",
      "Input: [1, 2, 3, 4]\n",
      "Output: [(1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 3)]\n"
     ]
    }
   ],
   "source": [
    "perm = itertools.permutations(lst, 2)  ## permutations of size 2\n",
    "print(\"Output from combinations: {}\".format(perm))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(perm)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gives cartesian product of input lists or with itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst1 = [1,2,3,4]\n",
    "lst2 = [5,6,7,8]\n",
    "string = \"ABCD\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.product object at 0x1154b9f00>\n",
      "Input1: [1, 2, 3, 4]\n",
      "Input2: [5, 6, 7, 8]\n",
      "Output: [(1, 5), (1, 6), (1, 7), (1, 8), (2, 5), (2, 6), (2, 7), (2, 8), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8)]\n"
     ]
    }
   ],
   "source": [
    "prod = itertools.product(lst1, lst2)  \n",
    "print(\"Output from combinations: {}\".format(prod))\n",
    "print('Input1: {0}\\nInput2: {1}\\nOutput: {2}'.format(lst1, lst2, list(prod)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.product object at 0x1154b2500>\n",
      "Input1: [1, 2, 3, 4]\n",
      "Input2: [5, 6, 7, 8]\n",
      "Input3: ABCD\n",
      "Output: [(1, 5, 'A'), (1, 5, 'B'), (1, 5, 'C'), (1, 5, 'D'), (1, 6, 'A'), (1, 6, 'B'), (1, 6, 'C'), (1, 6, 'D'), (1, 7, 'A'), (1, 7, 'B'), (1, 7, 'C'), (1, 7, 'D'), (1, 8, 'A'), (1, 8, 'B'), (1, 8, 'C'), (1, 8, 'D'), (2, 5, 'A'), (2, 5, 'B'), (2, 5, 'C'), (2, 5, 'D'), (2, 6, 'A'), (2, 6, 'B'), (2, 6, 'C'), (2, 6, 'D'), (2, 7, 'A'), (2, 7, 'B'), (2, 7, 'C'), (2, 7, 'D'), (2, 8, 'A'), (2, 8, 'B'), (2, 8, 'C'), (2, 8, 'D'), (3, 5, 'A'), (3, 5, 'B'), (3, 5, 'C'), (3, 5, 'D'), (3, 6, 'A'), (3, 6, 'B'), (3, 6, 'C'), (3, 6, 'D'), (3, 7, 'A'), (3, 7, 'B'), (3, 7, 'C'), (3, 7, 'D'), (3, 8, 'A'), (3, 8, 'B'), (3, 8, 'C'), (3, 8, 'D'), (4, 5, 'A'), (4, 5, 'B'), (4, 5, 'C'), (4, 5, 'D'), (4, 6, 'A'), (4, 6, 'B'), (4, 6, 'C'), (4, 6, 'D'), (4, 7, 'A'), (4, 7, 'B'), (4, 7, 'C'), (4, 7, 'D'), (4, 8, 'A'), (4, 8, 'B'), (4, 8, 'C'), (4, 8, 'D')]\n"
     ]
    }
   ],
   "source": [
    "prod = itertools.product(lst1, lst2, string)  \n",
    "print(\"Output from combinations: {}\".format(prod))\n",
    "print('Input1: {0}\\nInput2: {1}\\nInput3: {2}\\nOutput: {3}'.format(lst1, lst2, string, list(prod)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.product object at 0x1154b1e10>\n",
      "Input: [1, 2, 3, 4]\n",
      "Output: [(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4)]\n"
     ]
    }
   ],
   "source": [
    "prod = itertools.product(lst1, repeat=2)  ## cartesian product with itself\n",
    "print(\"Output from combinations: {}\".format(prod))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst1, list(prod)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.product object at 0x1154bd280>\n",
      "Input1: [1, 2, 3, 4]\n",
      "Input2: [5, 6, 7, 8]\n",
      "Output: [(1, 5, 1, 5), (1, 5, 1, 6), (1, 5, 1, 7), (1, 5, 1, 8), (1, 5, 2, 5), (1, 5, 2, 6), (1, 5, 2, 7), (1, 5, 2, 8), (1, 5, 3, 5), (1, 5, 3, 6), (1, 5, 3, 7), (1, 5, 3, 8), (1, 5, 4, 5), (1, 5, 4, 6), (1, 5, 4, 7), (1, 5, 4, 8), (1, 6, 1, 5), (1, 6, 1, 6), (1, 6, 1, 7), (1, 6, 1, 8), (1, 6, 2, 5), (1, 6, 2, 6), (1, 6, 2, 7), (1, 6, 2, 8), (1, 6, 3, 5), (1, 6, 3, 6), (1, 6, 3, 7), (1, 6, 3, 8), (1, 6, 4, 5), (1, 6, 4, 6), (1, 6, 4, 7), (1, 6, 4, 8), (1, 7, 1, 5), (1, 7, 1, 6), (1, 7, 1, 7), (1, 7, 1, 8), (1, 7, 2, 5), (1, 7, 2, 6), (1, 7, 2, 7), (1, 7, 2, 8), (1, 7, 3, 5), (1, 7, 3, 6), (1, 7, 3, 7), (1, 7, 3, 8), (1, 7, 4, 5), (1, 7, 4, 6), (1, 7, 4, 7), (1, 7, 4, 8), (1, 8, 1, 5), (1, 8, 1, 6), (1, 8, 1, 7), (1, 8, 1, 8), (1, 8, 2, 5), (1, 8, 2, 6), (1, 8, 2, 7), (1, 8, 2, 8), (1, 8, 3, 5), (1, 8, 3, 6), (1, 8, 3, 7), (1, 8, 3, 8), (1, 8, 4, 5), (1, 8, 4, 6), (1, 8, 4, 7), (1, 8, 4, 8), (2, 5, 1, 5), (2, 5, 1, 6), (2, 5, 1, 7), (2, 5, 1, 8), (2, 5, 2, 5), (2, 5, 2, 6), (2, 5, 2, 7), (2, 5, 2, 8), (2, 5, 3, 5), (2, 5, 3, 6), (2, 5, 3, 7), (2, 5, 3, 8), (2, 5, 4, 5), (2, 5, 4, 6), (2, 5, 4, 7), (2, 5, 4, 8), (2, 6, 1, 5), (2, 6, 1, 6), (2, 6, 1, 7), (2, 6, 1, 8), (2, 6, 2, 5), (2, 6, 2, 6), (2, 6, 2, 7), (2, 6, 2, 8), (2, 6, 3, 5), (2, 6, 3, 6), (2, 6, 3, 7), (2, 6, 3, 8), (2, 6, 4, 5), (2, 6, 4, 6), (2, 6, 4, 7), (2, 6, 4, 8), (2, 7, 1, 5), (2, 7, 1, 6), (2, 7, 1, 7), (2, 7, 1, 8), (2, 7, 2, 5), (2, 7, 2, 6), (2, 7, 2, 7), (2, 7, 2, 8), (2, 7, 3, 5), (2, 7, 3, 6), (2, 7, 3, 7), (2, 7, 3, 8), (2, 7, 4, 5), (2, 7, 4, 6), (2, 7, 4, 7), (2, 7, 4, 8), (2, 8, 1, 5), (2, 8, 1, 6), (2, 8, 1, 7), (2, 8, 1, 8), (2, 8, 2, 5), (2, 8, 2, 6), (2, 8, 2, 7), (2, 8, 2, 8), (2, 8, 3, 5), (2, 8, 3, 6), (2, 8, 3, 7), (2, 8, 3, 8), (2, 8, 4, 5), (2, 8, 4, 6), (2, 8, 4, 7), (2, 8, 4, 8), (3, 5, 1, 5), (3, 5, 1, 6), (3, 5, 1, 7), (3, 5, 1, 8), (3, 5, 2, 5), (3, 5, 2, 6), (3, 5, 2, 7), (3, 5, 2, 8), (3, 5, 3, 5), (3, 5, 3, 6), (3, 5, 3, 7), (3, 5, 3, 8), (3, 5, 4, 5), (3, 5, 4, 6), (3, 5, 4, 7), (3, 5, 4, 8), (3, 6, 1, 5), (3, 6, 1, 6), (3, 6, 1, 7), (3, 6, 1, 8), (3, 6, 2, 5), (3, 6, 2, 6), (3, 6, 2, 7), (3, 6, 2, 8), (3, 6, 3, 5), (3, 6, 3, 6), (3, 6, 3, 7), (3, 6, 3, 8), (3, 6, 4, 5), (3, 6, 4, 6), (3, 6, 4, 7), (3, 6, 4, 8), (3, 7, 1, 5), (3, 7, 1, 6), (3, 7, 1, 7), (3, 7, 1, 8), (3, 7, 2, 5), (3, 7, 2, 6), (3, 7, 2, 7), (3, 7, 2, 8), (3, 7, 3, 5), (3, 7, 3, 6), (3, 7, 3, 7), (3, 7, 3, 8), (3, 7, 4, 5), (3, 7, 4, 6), (3, 7, 4, 7), (3, 7, 4, 8), (3, 8, 1, 5), (3, 8, 1, 6), (3, 8, 1, 7), (3, 8, 1, 8), (3, 8, 2, 5), (3, 8, 2, 6), (3, 8, 2, 7), (3, 8, 2, 8), (3, 8, 3, 5), (3, 8, 3, 6), (3, 8, 3, 7), (3, 8, 3, 8), (3, 8, 4, 5), (3, 8, 4, 6), (3, 8, 4, 7), (3, 8, 4, 8), (4, 5, 1, 5), (4, 5, 1, 6), (4, 5, 1, 7), (4, 5, 1, 8), (4, 5, 2, 5), (4, 5, 2, 6), (4, 5, 2, 7), (4, 5, 2, 8), (4, 5, 3, 5), (4, 5, 3, 6), (4, 5, 3, 7), (4, 5, 3, 8), (4, 5, 4, 5), (4, 5, 4, 6), (4, 5, 4, 7), (4, 5, 4, 8), (4, 6, 1, 5), (4, 6, 1, 6), (4, 6, 1, 7), (4, 6, 1, 8), (4, 6, 2, 5), (4, 6, 2, 6), (4, 6, 2, 7), (4, 6, 2, 8), (4, 6, 3, 5), (4, 6, 3, 6), (4, 6, 3, 7), (4, 6, 3, 8), (4, 6, 4, 5), (4, 6, 4, 6), (4, 6, 4, 7), (4, 6, 4, 8), (4, 7, 1, 5), (4, 7, 1, 6), (4, 7, 1, 7), (4, 7, 1, 8), (4, 7, 2, 5), (4, 7, 2, 6), (4, 7, 2, 7), (4, 7, 2, 8), (4, 7, 3, 5), (4, 7, 3, 6), (4, 7, 3, 7), (4, 7, 3, 8), (4, 7, 4, 5), (4, 7, 4, 6), (4, 7, 4, 7), (4, 7, 4, 8), (4, 8, 1, 5), (4, 8, 1, 6), (4, 8, 1, 7), (4, 8, 1, 8), (4, 8, 2, 5), (4, 8, 2, 6), (4, 8, 2, 7), (4, 8, 2, 8), (4, 8, 3, 5), (4, 8, 3, 6), (4, 8, 3, 7), (4, 8, 3, 8), (4, 8, 4, 5), (4, 8, 4, 6), (4, 8, 4, 7), (4, 8, 4, 8)]\n"
     ]
    }
   ],
   "source": [
    "prod = itertools.product(lst1, lst2, repeat=2)  ## cartesian product with elements repeates twice\n",
    "print(\"Output from combinations: {}\".format(prod))\n",
    "print('Input1: {0}\\nInput2: {1}\\nOutput: {2}'.format(lst1, lst2, list(prod)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### repeat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeats an input object for specified times. If number of repetetions are not mentioned than either it repeats indefinitely or if used with a `map()` or `zip()` than repeats for length of accompanied lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rough implementation\n",
    "```py\n",
    "def repeat(obj, times=None):\n",
    "    if times is None:\n",
    "        while True:\n",
    "            yield obj\n",
    "    else:\n",
    "        for i in range(times):\n",
    "            yield obj\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from repeat: repeat(10, 5)\n",
      "Output: [10, 10, 10, 10, 10]\n"
     ]
    }
   ],
   "source": [
    "rpt = itertools.repeat(10, times=5)\n",
    "print(\"Output from repeat: {}\".format(rpt))\n",
    "print('Output: {}'.format(list(rpt)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from repeat: repeat(<__main__.A object at 0x10d874cd0>, 5)\n",
      "Output: [<__main__.A object at 0x10d874cd0>, <__main__.A object at 0x10d874cd0>, <__main__.A object at 0x10d874cd0>, <__main__.A object at 0x10d874cd0>, <__main__.A object at 0x10d874cd0>]\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    pass\n",
    "\n",
    "a = A()\n",
    "rpt = itertools.repeat(a, times=5)\n",
    "print(\"Output from repeat: {}\".format(rpt))\n",
    "print('Output: {}'.format(list(rpt)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from repeat: <map object at 0x10d874150>\n",
      "List: [1, 2, 3, 4, 5]\n",
      "Output: [11, 12, 13, 14, 15]\n"
     ]
    }
   ],
   "source": [
    "out = map(operator.add, lst, itertools.repeat(10))\n",
    "print(\"Output from repeat: {}\".format(out))\n",
    "print('List: {0}\\nOutput: {1}'.format(lst, list(out)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### starmap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to `map()` but difference being, `starmap()` can take more than one arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Roughly equivalent to\n",
    "```py\n",
    "def starmap(function, arg_list):\n",
    "    for args in arg_list:\n",
    "        yeild function(*args)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [(1,2), (3,4), (5,6), (7,8)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from starmap: <itertools.starmap object at 0x10d865d90>\n",
      "List: [(1, 2), (3, 4), (5, 6), (7, 8)]\n",
      "Output: [3, 7, 11, 15]\n"
     ]
    }
   ],
   "source": [
    "strmap = itertools.starmap(lambda x, y: x+y, lst)\n",
    "print(\"Output from starmap: {}\".format(strmap))\n",
    "print('List: {0}\\nOutput: {1}'.format(lst, list(strmap)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### takewhile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns elements of iterable only till predicate is <i>TRUE</i>. Stops as soon as first <i>FASLE</i> is encountered. Inverse of `dropwhile()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.takewhile object at 0x1154b35a0>\n",
      "Input: [1, 3, 2, 4, 6, 2, 1, 3, 5]\n",
      "Output: [1, 3, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "lst = [1,3,2,4,6,2,1,3,5]\n",
    "take = itertools.takewhile(lambda x: x<5, lst)\n",
    "print(\"Output from dropwhile: {}\".format(take))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(take)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can be used to get negetive numbers from a sorted list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.takewhile object at 0x10d87bf00>\n",
      "Input: [-8, -2, -3, -1, 0, 1, 3, 5, 7]\n",
      "Output: [-8, -2, -3, -1]\n"
     ]
    }
   ],
   "source": [
    "lst = [-8,-2,-3,-1,0,1,3,5,7]\n",
    "take = itertools.takewhile(lambda x: x<0, lst)\n",
    "print(\"Output from dropwhile: {}\".format(take))\n",
    "print('Input: {0}\\nOutput: {1}'.format(lst, list(take)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can be used to get substring from a string till a character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from dropwhile: <itertools.takewhile object at 0x10c13a6e0>\n",
      "Old string: Hello,World\n",
      "New string: Hello\n"
     ]
    }
   ],
   "source": [
    "def match_char(s, match_char):\n",
    "    return s != match_char\n",
    "\n",
    "string = \"Hello,World\"\n",
    "char = \",\"\n",
    "take = itertools.takewhile(lambda s: match_char(s, char), string)\n",
    "new_string = \"\".join(take).rstrip(char)\n",
    "print(\"Output from dropwhile: {}\".format(take))\n",
    "print('Old string: {0}\\nNew string: {1}'.format(string, new_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tee"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns specified numbers of replication of given iterable. All of the returned iterable are independent of each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output od tee are: <itertools._tee object at 0x10d872cd0> and <itertools._tee object at 0x10d872410>\n",
      "Output1: [1, 2, 3, 4, 5]\n",
      "Output2: [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "it1, it2 = itertools.tee(lst)\n",
    "print(\"Output od tee are: {0} and {1}\".format(it1, it2))\n",
    "print(\"Output1: {0}\\nOutput2: {1}\".format(list(it1), list(it2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can seen for output of above command that both of these iterators have difference addresses in memory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zip_longest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same as to `zip()` but difference being that `zip_longest()` can zip iterables of unequal length. Missing values of the shorter iterables are replaced by <i>fillvalue</i> argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst1 = [1,2,3,4,5,6]\n",
    "lst2 = [7,8,9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.zip_longest object at 0x1154c3a10>\n",
      "Input1: [1, 2, 3, 4, 5, 6]\n",
      "Input2: [7, 8, 9]\n",
      "Output: [(1, 7), (2, 8), (3, 9), (4, None), (5, None), (6, None)]\n"
     ]
    }
   ],
   "source": [
    "zip_long = itertools.zip_longest(lst1, lst2)  ## Default fillvalue=None\n",
    "print(\"Output from combinations: {}\".format(zip_long))\n",
    "print('Input1: {0}\\nInput2: {1}\\nOutput: {2}'.format(lst1, lst2, list(zip_long)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.zip_longest object at 0x1154c3c50>\n",
      "Input1: [1, 2, 3, 4, 5, 6]\n",
      "Input2: [7, 8, 9]\n",
      "Output: [(1, 7), (2, 8), (3, 9), (4, '-'), (5, '-'), (6, '-')]\n"
     ]
    }
   ],
   "source": [
    "zip_long = itertools.zip_longest(lst1, lst2, fillvalue='-')\n",
    "print(\"Output from combinations: {}\".format(zip_long))\n",
    "print('Input1: {0}\\nInput2: {1}\\nOutput: {2}'.format(lst1, lst2, list(zip_long)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output from combinations: <itertools.zip_longest object at 0x1154c3e90>\n",
      "Input1: [1, 2, 3, 4, 5, 6]\n",
      "Input2: [7, 8, 9]\n",
      "Output: [('A', 'E'), ('B', 'F'), ('C', 0), ('D', 0)]\n"
     ]
    }
   ],
   "source": [
    "zip_long = itertools.zip_longest(\"ABCD\", \"EF\", fillvalue=0)\n",
    "print(\"Output from combinations: {}\".format(zip_long))\n",
    "print('Input1: {0}\\nInput2: {1}\\nOutput: {2}'.format(lst1, lst2, list(zip_long)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}