10 - Unpacking.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, when working with iterables, we want to extract specific portions of the list or tuple into separate variables (symbols).\n",
    "\n",
    "Let me show you an example first of how we might deal with a list of tuples:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we have a list of 2D points (tuples with 2 elements), and we want to calculate the Euclidean distance of these points from the origin `(0, 0)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we'll need a square root function - that is actually in the `math` module, so we'll need to inmport it first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 1), (1, 1), (2, 1), (2, 2)]\n",
      "[(0, 1), (1, 1), (2, 1), (2, 2)]\n",
      "[(0, 1), (1, 1), (2, 1), (2, 2)]\n",
      "[(0, 1), (1, 1), (2, 1), (2, 2)]\n"
     ]
    }
   ],
   "source": [
    "points = [(0, 1), (1, 1), (2, 1), (2, 2)]\n",
    "\n",
    "for point in points:\n",
    "    print(points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see `point` is itself a tuple with the x and y coordinates.\n",
    "\n",
    "So we'll need to extract those. But we know we can use indexing, and that's the approach you would take in Java, something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "pt = (10, 20)\n",
    "x = pt[0]\n",
    "y = pt[1]\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we could write our code to calculate the distance as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 1) distance: 1.0\n",
      "(1, 1) distance: 1.4142135623730951\n",
      "(2, 1) distance: 2.23606797749979\n",
      "(2, 2) distance: 2.8284271247461903\n"
     ]
    }
   ],
   "source": [
    "for point in points:\n",
    "    x = point[0]\n",
    "    y = point[1]\n",
    "    distance = sqrt(x ** 2 + y ** 2)\n",
    "    print(point, 'distance:', distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But Python allows us to unpack iterables into symbols this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = (10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And remember that the `()` are not strictly necessary, so we can write it also this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "x, y = 10, 20\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is unpacking, and it can work for any number of elements in the collection object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c, d, e, f = 'Python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(b)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So using this we can rewrite our previous example in a much more expressive way (more Pythonic):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "1.4142135623730951\n",
      "2.23606797749979\n",
      "2.8284271247461903\n"
     ]
    }
   ],
   "source": [
    "for x, y in points:  # this gets a tuple from points, and unpacks it into x and y\n",
    "    distance = sqrt(x ** 2 + y ** 2)\n",
    "    print(distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's go back to the last example we did in the last section:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember we started with this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['THIS', 'is', 'a', 'DEAD', 'PARROT']\n"
     ]
    }
   ],
   "source": [
    "lst = ['this', 'is', 'a', 'dead', 'parrot']\n",
    "\n",
    "for i in range(len(lst)):\n",
    "    if len(lst[i]) > 2:\n",
    "        lst[i] = lst[i].upper()\n",
    "\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we went to this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['THIS', 'is', 'a', 'DEAD', 'PARROT']\n"
     ]
    }
   ],
   "source": [
    "lst = ['this', 'is', 'a', 'dead', 'parrot']\n",
    "\n",
    "for item in enumerate(lst):\n",
    "    index = item[0]\n",
    "    s = item[1]\n",
    "    if len(s) > 2:\n",
    "        lst[index] = s.upper()\n",
    "        \n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But can you see where unpacking would be really useful here?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['THIS', 'is', 'a', 'DEAD', 'PARROT']\n"
     ]
    }
   ],
   "source": [
    "lst = ['this', 'is', 'a', 'dead', 'parrot']\n",
    "\n",
    "for index, s in enumerate(lst):\n",
    "    if len(s) > 2:\n",
    "        lst[index] = s.upper()\n",
    "        \n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much easier to read this code (expresses what is happening better) than the original Java-like approach. This type of programming style is considered more \"Pythonic\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another really cool application of unpacking is swapping two variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that in an assignment statement such as: \n",
    "\n",
    "`a = <expression>`\n",
    "\n",
    "the right hand side (the expression) is evaluated **first**, and that result is then assigned to the symbol on the left hand side of the assignment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a language such as Java, we have to use a temp variable to swap two values around, something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n",
      "20 10\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "print(a, b)\n",
    "\n",
    "tmp = a\n",
    "a = b\n",
    "b = tmp\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But in Python we can create a tuple on the right hand side: `a, b` and unpack it into the symbols `b`, and `a` like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n",
      "20 10\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 20\n",
    "print(a, b)\n",
    "\n",
    "b, a = a, b\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This works because the right hand side is evaluated first - so we end up with a tuple with the first object pointing to `10` in memory, and the second pointing to `20`. Then we re-assign the labels `b` and `a` to the first and second elements of the tuple when unpacking it."
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}