packing_unpacking_iterables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notebook by Ruchir Chawdhry<br>\n",
    "Released under MIT License<br>\n",
    "GitHub: [github.com/RuchirChawdhry/Jupyter-Notebooks](https://github.com/RuchirChawdhry/Jupyter-Notebooks)<br>\n",
    "LinkedIn: [linkedin.com/in/RuchirChawdhry](https://linkedin.com/in/RuchirChawdhry)<br>\n",
    "Website: [ruchirchawdhry.com](https://ruchirchawdhry.com)<br>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Packing and Unpacking Iterables: Tuple, List, Dictionary, Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.691897Z",
     "start_time": "2019-10-29T17:20:42.678501Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "a, b = [1, 2, 3, 4, 5], [6, 7, 8, 9, 10]\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.723028Z",
     "start_time": "2019-10-29T17:20:42.702213Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 10, 20, 'hello'\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.737712Z",
     "start_time": "2019-10-29T17:20:42.729060Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X\n",
      "Y\n",
      "Z\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 'XYZ'\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "# string unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.754600Z",
     "start_time": "2019-10-29T17:20:42.745751Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('apple', 'orange', 'stawberry')\n",
      "('spinach', 'kale', 'beetroot')\n"
     ]
    }
   ],
   "source": [
    "grocery = ('apple', 'orange', 'stawberry'), ('spinach', 'kale', 'beetroot')\n",
    "fruits, vegetables = grocery\n",
    "print(fruits)\n",
    "print(vegetables)\n",
    "# tuple unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.773890Z",
     "start_time": "2019-10-29T17:20:42.761714Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iPhone X\n",
      "Macbook Pro\n",
      "Vagabonding\n"
     ]
    }
   ],
   "source": [
    "wishlist = ('iPhone X', 'Macbook Pro', 'Vagabonding')\n",
    "phone, laptop, book = wishlist\n",
    "print(phone)\n",
    "print(laptop)\n",
    "print(book)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.798833Z",
     "start_time": "2019-10-29T17:20:42.776511Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Delhi', 'Bangkok', 'New York']\n",
      "['India', 'Thailand', 'United States']\n"
     ]
    }
   ],
   "source": [
    "places = ['Delhi', 'Bangkok', 'New York'], ['India', 'Thailand', 'United States']\n",
    "cities, countries = places\n",
    "print(cities)\n",
    "print(countries)\n",
    "# list unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.815844Z",
     "start_time": "2019-10-29T17:20:42.802769Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Delhi\n",
      "Thailand\n",
      "Indian Ocean\n"
     ]
    }
   ],
   "source": [
    "places = ['Delhi', 'Thailand', 'Indian Ocean']\n",
    "city, country, ocean = places\n",
    "print(city)\n",
    "print(country)\n",
    "print(ocean)\n",
    "# list unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.863474Z",
     "start_time": "2019-10-29T17:20:42.820293Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key1\n",
      "key2\n",
      "key3\n",
      "{'key1': 1, 'key2': 2, 'key3': 3}\n"
     ]
    }
   ],
   "source": [
    "d = {'key1': 1, 'key2': 2, 'key3': 3}\n",
    "a, b, c = d\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "# dictionaries and sets are unordered types\n",
    "# they can be iterated but there's no guarantee the order of the results will match\n",
    "# sets and dictionaries are rarely unpacked in this way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.887098Z",
     "start_time": "2019-10-29T17:20:42.872613Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n",
      "20 10\n"
     ]
    }
   ],
   "source": [
    "a, b = 10, 20\n",
    "print(a, b)\n",
    "\n",
    "b, a = a, b\n",
    "print(a, b)\n",
    "# can used to swap variable values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.911855Z",
     "start_time": "2019-10-29T17:20:42.891490Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}\n",
    "a, b, c, d = d.values()\n",
    "print(a, b, c, d)\n",
    "# the order is not always the same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.947323Z",
     "start_time": "2019-10-29T17:20:42.916393Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 1) ('b', 2) ('c', 3) ('d', 4)\n"
     ]
    }
   ],
   "source": [
    "d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}\n",
    "a, b, c, d = d.items()\n",
    "print(a, b, c, d)\n",
    "# d.items() returns a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.967897Z",
     "start_time": "2019-10-29T17:20:42.950082Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 [2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3, 4, 5, 6]\n",
    "a, b = l[0], l[1:] # parallel assignment\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:42.982485Z",
     "start_time": "2019-10-29T17:20:42.971030Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 [2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "a, *b = l\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.013630Z",
     "start_time": "2019-10-29T17:20:42.995826Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10\n",
      "[5, 2, 100]\n"
     ]
    }
   ],
   "source": [
    "a, *b = [-10, 5, 2, 100]\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.040860Z",
     "start_time": "2019-10-29T17:20:43.022626Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X\n",
      "['Y', 'Z']\n"
     ]
    }
   ],
   "source": [
    "a, *b = 'XYZ'\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.055669Z",
     "start_time": "2019-10-29T17:20:43.045648Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "[3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "a, b, *c = 1, 2, 3, 4, 5\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.081701Z",
     "start_time": "2019-10-29T17:20:43.062376Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "l1 = [1, 2, 3]\n",
    "l2 = [4, 5, 6]\n",
    "l = [*l1, *l2]\n",
    "print(l)\n",
    "# combining 2 lists w/ *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.103171Z",
     "start_time": "2019-10-29T17:20:43.084547Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "l1 = [1, 2, 3, 4]\n",
    "l2 = [4, 5, 6]\n",
    "l = {*l1, *l2}\n",
    "print(l)\n",
    "# combining 2 lists into a set\n",
    "# notice how the extra 4 is not there\n",
    "# a set cannot have duplicate elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.120331Z",
     "start_time": "2019-10-29T17:20:43.105738Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['p', 'y', 't', 'h', 'h', 'o', 'n']\n"
     ]
    }
   ],
   "source": [
    "d1 = {'p': 1, 'y': 2}\n",
    "d2 = {'t': 3, 'h': 4}\n",
    "d3 = {'h': 5, 'o': 6, 'n': 7}\n",
    "l = [*d1, *d2, *d3]\n",
    "print(l)\n",
    "# a list of all the keys of dicts d1, d2, d3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.133388Z",
     "start_time": "2019-10-29T17:20:43.123766Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'p': 1, 'y': 2, 't': 3, 'h': 5, 'o': 6, 'n': 7}\n"
     ]
    }
   ],
   "source": [
    "d1 = {'p': 1, 'y': 2}\n",
    "d2 = {'t': 3, 'h': 4}\n",
    "d3 = {'h': 5, 'o': 6, 'n': 7}\n",
    "d = {**d1, **d2, **d3}\n",
    "print(d)\n",
    "# an easy way to merge dictionaries\n",
    "# note that the value of 'h' in d3 'overwrote' the 1st value of 'h' in d2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.157295Z",
     "start_time": "2019-10-29T17:20:43.146816Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, [3, 4]]\n",
    "a, b , c = l\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "# nested unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.171929Z",
     "start_time": "2019-10-29T17:20:43.161408Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, [3, 4]]\n",
    "a, b , (c, d) = l\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "# nested unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.188913Z",
     "start_time": "2019-10-29T17:20:43.174645Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[2, 3]\n",
      "p\n",
      "['y', 't', 'h', 'o', 'n']\n"
     ]
    }
   ],
   "source": [
    "a, *b, (c, *d) = [1, 2, 3, 'python']\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "# nested unpacking w/ *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.200551Z",
     "start_time": "2019-10-29T17:20:43.190981Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 3, 'd', -99]\n"
     ]
    }
   ],
   "source": [
    "s = {10, -99, 3, 'd'}\n",
    "*l, = s\n",
    "print(l)\n",
    "# unpacking a set into a list without using list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.216468Z",
     "start_time": "2019-10-29T17:20:43.204290Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "s1 = {1, 2, 3}\n",
    "s2 = {3, 4, 5}\n",
    "c = {*s1, *s2}\n",
    "print(c)\n",
    "# merging sets without using .union()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.255671Z",
     "start_time": "2019-10-29T17:20:43.221501Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "s1 = {1, 2, 3}\n",
    "s2 = {3, 4, 5}\n",
    "c = [*s1, *s2]\n",
    "print(c)\n",
    "# unpacking 2 sets into a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.279783Z",
     "start_time": "2019-10-29T17:20:43.264847Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "s1 = {1, 2, 3}\n",
    "s2 = {3, 4, 5}\n",
    "c = *s1, *s2\n",
    "print(c)\n",
    "# unpacking 2 sets into a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.304715Z",
     "start_time": "2019-10-29T17:20:43.282175Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': 1, 'key2': 3, 'key4': 4}\n"
     ]
    }
   ],
   "source": [
    "d1 = {'key1': 1, 'key2': 2}\n",
    "d2 = {'key2': 3, 'key4': 4}\n",
    "d = {**d1, **d2}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-10-29T17:20:43.348732Z",
     "start_time": "2019-10-29T17:20:43.309759Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'key1': 1, 'key2': 2, 'c': 3}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{'a': 1, 'b': 2, **d1, 'c': 3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}