code/12-pack-unpack.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "📝 **Author:** Amirhossein Heydari - 📧 **Email:** <amirhosseinheydari78@gmail.com> - 📍 **Origin:** [mr-pylin/python-workshop](https://github.com/mr-pylin/python-workshop)\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Table of contents**<a id='toc0_'></a>    \n",
    "- [Packing and Unpacking](#toc1_)    \n",
    "  - [Packing [Grouping Multiple Values into a Collection]](#toc1_1_)    \n",
    "    - [ Packing in Assignment (Tuples and Lists)](#toc1_1_1_)    \n",
    "    - [Packing in Functions (`*args` and `**kwargs`)](#toc1_1_2_)    \n",
    "    - [Packing in Function Return Values](#toc1_1_3_)    \n",
    "    - [Packing with List Comprehensions](#toc1_1_4_)    \n",
    "    - [Packing in Loops](#toc1_1_5_)    \n",
    "    - [Packing in Dictionary Merging](#toc1_1_6_)    \n",
    "    - [Packing Arbitrary Number of Variables into a List](#toc1_1_7_)    \n",
    "  - [Unpacking [Extracting Values from a Collection]](#toc1_2_)    \n",
    "    - [Unpacking in Assignment (Tuples and Lists)](#toc1_2_1_)    \n",
    "    - [Unpacking in Functions (Passing Arguments)](#toc1_2_2_)    \n",
    "    - [Unpacking Function Return Values](#toc1_2_3_)    \n",
    "    - [Unpacking in Loops](#toc1_2_4_)    \n",
    "    - [Unpacking with `*` Operator (Extended Unpacking)](#toc1_2_5_)    \n",
    "    - [Unpacking Nested Data Structures](#toc1_2_6_)    \n",
    "    - [Unpacking for Multiple Assignment](#toc1_2_7_)    \n",
    "    - [Dictionary Unpacking with `**` Operator](#toc1_2_8_)    \n",
    "\n",
    "<!-- vscode-jupyter-toc-config\n",
    "\tnumbering=false\n",
    "\tanchor=true\n",
    "\tflat=false\n",
    "\tminLevel=1\n",
    "\tmaxLevel=6\n",
    "\t/vscode-jupyter-toc-config -->\n",
    "<!-- THIS CELL WILL BE REPLACED ON TOC UPDATE. DO NOT WRITE YOUR TEXT IN THIS CELL -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc1_'></a>[Packing and Unpacking](#toc0_)\n",
    "\n",
    "- packing and unpacking are concepts related to managing collections of values such as `lists`, `tuples`, or `dictionaries`.\n",
    "- They allow for more flexible and readable code when dealing with multiple values\n",
    "\n",
    "📝 **Docs**:\n",
    "\n",
    "- Arbitrary Argument Lists: [docs.python.org/3/tutorial/controlflow.html#arbitrary-argument-lists](https://docs.python.org/3/tutorial/controlflow.html#arbitrary-argument-lists)\n",
    "- Keyword Arguments: [docs.python.org/3/tutorial/controlflow.html#keyword-arguments](https://docs.python.org/3/tutorial/controlflow.html#keyword-arguments)\n",
    "- Unpacking Argument Lists: [docs.python.org/3/tutorial/controlflow.html#unpacking-argument-lists](https://docs.python.org/3/tutorial/controlflow.html#unpacking-argument-lists)\n",
    "- Tuples and Sequences: [docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)\n",
    "\n",
    "🐍 **PEPs**:\n",
    "\n",
    "- Additional Unpacking Generalizations [[PEP 448](https://peps.python.org/pep-0448/)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_1_'></a>[Packing [Grouping Multiple Values into a Collection]](#toc0_)\n",
    "\n",
    "- Packing occurs when multiple values are assigned to a single variable, typically in the form of a `tuple`, `list`, or `dictionary`.\n",
    "- Packing can happen in different ways:\n",
    "  - **Using `*args`**: Collects all positional arguments into a `tuple`.\n",
    "  - **Using `**kwargs`**: Collects all keyword arguments into a `dictionary`.\n",
    "  - **Direct Assignment**: Multiple values can also be packed into a single variable, like packing values into a `tuple` or `list`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_1_'></a>[ Packing in Assignment (Tuples and Lists)](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "packed_tuple = 1, 2, 3, 4\n",
    "\n",
    "# log\n",
    "print(packed_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "packed_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# log\n",
    "print(packed_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_2_'></a>[Packing in Functions (`*args` and `**kwargs`)](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args       : (1, 2, 3)\n",
      "type(args) : <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def pack_args(*args):\n",
    "    print(f\"args       : {args}\")\n",
    "    print(f\"type(args) : {type(args)}\")\n",
    "\n",
    "\n",
    "pack_args(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kwargs       : {'a': 1, 'b': 2, 'c': 3}\n",
      "type(kwargs) : <class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "def pack_kwargs(**kwargs):\n",
    "    print(f\"kwargs       : {kwargs}\")\n",
    "    print(f\"type(kwargs) : {type(kwargs)}\")\n",
    "\n",
    "\n",
    "# log\n",
    "pack_kwargs(a=1, b=2, c=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_3_'></a>[Packing in Function Return Values](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "def pack_return():\n",
    "    return 1, 2, 3\n",
    "\n",
    "\n",
    "result = pack_return()\n",
    "\n",
    "# log\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_4_'></a>[Packing with List Comprehensions](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "packed_list = [x for x in range(5)]\n",
    "\n",
    "# log\n",
    "print(packed_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_5_'></a>[Packing in Loops](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2] 3\n",
      "[4, 5] 6\n",
      "[7, 8] 9\n"
     ]
    }
   ],
   "source": [
    "pairs = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]\n",
    "for *packed, last in pairs:\n",
    "    print(packed, last)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_6_'></a>[Packing in Dictionary Merging](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 3, 'd': 4}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {\"a\": 1, \"b\": 2}\n",
    "dict2 = {\"c\": 3, \"d\": 4}\n",
    "\n",
    "# unpacking two dictionaries and pack it together\n",
    "packed_dict = {**dict1, **dict2}\n",
    "print(packed_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_1_7_'></a>[Packing Arbitrary Number of Variables into a List](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a, *b = 1, 2, 3, 4\n",
    "\n",
    "# log\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_2_'></a>[Unpacking [Extracting Values from a Collection]](#toc0_)\n",
    "\n",
    "- Unpacking allows you to assign elements from a collection (like a `tuple`, `list`, or `dictionary`) to individual variables.\n",
    "- Python supports unpacking with the `*` and `**` operators:\n",
    "  - **Using `*`**: Can unpack elements from a list/tuple, and collect remaining elements into a list.\n",
    "  - **Using `**`**: Unpacks key-value pairs from a dictionary into named arguments in function calls.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_1_'></a>[Unpacking in Assignment (Tuples and Lists)](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "packed_tuple = (1, 2, 3)\n",
    "a, b, c = packed_tuple\n",
    "\n",
    "# log\n",
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "packed_list = [1, 2, 3, 4]\n",
    "a, b, c, d = packed_list\n",
    "\n",
    "# log\n",
    "print(a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_2_'></a>[Unpacking in Functions (Passing Arguments)](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "def add(a, b, c):\n",
    "    return a + b + c\n",
    "\n",
    "\n",
    "values = [1, 2, 3]\n",
    "result = add(*values)\n",
    "\n",
    "# log\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice. You are 25 years old.\n"
     ]
    }
   ],
   "source": [
    "def greet(name, age):\n",
    "    print(f\"Hello, {name}. You are {age} years old.\")\n",
    "\n",
    "\n",
    "person = {\"name\": \"Alice\", \"age\": 25}\n",
    "\n",
    "# log\n",
    "greet(**person)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_3_'></a>[Unpacking Function Return Values](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "def return_values():\n",
    "    return 1, 2, 3\n",
    "\n",
    "\n",
    "a, b, c = return_values()\n",
    "\n",
    "# log\n",
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_4_'></a>[Unpacking in Loops](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "3 4\n",
      "5 6\n"
     ]
    }
   ],
   "source": [
    "pairs = [(1, 2), (3, 4), (5, 6)]\n",
    "for a, b in pairs:\n",
    "    print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_5_'></a>[Unpacking with `*` Operator (Extended Unpacking)](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[2, 3, 4]\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "a, *rest, b = numbers\n",
    "\n",
    "# log\n",
    "print(a)\n",
    "print(rest)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_6_'></a>[Unpacking Nested Data Structures](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "nested_tuple = (1, (2, 3), 4)\n",
    "a, (b, c), d = nested_tuple\n",
    "\n",
    "# log\n",
    "print(a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_7_'></a>[Unpacking for Multiple Assignment](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 1, 2, 3\n",
    "\n",
    "# log\n",
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_2_8_'></a>[Dictionary Unpacking with `**` Operator](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 3, 'd': 4}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {\"a\": 1, \"b\": 2}\n",
    "dict2 = {\"c\": 3, \"d\": 4}\n",
    "\n",
    "merged_dict = {**dict1, **dict2}\n",
    "\n",
    "# log\n",
    "print(merged_dict)"
   ]
  }
 ],
 "metadata": {
  "author_email": "AmirhosseinHeydari78@gmail.com",
  "author_github": "https://github.com/mr-pylin",
  "author_name": "Amirhossein Heydari",
  "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.12.3"
  },
  "origin_repo": "https://github.com/mr-pylin/python-workshop"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}