Lecture_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "To generate a presentation run the following command:\n",
    "\n",
    "``jupyter nbconvert Lecture_3.ipynb --to slides --post serve``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# How to use this notebook\n",
    "\n",
    "This notebook serves as both a presentation and interactive environment for students to experiment with Python. If you run it in the interactive mode using [Binder](https://mybinder.org/v2/gh/krzysztofarendt/deap/master), you can modify all code cells. Press `Shift+Enter` to run the modified code.\n",
    "\n",
    "Link to the repository: https://github.com/krzysztofarendt/deap "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Data types\n",
    "\n",
    "You will probably be using several different data types when programming in Python. Today, you'll learn about the built-in types, which are those readily available in Python without any additional libraries. Some of them you've been already using when learning the basics.\n",
    "\n",
    "### Built-in scalar types\n",
    "\n",
    "Scalar types represent a single value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = 1   # Integer\n",
    "b = 1.  # Floating-point number (real number)\n",
    "c = 'Hello!'                                  # String\n",
    "d = \"How are you?\"                            # String\n",
    "e = \"String with single quote (') character\"  # String\n",
    "f = 'String with double quote (\") character'  # String\n",
    "g = True          # Boolean\n",
    "h = False         # Boolean\n",
    "i = 2 + 3j        # Complex numbers "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Built-in data structures\n",
    "\n",
    "Data structures represent multiple values and possibly they relations to one another. The built-in data strucures are:\n",
    "\n",
    "- `list` - list, e.g. `[1, 2, 3]`\n",
    "- `tuple` - tuple, e.g. `(1, 2, 3)`\n",
    "- `set` - set, `{1, 2, 3}`\n",
    "- `dict` - dictionary, e.g. `{1: [1, 2], 2: [3, 4], 3: [5, 6]}`\n",
    "\n",
    "You know already a bit about lists, but let's summarize..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# List\n",
    "\n",
    "- A list is an ordered sequence of objects.\n",
    "- Any objects can be stored in a list.\n",
    "- Objects of different types can be hold in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [1.0, 2.0, 3.0], ['a', 'b', 'c'], [1, 2.0, '3', 'anything can be added to a list'], 'even another list...']\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]  # A list holding integers\n",
    "b = [1., 2., 3.]  # A list holding floating-point numbers\n",
    "c = ['a', 'b', 'c']  # A list holding strings\n",
    "d = [1, 2., '3', 'anything can be added to a list']\n",
    "e = [a, b, c, d, 'even another list...']\n",
    "\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A prettier way to print the elements of this list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1.0, 2.0, 3.0]\n",
      "['a', 'b', 'c']\n",
      "[1, 2.0, '3', 'anything can be added to a list']\n",
      "even another list...\n"
     ]
    }
   ],
   "source": [
    "for x in e:\n",
    "    print(x)  # x is a variable that can be used ONLY within THIS for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The same result can be achieved with another loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1.0, 2.0, 3.0]\n",
      "['a', 'b', 'c']\n",
      "[1, 2.0, '3', 'anything can be added to a list']\n",
      "even another list...\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(e)):\n",
    "    print(e[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "There are few useful methods worth remembering when working with lists: `append`, `extend`, `pop`. A method is a function specific to some object type, in this example a list.\n",
    "\n",
    "- `append` adds new elements to the end of the list.\n",
    "- `extend` extends the given list with another list.\n",
    "- `pop` returns the last element of a list and deletes it from the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3, 0]\n",
      "[1, 2, 3, 0, 4, 5]\n",
      "[1, 2, 3, 0, 4]\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "print(a)\n",
    "\n",
    "a.append(0)  # Add 0 at the and\n",
    "print(a)\n",
    "\n",
    "a.extend([4, 5])  # Add 4, 5 at the end\n",
    "print(a)\n",
    "\n",
    "b = a.pop()  # Return last element and delete\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If two lists are added together, this is what happens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "b = [3, 4, 5]\n",
    "print(a + b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "There are also two generic functions often used with lists:\n",
    "\n",
    "- `len` - return the length of the list\n",
    "- `reversed` - return the reversed sequence\n",
    "\n",
    "Both of these functions can be used also with other data structures, **as long as the operation makes sense**. E.g. a set is an unordered collection, so it has a size (`len` can be used), but cannot be reversed (`reversed` cannot be used)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "There are many ways to achieve the same result in Python. E.g. these are three equivalent loops printing a list in a reversed order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- EASY ---\n",
      "3\n",
      "2\n",
      "1\n",
      "--- ALSO EASY ---\n",
      "3\n",
      "2\n",
      "1\n",
      "--- CONFUSING? ---\n",
      "3\n",
      "2\n",
      "1\n",
      "--- MORE CONFUSING? ---\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print('--- EASY ---')\n",
    "a = [1, 2, 3]\n",
    "while len(a) > 0:\n",
    "    print(a.pop())\n",
    "\n",
    "print('--- ALSO EASY ---')\n",
    "a = [1, 2, 3]\n",
    "for x in reversed(a):\n",
    "    print(x)\n",
    "    \n",
    "print('--- CONFUSING? ---')\n",
    "a = [1, 2, 3]\n",
    "while len(a) > 0:\n",
    "    print(a[-1])\n",
    "    a = a[:-1]\n",
    "    \n",
    "print('--- MORE CONFUSING? ---')\n",
    "a = [1, 2, 3]\n",
    "for i in range(len(a) - 1, -1, -1):\n",
    "    print(a[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Surprised in the way `range` was used? You can always get a quick `help`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class range in module builtins:\n",
      "\n",
      "class range(object)\n",
      " |  range(stop) -> range object\n",
      " |  range(start, stop[, step]) -> range object\n",
      " |  \n",
      " |  Return an object that produces a sequence of integers from start (inclusive)\n",
      " |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
      " |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
      " |  These are exactly the valid indices for a list of 4 elements.\n",
      " |  When step is given, it specifies the increment (or decrement).\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      self != 0\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      helper for pickle\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(...)\n",
      " |      Return a reverse iterator.\n",
      " |  \n",
      " |  count(...)\n",
      " |      rangeobject.count(value) -> integer -- return number of occurrences of value\n",
      " |  \n",
      " |  index(...)\n",
      " |      rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.\n",
      " |      Raise ValueError if the value is not present.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  start\n",
      " |  \n",
      " |  step\n",
      " |  \n",
      " |  stop\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let's do a small repetition on indexing and slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = ['a', 'b', 'c', 'd']\n",
      "a[0] = a\n",
      "a[0:2] = ['a', 'b']\n",
      "a[-1] = d\n",
      "a[:] = ['a', 'b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "a = ['a', 'b', 'c', 'd']\n",
    "print('a =', a)\n",
    "print('a[0] =', a[0])\n",
    "print('a[0:2] =', a[0:2])\n",
    "print('a[-1] =', a[-1])\n",
    "print('a[:] =', a[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "With indexing (and slicing) you can also replace specific elements in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'x', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "a = ['a', 'b', 'c', 'd']\n",
    "a[1] = 'x'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Finally, unlike basic data types (scalars), data structures are requires special attention when copying variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "['x', 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Create new list\n",
    "a = [1, 2, 3]\n",
    "print(a)\n",
    "\n",
    "# Make a \"copy\" and replace the first element\n",
    "b = a\n",
    "b[0] = 'x'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "What happened here is that in fact `b` is not a copy of `a`, but just an *alias*. They both point to the same object in the memory!\n",
    "\n",
    "**What we need is a real copy.** A list can be copied in a number of ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "['x', 2, 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a.copy()  # Call the list-specific method copy()\n",
    "b = list(a)   # Create a new list using the values of a\n",
    "b = a[:]      # Slice the entire list\n",
    "\n",
    "b[0] = 'x'\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### List comprehensions\n",
    "\n",
    "Python has a special and very useful way to construct new lists, called *list comprehensions*. In many cases *list comprehensions* are equivalent to several lines of code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "a = [x for x in range(10)]  # Create a sequence from 0 to 9\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "b = [x for x in a if x > 2]  # Take values larger than 2\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "c = [x for x in a if (x > 2) and (x % 2 == 0)]  # Take only EVEN values larger than 2\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tuple\n",
    "\n",
    "Tuples are very similar to lists. The only difference is that they are *immutable*, meaning that once created, you cannot change their elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, 3)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-81-7d02990d0abc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "a[0] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "How do you think, why is it useful to use tuples instead of lists in some cases?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Set\n",
    "\n",
    "Sets are unordered collections of objects.\n",
    "\n",
    "Some of the often used methods are `add`, `remove`, `intersection`, `union`, `difference`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Tomato', 'Orange', 'Apple'}\n",
      "{'Tomato', 'Lemon', 'Orange', 'Apple'}\n"
     ]
    }
   ],
   "source": [
    "basket1 = {'Apple', 'Orange', 'Tomato'}\n",
    "print(basket1)\n",
    "\n",
    "basket1.add('Lemon')\n",
    "print(basket1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Tomato', 'Apple', 'Lemon', 'Onion', 'Orange'}\n"
     ]
    }
   ],
   "source": [
    "basket2 = {'Onion', 'Apple'}\n",
    "basket3 = basket1.union(basket2)\n",
    "print(basket3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Apple'}\n"
     ]
    }
   ],
   "source": [
    "basket3 = basket1.intersection(basket2)\n",
    "print(basket3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Tomato', 'Lemon', 'Orange'}\n"
     ]
    }
   ],
   "source": [
    "basket1.remove('Apple')  # Apple MUST be in the basket\n",
    "print(basket1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No more apples in the basket\n"
     ]
    }
   ],
   "source": [
    "# You can always check if a given object is in the set or not\n",
    "if 'Apple' in basket1:\n",
    "    basket1.remove('Apple')\n",
    "else:\n",
    "    print('No more apples in the basket')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Finally, sets can be initialized from other sequences, like lists and tuples. This is a useful way to get rid of any duplicate values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 3]\n",
    "my_set = set(my_list)\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Dictionary\n",
    "\n",
    "Dictionaries are used to map some values (called *keys*) to another values (called *values*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'City': 'Odense', 'Postal code': 5230, 'Country': 'Denmark', 'Buildings': [1, 2, 3]}\n"
     ]
    }
   ],
   "source": [
    "d = {'City': 'Odense', 'Postal code': 5230, 'Country': 'Denmark', 'Buildings': [1, 2, 3]}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Once a dictionary is initialized, new keys and values can be added easily:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'City': 'Odense', 'Postal code': 5230, 'Country': 'Denmark', 'Buildings': [1, 2, 3], 'Street': 'Campusvej'}\n"
     ]
    }
   ],
   "source": [
    "d['Street'] = 'Campusvej'\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A specific values can be accessed by related keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are on Campusvej in Odense (Denmark).\n"
     ]
    }
   ],
   "source": [
    "print('We are on {} in {} ({}).'.format(d['Street'], d['City'], d['Country']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In a typical scenario, the iteration over the objects stored in a dictionary looks as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "City --> Odense\n",
      "Postal code --> 5230\n",
      "Country --> Denmark\n",
      "Buildings --> [1, 2, 3]\n",
      "Street --> Campusvej\n"
     ]
    }
   ],
   "source": [
    "for key in d:\n",
    "    print(key, '-->', d[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Cattegory: vegetables\n",
      "=========================\n",
      "beetroot\n",
      "potato\n",
      "\n",
      "Cattegory: fruit\n",
      "=========================\n",
      "apple\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "food = {'vegetables': ['beetroot', 'potato'], 'fruit': ['apple', 'banana']}\n",
    "\n",
    "for key in food:\n",
    "    print('\\nCattegory:', key)  # \\n is simply 'new line'\n",
    "    print('=========================')\n",
    "    for x in food[key]:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Pitfalls\n",
    "\n",
    "### Do not modify the sequence while iterating over it!\n",
    "Avoid modifying a list or a dictionary when iterating over its objects. In example this might have an unexpected outcome:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog\n",
      "Cat\n"
     ]
    }
   ],
   "source": [
    "animals = ['Dog', 'Cat', 'Horse']\n",
    "\n",
    "for a in animals:\n",
    "    print(a)\n",
    "    animals.pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Example with a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Cattegory: vegetables\n",
      "=========================\n",
      "beetroot\n",
      "potato\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "dictionary changed size during iteration",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-142-238167b1864c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mfood\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;34m'vegetables'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'beetroot'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'potato'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'fruit'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'apple'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'banana'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mfood\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m     \u001b[0mfood\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'meat'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'chicken'\u001b[0m\u001b[1;33m]\u001b[0m  \u001b[1;31m# This is not a good idea...\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'\\nCattegory:'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mRuntimeError\u001b[0m: dictionary changed size during iteration"
     ]
    }
   ],
   "source": [
    "food = {'vegetables': ['beetroot', 'potato'], 'fruit': ['apple', 'banana']}\n",
    "\n",
    "for key in food:\n",
    "    food['meat'] = ['chicken']  # This is not a good idea...  \n",
    "    print('\\nCattegory:', key)\n",
    "    print('=========================')\n",
    "    for x in food[key]:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Dictionary keys should be treated as unordered\n",
    "\n",
    "In the recent versions of Python (3.6, 3.7) the key order in dictionaries is preserved:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "d = {'a': 1, 'b': 2, 'c': 3}\n",
    "\n",
    "for key in d:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "However, in older Python versions the outcome is undefined. It could be `a, b, c` or `b, a, c` or any other combination."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Copy vs. alias\n",
    "\n",
    "Consider the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: ['a', 'b', 'c']}\n",
      "{1: ['x', 'b', 'c']}\n",
      "{1: ['x', 'b', 'c']}\n"
     ]
    }
   ],
   "source": [
    "abc = ['a', 'b', 'c']\n",
    "d = {1: abc}  # A dictionary with one key\n",
    "print(d)\n",
    "\n",
    "abc[0] = 'x'  # When you change a value using indexing, you change the underlaying object\n",
    "print(d)\n",
    "\n",
    "abc = ['x', 'x', 'x']  # When you assign a new list to variable abc, it points to another object\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "It's always better to be explicit when you want to use a copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: ['a', 'b', 'c']}\n",
      "{1: ['a', 'b', 'c']}\n"
     ]
    }
   ],
   "source": [
    "abc = ['a', 'b', 'c']\n",
    "d = {1: abc.copy()}  # A dictionary with one key\n",
    "print(d)\n",
    "\n",
    "abc[0] = 'x'  # We change abc, but not the list in the dictionary (because it holds a copy)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Exercises\n",
    "\n",
    "1. Define a list of lists storing the following matrix:\n",
    "\n",
    "```\n",
    "1 2 3\n",
    "4 5 6\n",
    "7 8 9\n",
    "```\n",
    "\n",
    "2. Define a dictionary storing the following table:\n",
    "\n",
    "```\n",
    "x  y\n",
    "----\n",
    "1  4\n",
    "2  5\n",
    "3  6\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Final remarks\n",
    "\n",
    "The present data types are the most generic types which can be used in any application. E.g. you could use lists of lists to store matrices and write your own functions for matrix multiplication and other matrix-related operations. Similarly dictionaries could be used to work with tabular data.\n",
    "\n",
    "**However**, using the built-in data types for those specialized applications would require from you to write quite complex code for things which seem to be used very often. In addition your code for those purposes would be very slow and inefficient, because:\n",
    "\n",
    "* Python built-in types are not optimized for mathematical computations,\n",
    "* You have no experience in writing such applications.\n",
    "\n",
    "**Fortunately**, there are specialized scientific libraries available:\n",
    "- `numpy` - vector and matrix data types and operations,\n",
    "- `scipy` - scientific algorithms for linear algebra, optimization, statistics etc.,\n",
    "- `pandas` - data types and functions to work with tabular data,\n",
    "- `matplotlib` - data types and functions for data visualization.\n",
    "\n",
    "The libraries are compatible between one another and highly inter-related.\n",
    "\n",
    "We will get to them soon!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The end"
   ]
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}