A Gentle Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Gentle Introduction to Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assumes that you already set up jupyter successfully. Assumes that you have had exposure to an object-oriented programming language like Java or C++ before.\n",
    "\n",
    "partially inspired by https://lobster1234.github.io/2017/05/25/python-java-primer/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright Jens Dittrich, [Big Data Analytics Group](https://bigdata.uni-saarland.de/), [CC-BY-SA](https://creativecommons.org/licenses/by-sa/4.0/legalcode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter Cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a cell, move the cursor here and hit SHIFT+RETURN\n"
     ]
    }
   ],
   "source": [
    "print('this is a cell, move the cursor here and hit SHIFT+RETURN')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "126\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "84"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# an assignment\n",
    "theAnswer=42\n",
    "theAnswer*2\n",
    "# the last evaluation in a cell will be printed\n",
    "print(theAnswer*3)\n",
    "theAnswer*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes, this is a **markdown** cell. Cells may be of different type: code or markdown. Code may be python (as we are using a python kernel), but kernels for other languages exist as well, e.g. SQL. \n",
    "\n",
    "Also note that there is neither an In[.] nor an Out[.] on the left side of a markdown cell. You can switch the type of a cell through the menu *or* by using the shortcut ESC+M."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And just in case you need to typeset some math, simply use LaTeX notation: $$\\sum_{k=1}^{42} k$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Program State"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# does the state executed above in that other cell still exists?\n",
    "theAnswer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Program state is accumulated in a notebook through every execution of a code cell. This has pros and cons. Sometimes you edit a cell but forget to execute it and wonder why you do not receive the expected result further down in your notebook. Sometimes you execute a cell but forgot to execute the cells above. \n",
    "\n",
    "**When in doubt:** got to Menu \"Kernel\" and hit \"Restart&Run all\". If the bug is still there, it is your fault 😀.\n",
    "\n",
    "On the pro side: jupyter notebooks reflect the iterative style of small-scale programming. Notebooks are fantastic for prototyping. And they are a brilliant mix of program code, markdown/latex, and program output including graphical output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 2 artists>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "data = {'People that like Python': 93, 'People that do not have taste': 7}\n",
    "names = list(data.keys())\n",
    "values = list(data.values())\n",
    "plt.ylabel('Percentage')\n",
    "plt.bar(names, values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python: the Basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python is untyped\n",
    "firstname = \"Jens\"\n",
    "lastname = 'Dittrich'\n",
    "age = 42\n",
    "completed = False\n",
    "c = 'A'\n",
    "f = 0.0034"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jens'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firstname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dittrich'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lastname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hello World:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hello World"
     ]
    }
   ],
   "source": [
    "# With newline\n",
    "print(\"Hello World\");\n",
    "# Without newline\n",
    "print(\"Hello World\", end='')\n",
    "#print(\"Hello World\", end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the brackets after print(..), in Python 2.x you could write print without those brackets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum :  8\n",
      "Diff :  2\n",
      "Product :  15\n",
      "Modulo :  2\n",
      "Floor Division :  1\n",
      "Float Division :  1.6666666666666667\n"
     ]
    }
   ],
   "source": [
    "i = 5\n",
    "j = 3\n",
    "print(\"Sum : \", i+j)\n",
    "print(\"Diff : \" , i-j)\n",
    "print(\"Product : \" , i*j)\n",
    "print(\"Modulo : \" , i%j)\n",
    "print(\"Floor Division : \" , i//j)\n",
    "print(\"Float Division : \" , i/j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for n in range(5):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes, a body is not marked by {} but rather denoted through TABs! Looks weirs in the beginningm but you will get used to this quickly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-12-ee534247510f>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-12-ee534247510f>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    print(c)\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "for c in \"Manish\":\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yep, this does not work and yields an IndentationError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n",
      " \n",
      "r\n",
      "o\n",
      "c\n",
      "k\n",
      "s\n",
      "!\n"
     ]
    }
   ],
   "source": [
    "for c in \"Python rocks!\":\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It does!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If then else:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not Weird\n"
     ]
    }
   ],
   "source": [
    "n = 42\n",
    "if n%2 == 1:\n",
    "    print(\"Weird\")\n",
    "else:\n",
    "    if n >= 2 and n <= 5:\n",
    "        print(\"Not Weird\")\n",
    "    elif n >= 6 and n <= 20:\n",
    "        print(\"Weird\")\n",
    "    elif n > 20:\n",
    "        print(\"Not Weird\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo = [] # create an empty list\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.append(\"A\") # add to the end\n",
    "foo.append('B') # add to the end, single or double quote makes no difference\n",
    "foo.append(\"C\") # add to the end\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'D', 'C']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.insert(2,\"D\")    # insert at an index\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'D']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_list = sorted(foo) # returns a new, sorted list\n",
    "foo.sort()           # in place sort\n",
    "foo.remove(\"C\")      # remove first occurrence of \"C\"\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.pop(2) # return and remove the item at index 2\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['B', 'A']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo.reverse()       # reverse the list\n",
    "foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['B', 'A', 'E', 'F']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = foo.index(\"A\") # return index of \"A\"\n",
    "foo += [\"E\",\"F\"] # add a list with E and F to the end of this list\n",
    "size = len(foo) # size of the list\n",
    "foo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A', 'Boat', 'The'}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set_of_words1 = set()   # create a new set. Note that we do not use {} as that would be a dictionary (see below).\n",
    "set_of_words1.add(\"The\") # add a value\n",
    "set_of_words1.add(\"A\")   # add a value\n",
    "set_of_words1.add(\"Boat\")# add a value\n",
    "set_of_words1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A'}\n"
     ]
    }
   ],
   "source": [
    "set_of_words2 = {\"Anchor\",\"A\",\"Coast\"} # create another set and populate it\n",
    "print(set_of_words1.intersection(set_of_words2)) # intersection of the two sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'The', 'Anchor', 'Coast', 'Boat', 'A'}\n"
     ]
    }
   ],
   "source": [
    "print(set_of_words1.union(set_of_words2)) # union of the two sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coast\n",
      "Anchor\n",
      "A\n"
     ]
    }
   ],
   "source": [
    "for value in set_of_words2 : # iterate over all values in set_of_words2\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Maps (aka Dictionaries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'anchor': 2, 'dock': 3, 'the': 10, 'a': 8, 'boat': 1}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wordcount_map = {} # create a new, empty dict\n",
    "wordcount_map = {\"anchor\":2, \"dock\":3} # create a new dict and add key-values\n",
    "# add keys and values\n",
    "wordcount_map[\"the\"] = 10\n",
    "wordcount_map[\"a\"] = 8\n",
    "wordcount_map[\"boat\"] = 1\n",
    "wordcount_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "dict_keys(['anchor', 'dock', 'the', 'a', 'boat'])\n",
      "dict_values([2, 3, 10, 8, 1])\n"
     ]
    }
   ],
   "source": [
    "print(wordcount_map[\"the\"]) # value of a key\n",
    "print(wordcount_map.keys()) # List of keys\n",
    "print(wordcount_map.values()) # List of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"a\" in wordcount_map) # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('anchor', 2), ('dock', 3), ('the', 10), ('a', 8), ('boat', 1)])\n"
     ]
    }
   ],
   "source": [
    "print(wordcount_map.items()) #prints tuples of key-value pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'foo'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-30-0733c182e901>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwordcount_map\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"foo\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# throws a KeyError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'foo'"
     ]
    }
   ],
   "source": [
    "print(wordcount_map[\"foo\"]) # throws a KeyError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a simple function\n",
    "def theAnswer():\n",
    "    return 42\n",
    "\n",
    "theAnswer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# default function parameter:\n",
    "def kindOfIdentity(bla=42):\n",
    "    return bla\n",
    "\n",
    "kindOfIdentity()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kindOfIdentity(11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions without side effects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 2, 3, 5, 8]\n",
      "[47, 11]\n",
      "[0, 1, 1, 2, 3, 5, 8]\n"
     ]
    }
   ],
   "source": [
    "# no side effect:\n",
    "def func1(mylist):\n",
    "    print (mylist)\n",
    "    mylist = [47,11] \n",
    "    print (mylist)\n",
    "\n",
    "fib = [0,1,1,2,3,5,8]\n",
    "func1(fib)\n",
    "print(fib)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4463871944\n",
      "4463769160\n",
      "4463871944\n"
     ]
    }
   ],
   "source": [
    "def func1(mylist):\n",
    "    print (id(mylist))\n",
    "    mylist = [47,11] # this creates a new list object and assigns it to list!\n",
    "    print (id(mylist))\n",
    "\n",
    "fib = [0,1,1,2,3,5,8]\n",
    "func1(fib)\n",
    "print (id(fib))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions **with** side effects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4463697736 [0, 1, 1, 2, 3, 5, 8]\n",
      "4463697736 [0, 1, 1, 2, 3, 5, 8, 47, 11]\n",
      "4463697736 [0, 1, 1, 2, 3, 5, 8, 47, 11]\n"
     ]
    }
   ],
   "source": [
    "# list and fib refer the same address as shown by calling id():\n",
    "def func2(mylist):\n",
    "    print (id(mylist), mylist)\n",
    "    mylist += [47,11] # appends two elements to the array\n",
    "    print (id(mylist), mylist)\n",
    "    \n",
    "fib = [0,1,1,2,3,5,8]\n",
    "func2(fib)\n",
    "print (id(fib), fib)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions **without** side effects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4463620144 bla\n",
      "4463723944 blablub\n",
      "4463620144 bla\n"
     ]
    }
   ],
   "source": [
    "# no side effect:\n",
    "def func3(stlocal):\n",
    "    print (id(stlocal), stlocal)\n",
    "    stlocal += 'blub' # this creates a new string object and assigns it to stlocal!\n",
    "    print (id(stlocal), stlocal)\n",
    "    \n",
    "st = 'bla'\n",
    "func3(st)\n",
    "print (id(st), st)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generator function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "# generator function\n",
    "def square(n):\n",
    "    for i in range(n):\n",
    "        yield i**2\n",
    "\n",
    "for i in square(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes and Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def __init__(self, data=['what','ever']): # the constructor\n",
    "        self.words = data\n",
    "        print('constructor of class A was called')\n",
    "\n",
    "    # the \"kind of\"-destructor/finalizer\n",
    "    # Note that in Python (as in Java) and in contrast to languages like C++ there is no guarantee\n",
    "    # if and when this method will be executed!\n",
    "    # If you want to make sure that certain cleanup routines are executed, define a separate close()-method.\n",
    "    def __del__(self):                        \n",
    "        print('destructor of an instance of A was called')\n",
    "        if self.words != None:\n",
    "            del(self.words)\n",
    "\n",
    "    def __len__(self): # think of \"self\" as \"this\" in Java, instance methods must have self as their first parameter\n",
    "        return len(self.words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "constructor of class A was called\n",
      "2\n",
      "['what', 'ever']\n"
     ]
    }
   ],
   "source": [
    "# Usage\n",
    "a = A()     # create an instance oy MyClass\n",
    "print(len(a))  # will print 2\n",
    "print(a.words)    # will print ['what','ever']\n",
    "a2 = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the following has no effect as d still has a reference to the instance:\n",
    "a = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "destructor of an instance of A was called\n"
     ]
    }
   ],
   "source": [
    "# setting the last ref to the object to None will call the destructor (reference counting):\n",
    "a2 = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "constructor of class A was called\n",
      "2\n",
      "['foo', 'bar']\n"
     ]
    }
   ],
   "source": [
    "a3 = A([\"foo\",\"bar\"])\n",
    "print(len(a3))  # will print 2\n",
    "print(a3.words)    # will print ['foo','bar']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# B is a subclass of A:\n",
    "class B(A):\n",
    "    def __init__(self, data=None): # the constructor\n",
    "        super().__init__(data)     # call the constructor of the superclass\n",
    "        print('constructor of class B was called')\n",
    "        # do something here...\n",
    "        \n",
    "    def __del__(self): \n",
    "        print('destructor of an instance of B was called')\n",
    "        # do something here...\n",
    "\n",
    "        super().__del__()         # call the destructor of the superclass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "constructor of class A was called\n",
      "constructor of class B was called\n"
     ]
    }
   ],
   "source": [
    "b = B()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "destructor of an instance of B was called\n",
      "destructor of an instance of A was called\n"
     ]
    }
   ],
   "source": [
    "b = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pitfall**: Instance vs class attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in a class declaration an instance attribute may have the same name as the class attribute!\n",
    "class A: \n",
    "    counter = 0  # a class! attribute used for counting the number of instances of this class\n",
    "    \n",
    "    def __init__(self): \n",
    "        # increase the class attribute:\n",
    "        type(self).counter += 1\n",
    "        # set the instance attribute:\n",
    "        self.counter = 0\n",
    "\n",
    "    def __del__(self): \n",
    "        # decrease the class attribute:\n",
    "        type(self).counter -= 1\n",
    "\n",
    "    def incInstanceCounter(self):\n",
    "        # increase the instance attribute:\n",
    "        self.counter += 1\n",
    "        \n",
    "    def printCounter(self):\n",
    "        print(\"instance: \", self.counter, \" class: \", A.counter)\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "instance:  0  class:  1\n",
      "instance:  0  class:  2\n",
      "instance:  0  class:  2\n",
      "instance:  1  class:  2\n",
      "instance:  2  class:  2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's instantiate some objects and thereby increase the instance counter:\n",
    "x = A()\n",
    "x.printCounter()\n",
    "y = A()\n",
    "x.printCounter()\n",
    "y.printCounter()\n",
    "\n",
    "# now let's increase the instance attributes:\n",
    "x.incInstanceCounter()\n",
    "x.printCounter()\n",
    "x.incInstanceCounter()\n",
    "x.printCounter()\n",
    "x = None\n",
    "y = None\n",
    "A.counter"
   ]
  }
 ],
 "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.6.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}