session4_oop.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\n",
       "\n",
       "<style>\n",
       "\n",
       ".container {\n",
       "    width: 95% !important;\n",
       "}\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: #888;\n",
       "    color: #f6f6f6;\n",
       "}\n",
       "\n",
       "div.cell { /* set cell width to about 80 chars */\n",
       "    width: 1275px;\n",
       "}\n",
       "\n",
       "div #notebook { /* centre the content */\n",
       "    background: #fff; /* white background for content */\n",
       "    width: 1400px;\n",
       "    margin: auto;\n",
       "    padding-left: 1em;\n",
       "    padding-right: 1em;\n",
       "}\n",
       "\n",
       "#notebook li { /* More space between bullet points */\n",
       "margin-top:0.8em;\n",
       "}\n",
       "\n",
       "/* draw border around running cells */\n",
       "div.cell.border-box-sizing.code_cell.running { \n",
       "    border: 3px solid #111;\n",
       "}\n",
       "\n",
       "/* Put a solid color box around each cell and its output, visually linking them together */\n",
       "div.cell.code_cell {\n",
       "    background-color: #f4f3e0; \n",
       "    border-radius: 10px; /* rounded borders */\n",
       "    padding: 1em;\n",
       "    margin-top: 1em;\n",
       "}\n",
       "\n",
       "div.text_cell_render{\n",
       "    font-family: 'Arvo' sans-serif;\n",
       "    line-height: 130%;\n",
       "    font-size: 125%;\n",
       "    width:1100px;\n",
       "    margin-left: 0em;\n",
       "    margin-right: auto;\n",
       "}\n",
       "\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Philosopher', sans-serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 32pt;\n",
       "    line-height: 100%;\n",
       "    color: rgb(12,85,97);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    font-weight: 700;\n",
       "    font-size: 24pt;\n",
       "    line-height: 100%;\n",
       "    color: rgb(95,92,72);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    margin-top:12px;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: italic;\n",
       "    color: rgb(95,92,72);\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {\n",
       "    font-family: 'Alegreya Sans', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 16pt;\n",
       "    color: grey;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 {\n",
       "    font-family: 'PT Mono', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 10pt;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "    font-family: \"PT Mono\";\n",
       "    font-size: 110%;\n",
       "}\n",
       "\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "css_file = './stylesheets/custom.css'\n",
    "HTML(open(css_file, \"r\").read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<div><img src=\"https://github.com/ACM-SIAM-KAUST-chapter/python_tutorial_2017/blob/gh-pages/images/acmchapterlogo.png?raw=true\" width=\"260px\" style=\"float: left;\">\n",
    "<img src=\"https://github.com/ACM-SIAM-KAUST-chapter/python_tutorial_2017/blob/gh-pages/images/siamchapterlogo.png?raw=true\" width=\"260px\" style=\"float: right;\"></div>\n",
    "<h1 align=\"center\">Advanced Techniques in Python:</h1>\n",
    "<h1 align=\"center\">Classes, Objects, Functions, Memory</h1>\n",
    "\n",
    "<p><br style=\"clear: both;\"/></p><p><br style=\"clear: both;\"/></p><p><br style=\"clear: both;\"/></p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<div style=\"color:#999\">\n",
    "This tutorial is prepared by ACM/SIAM Student Chapter of King Abdullah University of Science and Technology (KAUST).\n",
    "It is adapted from a <a url=\"http://nbviewer.jupyter.org/github/mar-one/ACM-Python-Tutorials-KAUST-2015/blob/master/advanced/advanced_part1.ipynbnotebook\">notebook</a> by Maruan Al-Shedivat.\n",
    "\n",
    "<br/><br/>\n",
    "It includes some advanced topics and techniques frequently used in Python.\n",
    "<br/>\n",
    "\n",
    "The topics covered in this part are:\n",
    "<ul>\n",
    "    <li>Classes, objects, and methods. OOP in Python.\n",
    "    <li>Advanced techneques in objects and functions manipulation.\n",
    "    <li>Modules and their structure. How to develop a Python module.\n",
    "    <li>Python memory management.\n",
    "    <li>The Pythonic way: Tips & Tricks.\n",
    "</ul>\n",
    "<br/>\n",
    "\n",
    "Presented on 28 February, 2017 by Maxat Kulmanov.\n",
    "<br/><br/>\n",
    "\n",
    "**Prerequisites:** *Basic ACM Python tutorial and/or some experience in Python and programming in general.*\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 1. Object-oriented programming in Python\n",
    "Python is general purpose programming language and supports multiple paradigms. Object-oriented programming (OOP) manipulate collections of objects. Objects have internal states and methods to change or query its state in some way.\n",
    "Concepts of OOP:\n",
    "* Class - Prototype for the object which defines set of attributes (instance variables and class variables) and methods of any object of the class.\n",
    "* Object - A unique instance of the class\n",
    "* Inheritance - Acquiring properties and methods of the parent class\n",
    "* Abstraction - Hiding internal details and showing only the functionality. For example, phone call, we don't know how it is done.\n",
    "* Encapsulation - Hiding variables and methods from outside world.\n",
    "* Polymorphism - Using a function or operator in different ways depending on data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'int'>\n",
      "<type 'str'>\n",
      "<type 'list'>\n",
      "<type 'dict'>\n",
      "<type 'tuple'>\n",
      "<type 'type'>\n",
      "<type 'function'>\n",
      "<type 'module'>\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "def function():\n",
    "    pass\n",
    "\n",
    "print(type(1))\n",
    "print(type(\"\"))\n",
    "print(type([]))\n",
    "print(type({}))\n",
    "print(type(()))\n",
    "print(type(object))\n",
    "print(type(function))\n",
    "print(type(sys))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 1.1. Classes and Objects\n",
    "Let's create an example class `Person` and add a couple of fields and methods to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'type'>\n",
      "<class '__main__.Person'>\n",
      "John Ossietzky\n",
      "Mike\n",
      "Hi, I am John Ossietzky\n",
      "John Ossietzky\n"
     ]
    }
   ],
   "source": [
    "class Person(object):\n",
    "    first_name = \"\"\n",
    "    \n",
    "    \n",
    "    def __init__(self, *args, **kwargs):\n",
    "        self.first_name = args[0]\n",
    "        if len(args) > 1:\n",
    "            self.second_name = args[1]\n",
    "        else:\n",
    "            self.second_name = None\n",
    "        \n",
    "        \n",
    "    def __repr__(self):\n",
    "        return self.get_name()\n",
    "    \n",
    "#     def __str__(self):\n",
    "#         return self.get_name()\n",
    "        \n",
    "        \n",
    "    def get_name(self):\n",
    "        if hasattr(self, 'second_name') and self.second_name:\n",
    "            return self.first_name + ' ' + self.second_name\n",
    "        return self.first_name\n",
    "    \n",
    "    def say_hi(self):\n",
    "        print ('Hi, I am ' + self.get_name())\n",
    "    \n",
    "print(type(Person))\n",
    "\n",
    "p1 = Person('John', 'Ossietzky')\n",
    "p2 = Person('Mike')\n",
    "\n",
    "print(type(p1))\n",
    "\n",
    "# print(p1.__first_name)\n",
    "print(p1.get_name())\n",
    "print(p2.get_name())\n",
    "p1.say_hi()\n",
    "print(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 1.2 Inheritance\n",
    "Now, let's create a small hierarchy of classes with a base class `Person`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joshua works at KAUST\n",
      "Michael Koncz studies Computer Science\n"
     ]
    }
   ],
   "source": [
    "class Employee(Person):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super(Employee, self).__init__(*args, **kwargs)\n",
    "        if 'employer' in kwargs:\n",
    "            self.employer = kwargs.pop('employer')\n",
    "        else:\n",
    "            raise Exception(\"employer field is required!\")\n",
    "    \n",
    "    def get_employer(self):\n",
    "        return self.employer\n",
    "\n",
    "e = Employee('Joshua', employer='KAUST')\n",
    "print('%s works at %s' % (e.get_name(), e.get_employer()))\n",
    "\n",
    "class Student(Person):\n",
    "    \n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super(Student, self).__init__(*args, **kwargs)\n",
    "        self.major = kwargs.pop('major', None)\n",
    "    \n",
    "    def get_major(self):\n",
    "        return self.major\n",
    "\n",
    "s = Student('Michael', 'Koncz', major='Computer Science')\n",
    "print(s.get_name() + ' studies ' + s.get_major())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Exercise:\n",
    "\n",
    "\n",
    "- Modify class `Student` to have an optional field `school`.\n",
    "- Create a class `PhDStudent` with base class - `Student`.\n",
    "\n",
    "You can extend the above cells or use the below cell for your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Liam', 'Computational Biology', 'KAUST')\n"
     ]
    }
   ],
   "source": [
    "class PhDStudent(Student, Employee):\n",
    "    \n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super(PhDStudent, self).__init__(*args, **kwargs)\n",
    "        \n",
    "        \n",
    "\n",
    "s1 = PhDStudent('Liam', major='Computational Biology', employer='KAUST')\n",
    "print(s1.get_name(), s1.get_major(), s1.get_employer())\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 1.3 Polymorphism\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Destroyed person Yerzhan\n",
      "Hi, I am Yerzhan\n",
      "I am a manager\n",
      "Hi, my name is Andrew\n",
      "I am a specialist\n"
     ]
    }
   ],
   "source": [
    "class Manager(Employee):\n",
    "    \n",
    "    def say_hi(self):\n",
    "        super(Employee, self).say_hi()\n",
    "        print('I am a manager')\n",
    "        \n",
    "class Specialist(Employee):\n",
    "    \n",
    "    def say_hi(self):\n",
    "        print('Hi, my name is ' + self.get_name())\n",
    "        print('I am a specialist')\n",
    "\n",
    "m = Manager('Yerzhan', 'KAUST')\n",
    "s = Specialist('Andrew', 'KAUST')\n",
    "m.say_hi()\n",
    "s.say_hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Exercise:\n",
    "- Override say_hi method of classes Student and Employee\n",
    "- Call say_hi method of parent class in child class using keyword `super` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 1.4 Class variables\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3 3 3\n",
      "2 2\n"
     ]
    }
   ],
   "source": [
    "class Organization(object):\n",
    "    \n",
    "    count = 0 # Class variable, shared among all objects\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        Organization.count += 1\n",
    "    \n",
    "    def __del__(self):\n",
    "        Organization.count -= 1\n",
    "\n",
    "org1 = Organization('KAUST')\n",
    "org2 = Organization('KAEC')\n",
    "\n",
    "print(org1.count)\n",
    "org3 = Organization('ARAMCO')\n",
    "\n",
    "print(org1.count, org2.count, org3.count)\n",
    "del org1\n",
    "print(org2.count, Organization.count)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 1.5 Extending existing Python types\n",
    "Often, it is very useful to extend existing types and classes when an additional feature is needed. For this section, let's try to extend `dict` into a class `Graph`. But before this let's have a closer look at how the basic types/classes in python are organized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Check the type of class dict\n",
    "type(dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# List all the methods, fields and properties dict class has\n",
    "dir(dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# An example of 'magic' method with two underscores\n",
    "dict.__getitem__?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**NOTE:** A well written and more detailed guide on so called Python \"magic methods\" (with double underscores) you can find [here](http://www.rafekettler.com/magicmethods.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Now, knowing that `dict` is basically a class, we can build another class `Graph` and use dict as the base class. Our `Graph` will have the following structure: each key-element will be a node, each value element will be a `list` of the adjacent nodes. Graph will be initialized with a list of edges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "class Graph(dict):\n",
    "    \"\"\"Graph class, extends dict\"\"\"\n",
    "    \n",
    "    def __init__(self, edges):\n",
    "        \"\"\"Initialize graph with a list of 2-tuples. Each tuple is a directed edge.\"\"\"\n",
    "        for u, v in edges:\n",
    "            if u not in self:\n",
    "                self[u] = []\n",
    "            self[u].append(v)\n",
    "            # instead of try-except you can use: self[u] = self.get(u,[]) + [v]\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"Returns a Graph representation. Called by 'print' for any object we would like to print.\"\"\"\n",
    "        representation = '\\n'.join([\"%i -> [%s]\" % (u, ','.join([str(v) for v in V]))\n",
    "                                    for u, V in self.items()])\n",
    "        return representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 -> [2,3]\n",
      "2 -> [3]\n"
     ]
    }
   ],
   "source": [
    "g = Graph([(1,2), (2,3), (1,3)])\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Exercise:\n",
    "Build an extention for dict called \"SortedDict\". Whenever you print an instance of such `dict`, print it sorted by keys in the ascending order. For the test use the `dict` below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{24: 'Work', 2009: 'KAUST', 100: 'Hi', 7: 'Week'}\n"
     ]
    }
   ],
   "source": [
    "d = {100: \"Hi\", 7:\"Week\", 24:\"Work\", 2009:\"KAUST\"}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3:Work\n",
      "5:HI\n",
      "23:KAUST\n",
      "100:Hello\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class SortedDict(dict):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super(dict, self).__init__()\n",
    "    \n",
    "    def __str__(self):\n",
    "        keys = sorted(self.keys())\n",
    "        ret = ''\n",
    "        for key in keys:\n",
    "            ret += str(key) + ':' + str(self[key]) + '\\n'\n",
    "        return ret\n",
    "        \n",
    "\n",
    "\n",
    "sd = SortedDict()\n",
    "sd[3] = 'Work'\n",
    "sd[23] = 'KAUST'\n",
    "sd[5] = 'HI'\n",
    "sd[100] = 'Hello'\n",
    "\n",
    "print(sd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 1.6 Functions are also classes, and we can play with them the same way!\n",
    "As we mentioned, everything in Python is an object. Even a function. Let's check it out and see how we can exploit this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "dir(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Check the help for the __call__ method\n",
    "len.__call__?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Now, since functions are objects, we can use them as objects, e.g., as another funciton arguments. Consider the following example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Apply function example\n",
    "def apply(data, func):\n",
    "    \"\"\"Loop through the data and apply the provided function.\"\"\"\n",
    "    return [func(d) for d in data]\n",
    "\n",
    "apply([1, -1, 2, 10, 100, -404], str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Bind function example\n",
    "def bind(func, **kwargs):\n",
    "    def bfunc(*args):\n",
    "        return func(*args, **kwargs)\n",
    "    return bfunc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "As a quick example, let's make function `sorted` sort the provided iterable object in the reverse order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "sorted([1, -1, 2, 10, 100, -404])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "sorted?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "rev_sorted = bind(sorted, reverse=True)\n",
    "rev_sorted([1, -1, 2, 10, 100, -404])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The last pattern when we have a function generates a function based on the provided one is unltimately frequent and very useful. Let's consider an example, and firts write a simple Fibonacci sequence generator function.\n",
    "\n",
    "*(FYI: Fibonacci recurrent numerical sequence is defined as follows: F(n) = F(n-1) + F(n-2), F(0) = 0, F(1) = 1)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def Fib(n):\n",
    "    \"\"\"Return the n-th Fibonacci number.\"\"\"\n",
    "    assert type(n) is int and n >= 0, \"ERROR (Fib): index should be positive and integer!\"\n",
    "    return Fib(n-1) + Fib(n-2) if n > 1 else 1 if n is 1 else 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "[Fib(i) for i in range(15)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Fibonacci function is recurrent. Moreover, for every input n, it should compute values for all the previous indices. Is this efficient? Of course not. Let's make it more efficient, hacking the \\_\\_call\\_\\_ method and adding some caching. We will make it using decorators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import collections\n",
    "\n",
    "def memoize(func):\n",
    "    \"\"\"A caching decorator. Checks and returns a cached value before applying the function itself.\"\"\"\n",
    "    cache = {}\n",
    "    def cachedFunc(*args):\n",
    "        if args not in cache:\n",
    "            print(\"Cache miss!\")\n",
    "            cache[args] = func(*args)\n",
    "        return cache[args]\n",
    "    return cachedFunc\n",
    "\n",
    "@memoize\n",
    "def Fib(n):\n",
    "    \"\"\"Return the n-th Fibonacci number.\"\"\"\n",
    "    assert type(n) is int and n >= 0, \"ERROR (Fib): index should be positive and integer!\"\n",
    "    return Fib(n-1) + Fib(n-2) if n > 1 else 1 if n is 1 else 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "[Fib(i) for i in range(16)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Exercise:\n",
    "Implement a decorator that will trace Fibonacci function calls. Whenever the Fib function called, print it and its arguments. If it is called recurrently, maintain the indent: each subsequent recurrent call should be indented with two more spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**NOTE:** You can find a lot of useful decorators along with their design patterns in [this library](https://wiki.python.org/moin/PythonDecoratorLibrary)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 2. What are modules in Python? How to develop your own?\n",
    "If you used Python even for a bit, you most probably noticed that the real power of the language is in its modules and packages which you can import into your script and use the code you or somebody else developed and tested before. But how to write your own package? Right, it is simple... because modules are also objects!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "The simplest way is just create a file, say `mymodule.py`, put some functions and classes you implemented in it, and finally write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "%%file mymodule.py\n",
    "\"\"\"\n",
    "Example of a python module. Contains a variable called my_variable,\n",
    "a function called my_function, and a class called MyClass.\n",
    "\"\"\"\n",
    "\n",
    "my_variable = 0\n",
    "\n",
    "def my_function():\n",
    "    \"\"\"\n",
    "    Example function\n",
    "    \"\"\"\n",
    "    return my_variable\n",
    "    \n",
    "class MyClass:\n",
    "    \"\"\"\n",
    "    Example class.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        self.variable = my_variable\n",
    "        \n",
    "    def set_variable(self, new_value):\n",
    "        \"\"\"\n",
    "        Set self.variable to a new value\n",
    "        \"\"\"\n",
    "        self.variable = new_value\n",
    "        \n",
    "    def get_variable(self):\n",
    "        return self.variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'classobj'>\n"
     ]
    }
   ],
   "source": [
    "import mymodule\n",
    "print(type(mymodule.MyClass))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "or something like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from mymodule import my_function\n",
    "\n",
    "my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Now, if you would like to build something BIG, say a whole package for sound processing, you would probably prefer not putting everything in a mess into a single file, but rather you would prefer splitting everything logically into separate files or even folders. Then, your structure should look like this: (*Example is taken from the Python [documentation page](http://docs.python.org/2/tutorial/modules.html#packages)*)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "sound/                          Top-level package\n",
    "      __init__.py               Initialize the sound package\n",
    "      formats/                  Subpackage for file format conversions\n",
    "              __init__.py\n",
    "              wavread.py\n",
    "              wavwrite.py\n",
    "              aiffread.py\n",
    "              aiffwrite.py\n",
    "              auread.py\n",
    "              auwrite.py\n",
    "              ...\n",
    "      effects/                  Subpackage for sound effects\n",
    "              __init__.py\n",
    "              echo.py\n",
    "              surround.py\n",
    "              reverse.py\n",
    "              ...\n",
    "      filters/                  Subpackage for filters\n",
    "              __init__.py\n",
    "              equalizer.py\n",
    "              vocoder.py\n",
    "              karaoke.py\n",
    "              ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Note the `__init__.py` files. They might be just empty (in most of the packages they are), but if you need to do some additional stuff at the moment of importing module (say, you want to print your module's version information and a license), you should do this exactly in the appropriate `__init__.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Also note the subfolders you might have with submodules. Large packages with large libraries use exactly this kind of structure which allows programmers import only the submodules they are interested in working with. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import numpy.polynomial.polynomial as poly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's have a look at a more concrete example (*taken from [Johansson's Python lectures](https://github.com/jrjohansson/scientific-python-lectures)*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import mymodule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module mymodule:\n",
      "\n",
      "NAME\n",
      "    mymodule\n",
      "\n",
      "FILE\n",
      "    /Users/kulmanm/KAUST/ACM/python_tutorial_2017/mymodule.py\n",
      "\n",
      "DESCRIPTION\n",
      "    Example of a python module. Contains a variable called my_variable,\n",
      "    a function called my_function, and a class called MyClass.\n",
      "\n",
      "CLASSES\n",
      "    MyClass\n",
      "    \n",
      "    class MyClass\n",
      "     |  Example class.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self)\n",
      "     |  \n",
      "     |  get_variable(self)\n",
      "     |  \n",
      "     |  set_variable(self, new_value)\n",
      "     |      Set self.variable to a new value\n",
      "\n",
      "FUNCTIONS\n",
      "    my_function()\n",
      "        Example function\n",
      "\n",
      "DATA\n",
      "    my_variable = 0\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(mymodule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mymodule.my_variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function mymodule.my_function>"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mymodule.my_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_class = mymodule.MyClass() \n",
    "my_class.set_variable(10)\n",
    "my_class.get_variable()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 3. Memory management in Python\n",
    "In this section we shed some light on how the memory is actually managed by Python, show you important-to-know techniques that will help you build efficient code and avoid common mistakes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 3.1. Size of objects in Python\n",
    "First, we should get a good feeling of what the actual sizes of objects in Pyhton are, and how the sizes grow whenever we create lists/dictionaries/tuples out of some number of objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# This script computes the memory footprint of an object and its components\n",
    "# (source: https://code.activestate.com/recipes/577504/)\n",
    "\n",
    "from __future__ import print_function\n",
    "from sys import getsizeof\n",
    "from itertools import chain\n",
    "from collections import deque\n",
    "try:\n",
    "    from reprlib import repr\n",
    "except ImportError:\n",
    "    pass\n",
    "\n",
    "def total_size(o, handlers={}, verbose=True):\n",
    "    \"\"\" Returns the approximate memory footprint an object and all of its contents.\n",
    "\n",
    "    Automatically finds the contents of the following builtin containers and\n",
    "    their subclasses:  tuple, list, deque, dict, set and frozenset.\n",
    "    To search other containers, add handlers to iterate over their contents:\n",
    "\n",
    "        handlers = {SomeContainerClass: iter,\n",
    "                    OtherContainerClass: OtherContainerClass.get_elements}\n",
    "\n",
    "    \"\"\"\n",
    "    dict_handler = lambda d: chain.from_iterable(d.items())\n",
    "    all_handlers = {tuple: iter,\n",
    "                    list: iter,\n",
    "                    deque: iter,\n",
    "                    dict: dict_handler,\n",
    "                    set: iter,\n",
    "                    frozenset: iter,\n",
    "                   }\n",
    "    all_handlers.update(handlers)     # user handlers take precedence\n",
    "    seen = set()                      # track which object id's have already been seen\n",
    "    default_size = getsizeof(0)       # estimate sizeof object without __sizeof__\n",
    "\n",
    "    def sizeof(o):\n",
    "        if id(o) in seen:       # do not double count the same object\n",
    "            return 0\n",
    "        seen.add(id(o))\n",
    "        s = getsizeof(o, default_size)\n",
    "\n",
    "        if verbose:\n",
    "            print(s, type(o), repr(o))\n",
    "\n",
    "        for typ, handler in all_handlers.items():\n",
    "            if isinstance(o, typ):\n",
    "                s += sum(map(sizeof, handler(o)))\n",
    "                break\n",
    "        return s\n",
    "\n",
    "    return sizeof(o)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "sys.getsizeof?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16 <type 'NoneType'> None\n",
      "24 <type 'int'> 1\n",
      "92 <type 'long'> 3273390607896141870013189696827599152216642046043064789483291368096133796404674554883270092325904157150886684127560071009217256545885393053328527589376L\n",
      "24 <type 'float'> 0.5\n",
      "37 <type 'str'> ''\n",
      "41 <type 'str'> 'Test'\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "41"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lets check sizes of different objects (sizes are indicated for 64-bit Python)\n",
    "total_size(None)    # 16 bytes for None\n",
    "total_size(1)       # 24 bytes for 64-bit int - 3 time the size of int64_t in C\n",
    "total_size(2**500)  # 92 bytes for 64-bit Python's long with unconstrained length\n",
    "total_size(0.5)     # 24 bytes for 64-bit double\n",
    "total_size(\"\")      # 49 bytes for empty string\n",
    "total_size(\"Test\")  # 53 for not empty string (+1 byte per character)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "96 <type 'list'> [4, 'toaster', 230.1]\n",
      "24 <type 'int'> 4\n",
      "44 <type 'str'> 'toaster'\n",
      "24 <type 'float'> 230.1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "188"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_size([4, \"toaster\", 230.1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Python lists are actually [dynamic arrays](http://en.wikipedia.org/wiki/Dynamic_array)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "72 <type 'list'> []\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_size([]) # 72 bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "96 <type 'list'> [40, 'toaster', 230.1]\n",
      "24 <type 'int'> 40\n",
      "44 <type 'str'> 'toaster'\n",
      "24 <type 'float'> 230.1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "188"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_size([40, \"toaster\", 230.1])  # 188 bytes.\n",
    "# The capacity of this list is 64; +8 bytes per each element in the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "All of these details seem to be minor, unless you start building large-scale applications, or process huge amounts of data for your projects. So, keep this in mind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "280 <type 'dict'> {'a': 1, 'c': 3, 'b': 2, 'e': 'a string of chars', 'd': [4, 5, 6, 7]}\n",
      "38 <type 'str'> 'a'\n",
      "24 <type 'int'> 1\n",
      "38 <type 'str'> 'c'\n",
      "24 <type 'int'> 3\n",
      "38 <type 'str'> 'b'\n",
      "24 <type 'int'> 2\n",
      "38 <type 'str'> 'e'\n",
      "54 <type 'str'> 'a string of chars'\n",
      "38 <type 'str'> 'd'\n",
      "104 <type 'list'> [4, 5, 6, 7]\n",
      "24 <type 'int'> 4\n",
      "24 <type 'int'> 5\n",
      "24 <type 'int'> 6\n",
      "24 <type 'int'> 7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "796"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_size(dict(a=1, b=2, c=3, d=[4,5,6,7], e='a string of chars'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### 3.2. Python internal memory management\n",
    "Here we just briefly discuss a pretty wasteful approach to manage memory allocation employed in Python. For thorough description and possible solutions you can refer to http://www.evanjones.ca/memoryallocator/."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can run a small experiment using [memory profiler](https://github.com/fabianp/memory_profiler) utitlity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting memory-profile-me.py\n"
     ]
    }
   ],
   "source": [
    "%%file memory-profile-me.py\n",
    "\n",
    "import copy\n",
    "from memory_profiler import profile\n",
    "\n",
    "@profile\n",
    "def function():\n",
    "    x = [0.0] * 1000000  # allocate a big list\n",
    "    y = copy.deepcopy(x)\n",
    "    del x\n",
    "    return y\n",
    "\n",
    "if __name__==\"__main__\":\n",
    "    function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filename: /Users/kulmanm/KAUST/ACM/python_tutorial_2017/memory-profile-me.py\n",
      "\n",
      "Line #    Mem usage    Increment   Line Contents\n",
      "================================================\n",
      "     5     52.9 MiB      0.0 MiB   @profile\n",
      "     6                             def function():\n",
      "     7     52.9 MiB      0.0 MiB       x = [0.0] * 1000000  # allocate a big list\n",
      "     8     60.4 MiB      7.4 MiB       y = copy.deepcopy(x)\n",
      "     9     60.4 MiB      0.0 MiB       del x\n",
      "    10     60.4 MiB      0.0 MiB       return y\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%run memory-profile-me.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "So, what does this chart above tell us? Somewhy, Python didn't shrink the memory in use after we deleted `x`. What happened?\n",
    "\n",
    "To speed up memory allocation, Python reuses already allocated chuncks. It keeps several lists for small objects (separate lists for different sizes). Whenever we create a new object, Python either allocates a new block, or reuses a free one from one of the lists. That's why when we deleted x, the memory usage didn't shrink."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## 4. The Pythonic way: Tips & Tricks\n",
    "Python is a nice language. If you had known other programming languages before starting using Python, you can easily switch to Python (learn it literaly in 3-6 hours), and continue writing ~~ugly awkward~~ code using idioms and structures from your previous languages. However, Python is beautiful, very succinct and very expressive. This section is devoted to show you some essential well known (or less known) Python idioms (or tricks, if you will) that can make your code shorter and more elegant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### List comprehensions (the same for dicts, sets, frozensets, and actually all iterable objects)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49]\n"
     ]
    }
   ],
   "source": [
    "# Basic for-loop comprehension\n",
    "a = [1,2,3,4,5,6,7]\n",
    "l = []\n",
    "for x in a:\n",
    "    l.append(x * x)\n",
    "b = [x**2 for x in a]\n",
    "b = map(lambda x: x ** 2, a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[25, 36, 49]\n"
     ]
    }
   ],
   "source": [
    "# For-loop if-else comprehension\n",
    "c = [x**2 for x in a if x > 4]\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "# Multiple for-loop if-else comprehension\n",
    "llist = [[1,2,3],(4,5,6),(7,8,9)]\n",
    "c = [x**2 for sublist in llist for x in sublist if x % 2 == 0]\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Infinite structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, [...]]\n"
     ]
    }
   ],
   "source": [
    "# In Python you can actually use infinite lsits and dicts (without running out of memory!)\n",
    "a = [1,2,3]\n",
    "a.append(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, [...]]"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3][3][3][3][3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "#### Other fancy stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "2 1\n"
     ]
    }
   ],
   "source": [
    "# Quick swap\n",
    "a = 1\n",
    "b = 2\n",
    "print(a,b)\n",
    "a, b = b, a\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Nice math-like comparison notation\n",
    "x = 5\n",
    "print(3 < x < 8)\n",
    "print(x < 10 < 5*x < 99)\n",
    "print(2 > x < 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# List flattening techniques\n",
    "a = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "print(sum(a,[]))                  # this works only with nested lists (or objects with __add__ method defined)\n",
    "print([x for b in a for x in b])  # works with any nested iterables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[6, 7, 8, 9, 10]\n",
      "[(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]\n"
     ]
    }
   ],
   "source": [
    "# Pairing elements of two lists\n",
    "first, second = [1,2,3,4,5], [6,7,8,9,10]\n",
    "print(first)\n",
    "print(second)\n",
    "\n",
    "paired = zip(first,second)\n",
    "print(paired)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n",
      "(6, 7, 8, 9, 10)\n"
     ]
    }
   ],
   "source": [
    "# Unpairing the elements back into two lists (NOTE: Lists turn into tuples. This is due to zip implementation.)\n",
    "a, b = zip(*paired)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "Hello\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "# Providing function arguments via structures\n",
    "def func(a, b, c, kw1 = '', kw2 = 0):\n",
    "    print(a)\n",
    "    print(b)\n",
    "    print(c)\n",
    "    print(kw1)\n",
    "    print(kw2)\n",
    "\n",
    "args = (1, 2, 3)\n",
    "kwargs = {'kw1':'Hello', 'kw2':100}\n",
    "func(*args,**kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 'spam'), (1, 'ham'), (2, 'eggs')]\n",
      "[(5, 'spam'), (6, 'ham'), (7, 'eggs')]\n"
     ]
    }
   ],
   "source": [
    "# Enumeration of the elements\n",
    "l = [\"spam\", \"ham\", \"eggs\"]\n",
    "print(list(enumerate(l)))\n",
    "print(list(enumerate(l,5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "*Copyright 2017, ACM/SIAM Student Chapter of King Abdullah University of Science and Technology*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}