advanced-python/07-Itertools.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Itertools\n",
    "\n",
    "The Python itertools module is a collection of tools for handling iterators. Simply put, iterators are data types that can be used in a for loop. The most common iterator in Python is the list.\n",
    "\n",
    "See https://docs.python.org/3/library/itertools.html for all possible itertools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## product()\n",
    "This tool computes the cartesian product of input iterables.  \n",
    "It is equivalent to nested for-loops. For example, *product(A, B)* returns the same as *((x,y) for x in A for y in B)*. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 3), (1, 4), (2, 3), (2, 4)]\n",
      "[(1, 3, 1, 3), (1, 3, 2, 3), (2, 3, 1, 3), (2, 3, 2, 3)]\n"
     ]
    }
   ],
   "source": [
    "from itertools import product\n",
    "\n",
    "prod = product([1, 2], [3, 4])\n",
    "print(list(prod)) # note that we convert the iterator to a list for printing\n",
    "\n",
    "# to allow the product of an iterable with itself, specify the number of repetitions \n",
    "prod = product([1, 2], [3], repeat=2)\n",
    "print(list(prod)) # note that we convert the iterator to a list for printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## permutations()\n",
    "This tool returns successive length permutations of elements in an iterable, with all possible orderings, and no repeated elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]\n",
      "[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]\n"
     ]
    }
   ],
   "source": [
    "from itertools import permutations\n",
    "\n",
    "perm = permutations([1, 2, 3])\n",
    "print(list(perm))\n",
    "\n",
    "# optional: the length of the permutation tuples\n",
    "perm = permutations([1, 2, 3], 2)\n",
    "print(list(perm))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## combinations() and combinations_with_replacement()\n",
    "\n",
    "r-length tuples, in sorted order. So, if the input iterable is sorted, the combination tuples will be produced in sorted order. *combinations()* does not allow repeated elements, but *combinations_with_replacement()* does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]\n",
      "[(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]\n"
     ]
    }
   ],
   "source": [
    "from itertools import combinations, combinations_with_replacement\n",
    "\n",
    "# the second argument is mandatory and specifies the length of the output tuples.\n",
    "comb = combinations([1, 2, 3, 4], 2)\n",
    "print(list(comb))\n",
    "\n",
    "comb = combinations_with_replacement([1, 2, 3, 4], 2)\n",
    "print(list(comb))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## accumulate()\n",
    "Make an iterator that returns accumulated sums, or accumulated results of other binary functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 6, 10]\n",
      "[1, 2, 6, 24]\n",
      "[1, 5, 5, 6, 6, 6]\n"
     ]
    }
   ],
   "source": [
    "from itertools import accumulate\n",
    "\n",
    "# return accumulated sums\n",
    "acc = accumulate([1,2,3,4])\n",
    "print(list(acc))\n",
    "\n",
    "# other possible functions are possible\n",
    "import operator\n",
    "acc = accumulate([1,2,3,4], func=operator.mul)\n",
    "print(list(acc))\n",
    "\n",
    "acc = accumulate([1,5,2,6,3,4], func=max)\n",
    "print(list(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## groupby()\n",
    "Make an iterator that returns consecutive keys and groups from the iterable. The key is a function computing a key value for each element. If not specified or is None, key defaults to an identity function and returns the element unchanged. Generally, the iterable needs to already be sorted on the same key function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True [1, 2]\n",
      "False [3, 4]\n",
      "True ['hi', 'nice']\n",
      "False ['hello', 'cool']\n",
      "25 [{'name': 'Tim', 'age': 25}, {'name': 'Dan', 'age': 25}]\n",
      "27 [{'name': 'Lisa', 'age': 27}]\n",
      "28 [{'name': 'Claire', 'age': 28}]\n"
     ]
    }
   ],
   "source": [
    "from itertools import groupby\n",
    "\n",
    "# use a function as key\n",
    "def smaller_than_3(x):\n",
    "    return x < 3\n",
    "\n",
    "group_obj = groupby([1, 2, 3, 4], key=smaller_than_3)\n",
    "for key, group in group_obj:\n",
    "    print(key, list(group))\n",
    "    \n",
    "# or use a lamda expression, e.g. words with an 'i':\n",
    "group_obj = groupby([\"hi\", \"nice\", \"hello\", \"cool\"], key=lambda x: \"i\" in x)\n",
    "for key, group in group_obj:\n",
    "    print(key, list(group))\n",
    "    \n",
    "persons = [{'name': 'Tim', 'age': 25}, {'name': 'Dan', 'age': 25}, \n",
    "           {'name': 'Lisa', 'age': 27}, {'name': 'Claire', 'age': 28}]\n",
    "\n",
    "for key, group in groupby(persons, key=lambda x: x['age']):\n",
    "    print(key, list(group))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Infinite iterators: count(), cycle(), repeat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "\n",
      "1\n",
      "2\n",
      "3\n",
      "1\n",
      "2\n",
      "3\n",
      "\n",
      "A\n",
      "A\n",
      "A\n"
     ]
    }
   ],
   "source": [
    "from itertools import count, cycle, repeat\n",
    "# count(x): count from x: x, x+1, x+2, x+3...\n",
    "for i in count(10):\n",
    "    print(i)\n",
    "    if  i >= 13:\n",
    "        break\n",
    "\n",
    "# cycle(iterable) : cycle infinitely through an iterable\n",
    "print(\"\")\n",
    "sum = 0\n",
    "for i in cycle([1, 2, 3]):\n",
    "    print(i)\n",
    "    sum += i\n",
    "    if sum >= 12:\n",
    "        break\n",
    "\n",
    "# repeat(x): repeat x infinitely or n times\n",
    "print(\"\")\n",
    "for i in repeat(\"A\", 3):\n",
    "    print(i)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:pythonengineer_env]",
   "language": "python",
   "name": "conda-env-pythonengineer_env-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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}