Part1-Functional/05-FunctionParameters/05-ExtendedUnpacking.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3b600c43",
   "metadata": {},
   "source": [
    "# Extended Unpacking\n",
    "\n",
    "Using the **`*`** and **`**`** operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5281872c",
   "metadata": {},
   "source": [
    "## The use case for `*`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "feae573f",
   "metadata": {},
   "source": [
    "We don't always want to unpack every single item in an iterable.\n",
    "\n",
    "We may, for example, want to unpack the first value and then unpack the remaining values into another variable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d851e135",
   "metadata": {},
   "source": [
    "```python\n",
    "l = [1, 2, 3, 4, 5, 6, 7]\n",
    "```\n",
    "\n",
    "We can achieve this using slicing:\n",
    "\n",
    "```python\n",
    "a = l[0]\n",
    "b = l[1:]\n",
    "```\n",
    "\n",
    "or, using simple unpacking (aka **parallel assignment**):\n",
    "\n",
    "```python\n",
    "a, b = l[0], l[1:]\n",
    "```\n",
    "\n",
    "We can also use the **`*`** operator:\n",
    "\n",
    "```python\n",
    "a, *b = l\n",
    "```\n",
    "\n",
    "Apart from cleaner syntax, it also works with **any iterable**, not just sequence types!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4b2cc5dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6]\n",
      "1. a=0, b=[1, 2, 3, 4, 5, 6]\n",
      "2. a=0, b=[1, 2, 3, 4, 5, 6]\n",
      "3. a=0, b=[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "l = list(range(7))\n",
    "print(l)\n",
    "\n",
    "a = l[0]\n",
    "b = l[1:]\n",
    "print(f\"1. {a=}, {b=}\")\n",
    "\n",
    "a, b = l[0], l[1:] # parallel assignment\n",
    "print(f\"2. {a=}, {b=}\")\n",
    "\n",
    "a, *b = l\n",
    "print(f\"3. {a=}, {b=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52cbbc02",
   "metadata": {},
   "source": [
    "## Usage with ordered types\n",
    "\n",
    "Use **`*`** operator in the LHS of an assignment to unpack the RHS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b758912c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=-10, b=[5, 2, 300]\n"
     ]
    }
   ],
   "source": [
    "a, *b = [-10, 5, 2, 300] # list\n",
    "print(f\"{a=}, {b=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6a337392",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=-10, b=[5, 2, 300]\n"
     ]
    }
   ],
   "source": [
    "a, *b = (-10, 5, 2, 300) # tuple\n",
    "print(f\"{a=}, {b=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "578c95a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a='X', b=['Y', 'Z']\n"
     ]
    }
   ],
   "source": [
    "a, *b = \"XYZ\" # string\n",
    "print(f\"{a=}, {b=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aae7402a",
   "metadata": {},
   "source": [
    "> Always unpack in to a **list**\n",
    "\n",
    "The following also works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "76f31856",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=1, b=2, c=[3, 4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "a, b, *c = 1, 2, 3, 4, 5, 6, 7\n",
    "print(f\"{a=}, {b=}, {c=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7addb4a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=1, b=2, c=[3, 4, 5, 6], d=7\n"
     ]
    }
   ],
   "source": [
    "a, b, *c, d = 1, 2, 3, 4, 5, 6, 7\n",
    "print(f\"{a=}, {b=}, {c=}, {d=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9d00262e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a='p', b=['y', 't', 'h'], c='o', d='n'\n"
     ]
    }
   ],
   "source": [
    "a, *b, c, d = \"python\"\n",
    "print(f\"{a=}, {b=}, {c=}, {d=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97bd78f4",
   "metadata": {},
   "source": [
    "The **`*`** operator can only be used **once** in the LHS an unpacking assignment.\n",
    "\n",
    "For obvious reason, you cannot write something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "403b3d3f",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "multiple starred expressions in assignment (3518091481.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[27], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m    a, *b, *c = [1, 2, 3, 4, 5]\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m multiple starred expressions in assignment\n"
     ]
    }
   ],
   "source": [
    "a, *b, *c = [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "837c4932",
   "metadata": {},
   "source": [
    "Since both **`*b`** and **`*c`** mean \"the rest\", both cannot exhaust the remaining elements."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b8fa660",
   "metadata": {},
   "source": [
    "However, we can also use it this way: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ca92c79b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l1=[1, 2, 3]\n",
      "l2=[4, 5, 6]\n",
      "\n",
      "l=[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "l1 = [1, 2, 3]\n",
    "l2 = [4, 5, 6]\n",
    "\n",
    "print(f\"{l1=}\")\n",
    "print(f\"{l2=}\")\n",
    "\n",
    "l = [*l1, *l2]\n",
    "\n",
    "print(f\"\\n{l=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "885322f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l1=[1, 2, 3]\n",
      "l2='XYZ'\n",
      "\n",
      "l=[1, 2, 3, 'X', 'Y', 'Z']\n"
     ]
    }
   ],
   "source": [
    "l1 = [1, 2, 3]\n",
    "l2 = \"XYZ\"\n",
    "\n",
    "print(f\"{l1=}\")\n",
    "print(f\"{l2=}\")\n",
    "\n",
    "l = [*l1, *l2]\n",
    "print(f\"\\n{l=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a93ffb1",
   "metadata": {},
   "source": [
    "## Usage with unordered types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d9db7f9",
   "metadata": {},
   "source": [
    "Types such as **sets** and **dictionaries** have **no ordering**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "0b54bfb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s={2, 100, 5, -10, 'd'}\n"
     ]
    }
   ],
   "source": [
    "s = {-10, 2, 5, 100, \"d\"}\n",
    "print(f\"{s=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef226233",
   "metadata": {},
   "source": [
    "Sets and dictionary keys are still iterable, but iterating has no guarantee of preserving the order in which the elements were created/added.\n",
    "\n",
    "But, the **`*`** operator still works, since it works with any iterable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "e414a8d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s={2, 100, 5, -10, 'd'}\n",
      "a=2, b=[100, 5, -10], c='d'\n"
     ]
    }
   ],
   "source": [
    "s = {-10, 2, 5, 100, \"d\"}\n",
    "a, *b, c = s\n",
    "\n",
    "print(f\"{s=}\")\n",
    "print(f\"{a=}, {b=}, {c=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce8567b6",
   "metadata": {},
   "source": [
    "In practice, we rarely unpack sets and dictionaries directly in this way."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb389298",
   "metadata": {},
   "source": [
    "It is useful through in a situation where you might want to create single collection containing all the items of multiple sets, or all the keys of multiple dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "71aac4e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = {\"p\": 1, \"y\": 2}\n",
    "d2 = {\"t\": 3, \"h\": 4}\n",
    "d3 = {\"h\": 5, \"o\": 6, \"n\": 6}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55720da9",
   "metadata": {},
   "source": [
    "> Note that the key **`h`** is in both **`d2`** and **`d3`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "7c51578e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l=['p', 'y', 't', 'h', 'h', 'o', 'n']\n"
     ]
    }
   ],
   "source": [
    "l = [*d1, *d2, *d3]\n",
    "\n",
    "print(f\"{l=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "03e85b80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s={'y', 'p', 't', 'o', 'n', 'h'}\n"
     ]
    }
   ],
   "source": [
    "s = {*d1, *d2, *d3}\n",
    "\n",
    "print(f\"{s=}\") # order is not guaranteed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e9e011e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s={1, 2, 3, 4, 5, 6, 7, 8, 9}\n",
      "s={1, 2, 3, 4, 5, 6, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "s1 = {1, 2, 3}\n",
    "s2 = {3, 4, 5}\n",
    "s3 = {5, 6, 7}\n",
    "s4 = {7, 8, 9}\n",
    "\n",
    "# 1\n",
    "s = s1.union(s2, s3, s4) # or s = s1.union(s2).union(s3).union(s4) \n",
    "print(f\"{s=}\")\n",
    "\n",
    "# 2\n",
    "s = {*s1, *s2, *s3, *s4} # use unpacking\n",
    "print(f\"{s=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21f2f26e",
   "metadata": {},
   "source": [
    "## The **`**`** unpacking operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1035d69",
   "metadata": {},
   "source": [
    "When working with dictionaries we saw that **`*`** essentially iterated the **keys**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "b875bb1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a='a', b=['b', 'c'], c='d'\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "    \"a\": 1,\n",
    "    \"b\": 2,\n",
    "    \"c\": 3,\n",
    "    \"d\": 4\n",
    "}\n",
    "a, *b, c = d\n",
    "\n",
    "print(f\"{a=}, {b=}, {c=}\") # order is not guarantee"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "666ce38c",
   "metadata": {},
   "source": [
    "#### We might ask the question:\n",
    "\n",
    "Can we unpack the **key-value** pairs of dictionaries? ***YES!***\n",
    "\n",
    "> We need to use the **`**`** operator.\n",
    "\n",
    "### Using `**`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "19f43862",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d={'p': 1, 'y': 2, 't': 3, 'h': 5, 'o': 6, 'n': 6}\n"
     ]
    }
   ],
   "source": [
    "d1 = {\"p\": 1, \"y\": 2}\n",
    "d2 = {\"t\": 3, \"h\": 4}\n",
    "d3 = {\"h\": 5, \"o\": 6, \"n\": 6}\n",
    "\n",
    "d = {**d1, **d2, **d3} # merge the dictionaries\n",
    "print(f\"{d=}\") # order is not guarantee"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e1c1db4",
   "metadata": {},
   "source": [
    "Note that the **`**`** operator cannot be used in the LHS of an assignments.\n",
    "\n",
    "Note that the value of **`h`** in **`d3`** **\"overwrote\"** the first value of **`h`** found in **`d2`**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1d9d9c0",
   "metadata": {},
   "source": [
    "You can even also use it to add key-value pairs from one (or more) dictionary into a dictionary literal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "3ab131f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = {\n",
    "    \"a\": 1,\n",
    "    \"b\": 2\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "6727337b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'c': 3, 'b': 2}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\"a\": 10, \"c\": 3, **d1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "2fda604f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 10, 'b': 2, 'c': 3}"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{**d1, \"a\": 10, \"c\": 3}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49952892",
   "metadata": {},
   "source": [
    "## Nested unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "f0c143bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, [3, 4]] # nested list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "905bc466",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=1, b=2, c=[3, 4]\n",
      "d=3, e=4\n"
     ]
    }
   ],
   "source": [
    "a, b ,c = l\n",
    "\n",
    "print(f\"{a=}, {b=}, {c=}\")\n",
    "\n",
    "d, e = c\n",
    "\n",
    "print(f\"{d=}, {e=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32726780",
   "metadata": {},
   "source": [
    "Simple way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "fc967032",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=1, b=2, c=3, d=4\n"
     ]
    }
   ],
   "source": [
    "a, b, (c, d) = [1, 2, [3, 4]]\n",
    "\n",
    "print(f\"{a=}, {b=}, {c=}, {d=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "36c94426",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=1, b=[2, 3], c='X', d='Y', e='Z'\n"
     ]
    }
   ],
   "source": [
    "a, *b, (c, d, e) = [1, 2, 3, \"XYZ\"]\n",
    "\n",
    "print(f\"{a=}, {b=}, {c=}, {d=}, {e=}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9711ca6e",
   "metadata": {},
   "source": [
    "#### Practice with unpacking and slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8dfbc9e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, 3, \"python\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "24088888",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=1, b=[2, 3], c='p', d=['y', 't', 'h', 'o', 'n']\n"
     ]
    }
   ],
   "source": [
    "a, *b, (c, *d) = l\n",
    "print(f\"{a=}, {b=}, {c=}, {d=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bf2c4064",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=1, b=[2, 3], c='p', d=['y', 't', 'h', 'o', 'n']\n"
     ]
    }
   ],
   "source": [
    "a, b, c, d = l[0], l[1:3], l[3][0], list(l[3][1:])\n",
    "print(f\"{a=}, {b=}, {c=}, {d=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "947b9aae",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}