18_functions_advanced.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dc0a70b0",
   "metadata": {},
   "source": [
    "# Functions-Advanced\n",
    "    1. function/variable scopes\n",
    "    2. global keyword & immutable arguments\n",
    "    3. mutable input arguments\n",
    "    4. args, kwargs, *, and ** unpacking\n",
    "    5. pass statement & Ellipsis Mark\n",
    "    6. mandatory positional and keyword arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f814e64",
   "metadata": {},
   "source": [
    "## Function/Variable scopes\n",
    "    from a function's scope one can access global vairables! \n",
    "    changing a global variable from inside a func needs declaration of that variable within the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "8dc79c8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "var = 10 # global variable!\n",
    "def func_(input_1):\n",
    "    var_ = var + input_1 # accessing a global variable!\n",
    "    print(var_, input_1)\n",
    "\n",
    "func_(var) \n",
    "print(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "7ff584f7",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'var_' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [45], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# func variable can't be accessed from the outer scope!\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mvar_\u001b[49m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'var_' is not defined"
     ]
    }
   ],
   "source": [
    "# func variable can't be accessed from the outer scope!\n",
    "var_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "2ceaf168",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'input_1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [46], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43minput_1\u001b[49m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'input_1' is not defined"
     ]
    }
   ],
   "source": [
    "input_1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfda8cc2",
   "metadata": {},
   "source": [
    "## global Keyword and immutable arguments\n",
    "    Using global keyword global variables can be modified inside a function scope.\n",
    "    I don't recommend it at all, unless you know what you are about to do!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "8863479d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner_var: 20 inside function\n",
      "outer_var: 10 out of function\n"
     ]
    }
   ],
   "source": [
    "var = 10 # global variable!\n",
    "\n",
    "def func_(input_1):\n",
    "    var = 20 # This does not change the value of the global variable\n",
    "    print(f\"inner_var: {var} inside function\")\n",
    "\n",
    "func_(30) \n",
    "print(f\"outer_var: {var} out of function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "a62a4cce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner_var: 20\n",
      "outer_var: 20\n"
     ]
    }
   ],
   "source": [
    "var = 10 # global variable!\n",
    "def func_(input_1):\n",
    "    global var # creating a connection between inner and outer variables!\n",
    "    var = 20 \n",
    "    print(f\"inner_var: {var}\")\n",
    "\n",
    "func_(30) \n",
    "print(f\"outer_var: {var}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "2cd6374d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'c' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [49], line 11\u001b[0m\n\u001b[0;32m      8\u001b[0m     c \u001b[38;5;241m=\u001b[39m c \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m2\u001b[39m \n\u001b[0;32m      9\u001b[0m     \u001b[38;5;28mprint\u001b[39m(c)\n\u001b[1;32m---> 11\u001b[0m \u001b[43madd\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn [49], line 8\u001b[0m, in \u001b[0;36madd\u001b[1;34m()\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21madd\u001b[39m():\n\u001b[0;32m      6\u001b[0m     \u001b[38;5;66;03m# at the left side c is being assinged inside the function's scope\u001b[39;00m\n\u001b[0;32m      7\u001b[0m     \u001b[38;5;66;03m# at the right side the same variable is being referenced which raises UnboundLocalError\u001b[39;00m\n\u001b[1;32m----> 8\u001b[0m     c \u001b[38;5;241m=\u001b[39m \u001b[43mc\u001b[49m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m2\u001b[39m \n\u001b[0;32m      9\u001b[0m     \u001b[38;5;28mprint\u001b[39m(c)\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'c' referenced before assignment"
     ]
    }
   ],
   "source": [
    "# A common mistake! Referencing a variable before its assignment gets completed \n",
    "\n",
    "c = 1 # global variable\n",
    "    \n",
    "def add():\n",
    "    # at the left side c is being assinged inside the function's scope\n",
    "    # at the right side the same variable is being referenced which raises UnboundLocalError\n",
    "    c = c + 2 \n",
    "    print(c)\n",
    "\n",
    "add()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "de0c17fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner c variable: 2\n",
      "global c variable: 2\n"
     ]
    }
   ],
   "source": [
    "# Solution is to declare the global variable inside the func!\n",
    "c = 0 # global variable\n",
    "\n",
    "def add():\n",
    "    global c # the global vairable is introduced to the function's scope!\n",
    "    c = c + 2 # while the c is being assigned with another value, it can be referenced because it's already defined in the function's scope!\n",
    "    print(\"inner c variable:\", c)\n",
    "\n",
    "add()\n",
    "print(\"global c variable:\", c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "3a567604",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "local c variable: 2\n",
      "global c variable: 0\n"
     ]
    }
   ],
   "source": [
    "# as input argument!\n",
    "\n",
    "c = 0 # global variable\n",
    "\n",
    "def add(c):\n",
    "    c = c + 2 # while the c is being assigned with another value, it can be referenced because it's already defined in the function's scope!\n",
    "    print(\"local c variable:\", c)\n",
    "\n",
    "add(c)\n",
    "print(\"global c variable:\", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83774be4",
   "metadata": {},
   "source": [
    "## mutable input arguments\n",
    "    Variables are passed by reference in python\n",
    "    Mutable variables can be modified inside functions! no need for global declaration!\n",
    "    global declaration is used when we want to modify an immutable variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "550b343c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner input: [0, 2]\n",
      "outer input: [0, 2]\n"
     ]
    }
   ],
   "source": [
    "var = [10, 2]  # lists are mutable\n",
    "\n",
    "def func_(input_1: list):\n",
    "    input_1[0] = 0\n",
    "    print(f\"inner input: {input_1}\")\n",
    "\n",
    "func_(var) \n",
    "print(f\"outer input: {var}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "68b03392",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner input: [0, 2]\n",
      "global variable: [10, 2]\n"
     ]
    }
   ],
   "source": [
    "# How to prevent outer mutable vairable from changing\n",
    "from copy import deepcopy\n",
    "var = [10, 2]  # lists are mutable\n",
    "\n",
    "def func_(input_1: list):\n",
    "    input_1 = deepcopy(input_1)\n",
    "    input_1[0] = 0\n",
    "    print(f\"inner input: {input_1}\")\n",
    "\n",
    "func_(var) \n",
    "print(f\"global variable: {var}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "3156aad6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner c variable: [2, 1]\n",
      "global c variable: [2, 1]\n"
     ]
    }
   ],
   "source": [
    "c = [0, 1] # mutable global variable\n",
    "\n",
    "def add():\n",
    "    c[0] = c[0] + 2 # while the c is being assigned with another value, it can be referenced because it's already defined in the function's scope!\n",
    "    print(\"inner c variable:\", c)\n",
    "\n",
    "add()\n",
    "print(\"global c variable:\", c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "d486a4a7",
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'c' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [59], line 7\u001b[0m\n\u001b[0;32m      4\u001b[0m     c \u001b[38;5;241m=\u001b[39m c[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;66;03m# while the c is being assigned with another value, it can be referenced because it's already defined in the function's scope!\u001b[39;00m\n\u001b[0;32m      5\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124minner c variable:\u001b[39m\u001b[38;5;124m\"\u001b[39m, c)\n\u001b[1;32m----> 7\u001b[0m \u001b[43madd\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      8\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mglobal c variable:\u001b[39m\u001b[38;5;124m\"\u001b[39m, c)\n",
      "Cell \u001b[1;32mIn [59], line 4\u001b[0m, in \u001b[0;36madd\u001b[1;34m()\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21madd\u001b[39m():\n\u001b[1;32m----> 4\u001b[0m     c \u001b[38;5;241m=\u001b[39m \u001b[43mc\u001b[49m[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;66;03m# while the c is being assigned with another value, it can be referenced because it's already defined in the function's scope!\u001b[39;00m\n\u001b[0;32m      5\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124minner c variable:\u001b[39m\u001b[38;5;124m\"\u001b[39m, c)\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'c' referenced before assignment"
     ]
    }
   ],
   "source": [
    "c = [0, 1] # global variable\n",
    "\n",
    "def add():\n",
    "    c = c[0] + 2 # while the c is being assigned with another value, it can be referenced because it's already defined in the function's scope!\n",
    "    print(\"local c variable:\", c)\n",
    "\n",
    "add()\n",
    "print(\"global c variable:\", c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "fa146266",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner c variable: 2\n",
      "global c variable: 2\n"
     ]
    }
   ],
   "source": [
    "c = [0, 1] # global variable\n",
    "\n",
    "def add():\n",
    "    global c \n",
    "    c = c[0] + 2 \n",
    "    print(\"inner c variable:\", c)\n",
    "\n",
    "add()\n",
    "print(\"global c variable:\", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28b49b9b",
   "metadata": {},
   "source": [
    "## \\*args and \\**kwargs in Python\n",
    "\n",
    "### *args\n",
    "    If you do not know how many arguments will be passed into your function, add a * before the parameter name, which conventionally is called args, in the function definition.\n",
    "\n",
    "    This way, the function will receive a tuple of arguments, and can access the items accordingly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "c17d269e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args' type: <class 'tuple'>\n",
      "hello\n",
      "dear\n",
      "friends\n",
      "Mehdi\n",
      "Ali\n",
      "zahra\n",
      "fereshteh\n",
      "pooya\n",
      "mohammadi\n"
     ]
    }
   ],
   "source": [
    "def func(*args): \n",
    "    print(\"args' type:\", type(args))\n",
    "    for arg in args:  \n",
    "        print(arg)\n",
    "func('hello', 'dear', 'friends', 'Mehdi', \"Ali\", 'zahra', \"fereshteh\", \"pooya\", \"mohammadi\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "fccfc632",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "38"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# type hinting/annotation can be used as well!\n",
    "def sum_(*args: int):\n",
    "    sum_result = 0\n",
    "    for arg in args:\n",
    "        sum_result += arg\n",
    "    return sum_result    \n",
    "sum_(0, 10, 3, 6, 9, 10, 5, -5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "7d7de4e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First argument:  Hello\n",
      "Next argument through *args:  Welcome\n",
      "Next argument through *args:  to\n",
      "Next argument through *args:  Introducton to Python\n"
     ]
    }
   ],
   "source": [
    "# positional argument alongside *args\n",
    "def func(arg_1, *args): \n",
    "    print (\"First argument: \", arg_1) \n",
    "    for arg in args: \n",
    "        print(\"Next argument through *args: \", arg) \n",
    "func('Hello', 'Welcome', 'to', 'Introducton to Python') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05aab094",
   "metadata": {},
   "source": [
    "## Arbitrary Keyword Arguments, **kwargs\n",
    "\n",
    "    If you do not know how many keyword arguments that will be passed into your function, add two asterisks ** before the parameter name in the function definition.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "4915e3cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kwargs' type: <class 'dict'>\n",
      "first: python\n",
      "mid: programming\n",
      "last: language!\n"
     ]
    }
   ],
   "source": [
    "def func(**kwargs):  \n",
    "    print(\"kwargs' type:\", type(kwargs))\n",
    "    for key, val in kwargs.items(): \n",
    "        print (f\"{key}: {val}\") \n",
    "func(first='python', mid='programming', last='language!') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "44c7616e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "func() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [70], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# Cannot call this func with positional arguments\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpython\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: func() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "# Cannot call this func with positional arguments\n",
    "func(\"python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b478849a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(part, **kwargs: int):\n",
    "    if part == 'first':\n",
    "        result = f\"this is first: {kwargs['first']}\"\n",
    "    elif part == 'second':\n",
    "        result = f\"this is second: {kwargs['second']}\"\n",
    "    elif part == 'third':\n",
    "        result = f\"this is third: {kwargs['third']}\"\n",
    "    else:\n",
    "        result = ':('\n",
    "    print(result)\n",
    "func('second', second=15)\n",
    "func('first', first=25)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f5e50f3",
   "metadata": {},
   "source": [
    "## arg and \\*args and \\**kwargs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "f0c74bb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First required argument: hi\n",
      "First kwarg: wow\n",
      "Next optional arguments through *args: there\n",
      "Next optional arguments through *args: python\n",
      "\n",
      "Finally, optional key-word arguments:\n",
      "name: pooya\n",
      "kidding: yeah\n"
     ]
    }
   ],
   "source": [
    "def func(arg_1, *args, wow=\"wow\" ,**kwargs): \n",
    "    print (\"First required argument:\", arg_1) \n",
    "    print(\"First kwarg:\", wow)\n",
    "    \n",
    "    for arg in args: \n",
    "        print(\"Next optional arguments through *args:\", arg)\n",
    "        \n",
    "    print('\\n', 'Finally, optional key-word arguments:', sep=\"\")\n",
    "    \n",
    "    for key, value in kwargs.items(): \n",
    "        print (f\"{key}: {value}\") \n",
    "        \n",
    "func('hi', 'there', 'python', name='pooya', kidding='yeah')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cffd3d1",
   "metadata": {},
   "source": [
    "### Using \\*args and \\**kwargs to call a function\n",
    "    It's also called `unpacking`!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "f6be834b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg_1: python\n",
      "arg_2: programming\n",
      "arg_3: language\n"
     ]
    }
   ],
   "source": [
    "def func(arg_1, arg_2, arg_3): \n",
    "    print(\"arg_1:\", arg_1) \n",
    "    print(\"arg_2:\", arg_2) \n",
    "    print(\"arg_3:\", arg_3)\n",
    "\n",
    "func(\"python\", \"programming\", \"language\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "8279aebe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg_1: python\n",
      "arg_2: programming\n",
      "arg_3: language\n"
     ]
    }
   ],
   "source": [
    "def func_2():\n",
    "    return (\"python\", \"programming\", \"language\")  \n",
    "\n",
    "func_2_output = func_2()\n",
    "\n",
    "# usual way\n",
    "func(func_2_output[0], func_2_output[1], func_2_output[2]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "3ad1ba16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg_1: python\n",
      "arg_2: programming\n",
      "arg_3: language\n"
     ]
    }
   ],
   "source": [
    "# remove the boilerplate\n",
    "# unpacking a tuple/list\n",
    "func(*func_2_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "8c0e7132",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg_1: 1\n",
      "arg_2: 2\n",
      "arg_3: 3\n"
     ]
    }
   ],
   "source": [
    "# unpacking an iterable\n",
    "func(*\"123\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "64772d2a",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "func() missing 1 required positional argument: 'arg_3'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [78], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m12\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: func() missing 1 required positional argument: 'arg_3'"
     ]
    }
   ],
   "source": [
    "func(*\"12\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "6773fc81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg_1: python\n",
      "arg_2: programming\n",
      "arg_3: language\n"
     ]
    }
   ],
   "source": [
    "# **kwargs\n",
    "def func_3():\n",
    "    return {\"arg_1\" : \"python\", \"arg_2\" : \"programming\", \"arg_3\" : \"language\"}  \n",
    "func_3_output = func_3()\n",
    "\n",
    "func(arg_1=func_3_output['arg_1'], arg_2=func_3_output['arg_2'], arg_3=func_3_output['arg_3'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "9cdf1fab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arg_1: python\n",
      "arg_2: programming\n",
      "arg_3: language\n"
     ]
    }
   ],
   "source": [
    "# unpacking a dict\n",
    "func(**func_3_output) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "790e126b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# other examples:\n",
    "lst = [1, 2, 3]\n",
    "lst_2 = [*lst, 4, 5]\n",
    "print(lst_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8700271",
   "metadata": {},
   "outputs": [],
   "source": [
    "dct = dict(a=\"a\", b=\"b\", c=\"c\")\n",
    "dct_2 = dict(**dct, d=\"d\")\n",
    "print(dct_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a802a33b",
   "metadata": {},
   "source": [
    "## The pass Statement and Ellipsis Mark \n",
    "\n",
    "    function definitions cannot be empty, but if you for some reason have a function definition with no content, put in the ‍‍`pass` statement or `...` immediately after colon(:) to avoid getting an error, like the following examples. Moreover, the output is None because no return is defnied!\n",
    "    pass Statement can be used to inform the python that the scope is empty!\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "8ed0142b",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block after function definition on line 1 (1430813012.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn [82], line 2\u001b[1;36m\u001b[0m\n\u001b[1;33m    pinrt(\"...\")\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block after function definition on line 1\n"
     ]
    }
   ],
   "source": [
    "def func():\n",
    "pinrt(\"...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e237d94d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def func():\n",
    "    pass\n",
    "output = func()\n",
    "print(f\"result is {output}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a19545c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def func():\n",
    "    ...\n",
    "output = func()\n",
    "print(f\"result is {output}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "6c409541",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it's equal\n"
     ]
    }
   ],
   "source": [
    "# other examples\n",
    "var = 10\n",
    "target = 10\n",
    "if target < var:\n",
    "    print(\"it's smaller\")\n",
    "elif target > var:\n",
    "    pass\n",
    "else:\n",
    "    print(\"it's equal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5777e09",
   "metadata": {},
   "source": [
    "## Mandatory Positional & Keyword Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "373bfdf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# key_words\n",
    "def pass_keywords(*, first_name, last_name):\n",
    "    print(first_name, last_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "20f5d1d0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "pass_keywords() takes 0 positional arguments but 2 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [87], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mpass_keywords\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpooya\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmohammadi\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: pass_keywords() takes 0 positional arguments but 2 were given"
     ]
    }
   ],
   "source": [
    "pass_keywords(\"pooya\", \"mohammadi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "5de3b906",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pooya mohammadi\n"
     ]
    }
   ],
   "source": [
    "# pass in with keywords\n",
    "pass_keywords(first_name=\"pooya\", last_name=\"mohammadi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "8e78ca54",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "pass_keywords() missing 1 required keyword-only argument: 'last_name'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [89], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# pass in with keywords\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mpass_keywords\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfirst_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpooya\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: pass_keywords() missing 1 required keyword-only argument: 'last_name'"
     ]
    }
   ],
   "source": [
    "# pass in with keywords\n",
    "pass_keywords(first_name=\"pooya\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "f54a4ff6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "sort() takes no positional arguments",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [90], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# real usecase\u001b[39;00m\n\u001b[0;32m      2\u001b[0m lst \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m----> 3\u001b[0m \u001b[43mlst\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msort\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: sort() takes no positional arguments"
     ]
    }
   ],
   "source": [
    "# real usecase\n",
    "lst = [1, 3, 2, 0]\n",
    "lst.sort(None, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "12651673",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "sort() takes no positional arguments",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [91], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mlst\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msort\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreverse\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: sort() takes no positional arguments"
     ]
    }
   ],
   "source": [
    "lst.sort(None, reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "9b6d7368",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst.sort(key=None, reverse=False)\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "882ffc1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a Positional Argument + kwargs\n",
    "def mixed_keywords(item, *, first_name, last_name):\n",
    "    print(item, first_name, last_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "859e7965",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 pooya mohammadi\n"
     ]
    }
   ],
   "source": [
    "mixed_keywords(10, first_name=\"pooya\", last_name=\"mohammadi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "bfdb7446",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 pooya mohammadi\n"
     ]
    }
   ],
   "source": [
    "mixed_keywords(item=10, first_name=\"pooya\", last_name=\"mohammadi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "44a745d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mandatory positional Arguments - positional-only\n",
    "def pass_positional(first_name, last_name, /):\n",
    "    print(first_name, last_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "1905c32e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "pass_positional() got some positional-only arguments passed as keyword arguments: 'first_name, last_name'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [101], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mpass_positional\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfirst_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpooya\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlast_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmohammadi\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: pass_positional() got some positional-only arguments passed as keyword arguments: 'first_name, last_name'"
     ]
    }
   ],
   "source": [
    "pass_positional(first_name=\"pooya\", last_name=\"mohammadi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "a4b7c7d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pooya mohammadi\n"
     ]
    }
   ],
   "source": [
    "pass_positional(\"pooya\", \"mohammadi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "5bdcb330",
   "metadata": {},
   "outputs": [],
   "source": [
    "# mixed positional and keyword arguments\n",
    "def pass_mixed(item, /, extra_item, *, first_name, last_name):\n",
    "    print(item, extra_item, first_name, last_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "6a8a0825",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 10 pooya mohammadi\n",
      "10 20 pooya mohammadi\n"
     ]
    }
   ],
   "source": [
    "pass_mixed(10, extra_item=10, first_name=\"pooya\", last_name=\"mohammadi\")\n",
    "pass_mixed(10, 20, first_name=\"pooya\", last_name=\"mohammadi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6928f9b0",
   "metadata": {},
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}