code/08-functions.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",
    "- [Functions](#toc1_)    \n",
    "  - [Basics](#toc1_1_)    \n",
    "  - [Handle Returned values](#toc1_2_)    \n",
    "  - [🗂️ Types of parameters](#toc1_3_)    \n",
    "  - [All In One Example](#toc1_4_)    \n",
    "  - [Recursive Functions](#toc1_5_)    \n",
    "    - [Example 1: Factorial Calculation](#toc1_5_1_)    \n",
    "    - [Example 2: Fibonacci Sequence](#toc1_5_2_)    \n",
    "    - [Example 3: Sum of a List](#toc1_5_3_)    \n",
    "    - [Example 4: Recursive Directory Traversal](#toc1_5_4_)    \n",
    "    - [Example 5: Tower of Hanoi](#toc1_5_5_)    \n",
    "  - [First-Class Objects](#toc1_6_)    \n",
    "    - [Assigning Functions to Variables](#toc1_6_1_)    \n",
    "    - [Passing Functions as Arguments](#toc1_6_2_)    \n",
    "    - [Returning Functions from Functions](#toc1_6_3_)    \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>[Functions](#toc0_)\n",
    "\n",
    "- Functions allow you to encapsulate reusable code blocks that can be executed when called.\n",
    "- Functions can take inputs (parameters) and return outputs (values), helping to structure and organize code.\n",
    "\n",
    "🗂️ **Types of functions**:\n",
    "\n",
    "- Built-in Functions:\n",
    "  - Predefined functions such as `len()`, `print()`, and `range()`.\n",
    "- User-defined Functions:\n",
    "  - Functions that you define using the `def` keyword.\n",
    "- [Anonymous Functions](./11-anonymous-functions.ipynb) (`lambda`):\n",
    "  - Short, one-liner functions defined using the `lambda` keyword.\n",
    "\n",
    "🔤 **Basic Syntax**\n",
    "\n",
    "   ```python\n",
    "      def my_function(param1, param2):\n",
    "         # Code block to execute\n",
    "         return param1 + param2\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "📝 **Docs**:\n",
    "\n",
    "- Function Definition: [docs.python.org/3/tutorial/controlflow.html#defining-functions](https://docs.python.org/3/tutorial/controlflow.html#defining-functions)\n",
    "- Function Parameters: [docs.python.org/3/tutorial/controlflow.html#more-on-defining-functions](https://docs.python.org/3/tutorial/controlflow.html#more-on-defining-functions)\n",
    "- Types of Arguments: [docs.python.org/3/glossary.html#term-argument](https://docs.python.org/3/glossary.html#term-argument)\n",
    "- Scope of Variables: [docs.python.org/3/tutorial/classes.html#python-scopes-and-namespaces](https://docs.python.org/3/tutorial/classes.html#python-scopes-and-namespaces)\n",
    "- Higher-order functions: [docs.python.org/3/library/functools.html](https://docs.python.org/3/library/functools.html)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_1_'></a>[Basics](#toc0_)\n",
    "\n",
    "**Define a function**\n",
    "\n",
    "```python\n",
    "    def <function_name>(<parameters>):\n",
    "        <statement(s)>\n",
    "```\n",
    "\n",
    "**Call a function**\n",
    "\n",
    "```python\n",
    "    <function_name>(<arguments>)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "# a function to print \"Hello\"\n",
    "def hello():\n",
    "    print(\"Hello\")\n",
    "\n",
    "\n",
    "# log\n",
    "hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Amir\n",
      "Hello Michael\n",
      "Hello Sara\n"
     ]
    }
   ],
   "source": [
    "# a function to greet a person named <name>\n",
    "def greet(name):\n",
    "    print(f\"Hello {name}\")\n",
    "\n",
    "\n",
    "# log\n",
    "greet(\"Amir\")\n",
    "greet(\"Michael\")\n",
    "greet(name=\"Sara\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1+2=3\n",
      "3+4=7\n",
      "3+1=4\n",
      "3+1=4\n"
     ]
    }
   ],
   "source": [
    "# a function to calculate and print the a + b\n",
    "def add(a, b):\n",
    "    print(f\"{a}+{b}={a+b}\")\n",
    "\n",
    "\n",
    "# log\n",
    "add(1, 2)\n",
    "add(3, b=4)\n",
    "add(a=3, b=1)\n",
    "add(b=1, a=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_2_'></a>[Handle Returned values](#toc0_)\n",
    "\n",
    "✍️ **Note**: A function always returns value even without having `return` section and returns `None` in this case.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amir\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# define a function\n",
    "def foo(a):\n",
    "    print(a)\n",
    "\n",
    "\n",
    "# function call\n",
    "result_1 = foo(\"Amir\")\n",
    "\n",
    "# log\n",
    "print(result_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Amir, what's up?\n"
     ]
    }
   ],
   "source": [
    "# define a function\n",
    "def hello_2(name):\n",
    "    return f\"Hello {name}, what's up?\"\n",
    "\n",
    "\n",
    "# function call\n",
    "result_2 = hello_2(\"Amir\")\n",
    "\n",
    "# log\n",
    "print(result_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the result is: 6\n"
     ]
    }
   ],
   "source": [
    "# define a function\n",
    "def subtract(a, b):\n",
    "    return a - b\n",
    "\n",
    "\n",
    "# function call\n",
    "result_3 = subtract(10, 4)\n",
    "\n",
    "# log\n",
    "print(f\"the result is: {result_3}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 / 2 = 5.0\n"
     ]
    }
   ],
   "source": [
    "# define a function\n",
    "def division(a, b):\n",
    "    div = a / b\n",
    "    return a, b, div\n",
    "\n",
    "\n",
    "# function call\n",
    "num_1, num_2, result_4 = division(10, 2)\n",
    "\n",
    "# log\n",
    "print(f\"{num_1} / {num_2} = {result_4}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_3_'></a>[🗂️ Types of parameters](#toc0_)\n",
    "\n",
    "- Positional-Only Parameters\n",
    "  - These parameters can only be passed by position and not by keyword\n",
    "  - The slash (`/`) separates positional-only parameters from the rest\n",
    "- Positional-or-Keyword Parameters\n",
    "  - These parameters can be passed either by position or by keyword\n",
    "  - This is the default type if no `/` or `*` is used\n",
    "- Variable Positional Parameters (`*args`)\n",
    "  - These parameters collect any additional positional arguments into a `tuple`\n",
    "  - Useful when you want to accept an arbitrary number of positional arguments\n",
    "- Keyword-Only Parameters\n",
    "  - These parameters must be passed by keyword and cannot be passed by position\n",
    "  - The asterisk (`*`) separates positional-or-keyword parameters from keyword-only parameters\n",
    "- Variable Keyword Parameters (`**kwargs`)\n",
    "  - These parameters collect any additional keyword arguments into a dictionary\n",
    "  - Useful when you want to accept an arbitrary number of keyword arguments\n",
    "- Default Arguments\n",
    "  - These parameters have default values that are used if no value is provided in the function call.\n",
    "  - They must appear after all non-default parameters in the function definition.\n",
    "\n",
    "✍️ **Notes**:\n",
    "\n",
    "- Parameters: Defined in the function definition\n",
    "- Arguments: Passed during the function call\n",
    "- positional parameters are always before keyword parameters\n",
    "\n",
    "🔤 **Rule of Thumb**\n",
    "\n",
    "```python\n",
    "   def func_1(pos1, pos2, *args, kwd1, kwd2, **kwargs)\n",
    "   def func_2(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2, **kwargs)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jane from Nepal whose id is 0\n",
      "Frank from Finland whose id is 22\n",
      "Monica from USA whose id is 1\n"
     ]
    }
   ],
   "source": [
    "def info(name, /, country, id=0):\n",
    "    print(f\"{name} from {country} whose id is {id}\")\n",
    "\n",
    "\n",
    "# function call\n",
    "info(\"Jane\", \"Nepal\")\n",
    "info(\"Frank\", \"Finland\", 22)\n",
    "info(\"Monica\", id=1, country=\"USA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pos1: 1\n",
      "pos2: 2\n",
      "pos_or_kwd: 3\n",
      "args: (4, 5)\n",
      "kwd1: a\n",
      "kwd2: b\n",
      "kwargs: {'extra1': 'extra', 'extra2': 'stuff'}\n"
     ]
    }
   ],
   "source": [
    "def example(pos1, pos2, /, pos_or_kwd, *args, kwd1, kwd2, **kwargs):\n",
    "    print(f\"pos1: {pos1}\")\n",
    "    print(f\"pos2: {pos2}\")\n",
    "    print(f\"pos_or_kwd: {pos_or_kwd}\")\n",
    "    print(f\"args: {args}\")\n",
    "    print(f\"kwd1: {kwd1}\")\n",
    "    print(f\"kwd2: {kwd2}\")\n",
    "    print(f\"kwargs: {kwargs}\")\n",
    "\n",
    "\n",
    "# function call\n",
    "example(1, 2, 3, 4, 5, kwd1=\"a\", kwd2=\"b\", extra1=\"extra\", extra2=\"stuff\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_4_'></a>[All In One Example](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_average(scores):\n",
    "    if not scores:\n",
    "        return 0.0\n",
    "    return sum(scores) / len(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def format_user_info(name, age, city=None, *hobbies, **extra_info):\n",
    "\n",
    "    # calculate a hypothetical score based on age and number of hobbies\n",
    "    score = (age + len(hobbies)) * 10\n",
    "    average_score = calculate_average([score])  # Example usage of another function\n",
    "\n",
    "    # create a basic info string\n",
    "    info = f\"Name: {name}\\nAge: {age}\\n\"\n",
    "    if city:\n",
    "        info += f\"City: {city}\\n\"\n",
    "    if hobbies:\n",
    "        info += f\"Hobbies: {', '.join(hobbies)}\\n\"\n",
    "\n",
    "    # add extra info if provided\n",
    "    if extra_info:\n",
    "        extra_info_str = \", \".join(f\"{key}: {value}\" for key, value in extra_info.items())\n",
    "        info += f\"Additional Info: {extra_info_str}\\n\"\n",
    "\n",
    "    # append average score\n",
    "    info += f\"Average Score: {average_score:.2f}\"\n",
    "\n",
    "    return info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Alice\n",
      "Age: 30\n",
      "City: New York\n",
      "Hobbies: Reading, Traveling, Cooking\n",
      "Additional Info: profession: Engineer, interests: Music\n",
      "Average Score: 330.00\n"
     ]
    }
   ],
   "source": [
    "# function call\n",
    "user_info = format_user_info(\"Alice\", 30, \"New York\", \"Reading\", \"Traveling\", \"Cooking\", profession=\"Engineer\", interests=\"Music\")\n",
    "\n",
    "# log\n",
    "print(user_info)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_5_'></a>[Recursive Functions](#toc0_)\n",
    "\n",
    "- Recursive functions are functions that call themselves in order to solve a problem.\n",
    "- They break down a complex problem into simpler sub-problems and solve them by repeatedly invoking themselves.\n",
    "- There is a limit to how many times a function can recursively call itself\n",
    "- If the recursion depth exceeds the system’s stack size, it results in a `RecursionError: maximum recursion depth exceeded`\n",
    "\n",
    "🏗️ **Structure of a Recursive Function**:\n",
    "\n",
    "- Define the \"base case\" that will stop the recursion.\n",
    "- Define the \"recursive case\", which moves toward the base case.\n",
    "\n",
    "👍 **Advantages of Recursion**:\n",
    "\n",
    "- **Simplifies Code**: Recursion can simplify the implementation of complex algorithms e.g. nested or hierarchical data structures like trees or graphs.\n",
    "- **Divide-and-Conquer Problems**: Problems like merge sort, quicksort, and binary search are easier to express with recursion.\n",
    "\n",
    "👎 **Disadvantages of Recursion**:\n",
    "\n",
    "- **Performance**: Recursive functions due to repeated function calls, require additional memory (stack space).\n",
    "- **Tricky to Debug**: It’s sometimes harder to debug recursive functions due to the repeated calls.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "old recursion limit: 3000\n",
      "new recursion limit: 5000\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "# to check the current recursion limit\n",
    "print(f\"old recursion limit: {sys.getrecursionlimit()}\")\n",
    "\n",
    "# to set a new recursion limit\n",
    "sys.setrecursionlimit(5000)\n",
    "print(f\"new recursion limit: {sys.getrecursionlimit()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_5_1_'></a>[Example 1: Factorial Calculation](#toc0_)\n",
    "\n",
    "The factorial of a number `n` is defined as:\n",
    "$$n! = n \\times (n-1) \\times (n-2) \\times (n-3) \\dots \\times 1$$\n",
    "\n",
    "<figure style=\"text-align: center;\">\n",
    "  <img src=\"../assets/images/svgs/recursive-factorial.svg\" alt=\"recursive-factorial.svg\" style=\"width: 75%;\">\n",
    "  <figcaption style=\"text-align:center;\">Factorial Calculation</figcaption>\n",
    "</figure>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "24\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "def factorial(n: int) -> int:\n",
    "    # base case: factorial of 1 or 0 is 1\n",
    "    if n == 1 or n == 0:\n",
    "        return 1\n",
    "\n",
    "    # recursive case\n",
    "    return n * factorial(n - 1)\n",
    "\n",
    "\n",
    "# log\n",
    "print(factorial(3))\n",
    "print(factorial(4))\n",
    "print(factorial(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "24\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "# note: recursive functions can be replaced with iterative functions\n",
    "def factorial_2(n: int) -> int:\n",
    "    result = 1\n",
    "    for i in range(1, n + 1):\n",
    "        result *= i\n",
    "    return result\n",
    "\n",
    "\n",
    "# log\n",
    "print(factorial_2(3))\n",
    "print(factorial_2(4))\n",
    "print(factorial_2(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_5_2_'></a>[Example 2: Fibonacci Sequence](#toc0_)\n",
    "\n",
    "The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones:\n",
    "$$F(0) = 0, \\quad F(1) = 1$$\n",
    "$$F(n) = F(n-1) + F(n-2) \\quad \\text{for } n \\geq 2$$\n",
    "$$\\text{Fibonacci Sequence}: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, \\dots$$\n",
    "\n",
    "<figure style=\"text-align: center;\">\n",
    "  <img src=\"../assets/images/svgs/recursive-fibonacci.svg\" alt=\"recursive-fibonacci.svg\" style=\"width: 75%;\">\n",
    "  <figcaption style=\"text-align:center;\">Fibonacci Sequence</figcaption>\n",
    "</figure>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "def fibonacci(n: int) -> int:\n",
    "    # base case 1\n",
    "    if n == 0:\n",
    "        return 0\n",
    "\n",
    "    # base case 2\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "\n",
    "    # recursive cacse\n",
    "    return fibonacci(n - 1) + fibonacci(n - 2)\n",
    "\n",
    "\n",
    "# log\n",
    "print(fibonacci(4))\n",
    "print(fibonacci(5))\n",
    "print(fibonacci(6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# note: recursive functions can be replaced with iterative functions\n",
    "def fibonacci_2(n: int) -> int:\n",
    "    a, b = 0, 1\n",
    "    for _ in range(n):\n",
    "        a, b = b, a + b\n",
    "    return a\n",
    "\n",
    "\n",
    "# log\n",
    "print(fibonacci(4))\n",
    "print(fibonacci(5))\n",
    "print(fibonacci(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_5_3_'></a>[Example 3: Sum of a List](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "13\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "def sum_list(numbers: list[int]) -> int:\n",
    "    # base case: empty list\n",
    "    if not numbers:\n",
    "        return 0\n",
    "\n",
    "    # recursion case\n",
    "    return numbers[0] + sum_list(numbers[1:])\n",
    "\n",
    "\n",
    "# log\n",
    "print(sum_list([1, 2, 3]))\n",
    "print(sum_list([5, 8, 0]))\n",
    "print(sum_list([9, 9, 9]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_5_4_'></a>[Example 4: Recursive Directory Traversal](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File: ./built-in methods/dictionary-methods.ipynb\n",
      "File: ./built-in methods/list-methods.ipynb\n",
      "File: ./built-in methods/number-methods.ipynb\n",
      "File: ./built-in methods/set-methods.ipynb\n",
      "File: ./built-in methods/string-methods.ipynb\n",
      "File: ./built-in methods/tuple-methods.ipynb\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "\n",
    "# this recursive function has implicit base case\n",
    "def list_files(directory: str) -> None:\n",
    "    for item in os.listdir(directory):\n",
    "        path = os.path.join(directory, item)\n",
    "\n",
    "        # recursive case: directory\n",
    "        if os.path.isdir(path):\n",
    "            print(f\"Directory: {path}\")\n",
    "            list_files(path)\n",
    "        else:\n",
    "            print(f\"File: {path}\")\n",
    "\n",
    "\n",
    "# log\n",
    "print(list_files(\"./built-in methods/\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_5_5_'></a>[Example 5: Tower of Hanoi](#toc0_)\n",
    "\n",
    "- Only one disk can be moved at a time.\n",
    "- A disk can only be placed on top of a larger disk (or an empty rod).\n",
    "- The goal is to move all disks from the source rod to the target rod, using an auxiliary rod if necessary.\n",
    "\n",
    "💡 **Recursion in the Tower of Hanoi**:\n",
    "\n",
    "- **Base Case**: When there's only one disk, simply move it from the source rod to the target rod.\n",
    "- **Recursive Case**: When there are more than one disk, the problem is solved by:\n",
    "  - Moving `n-1` disks from the source rod to the auxiliary rod.\n",
    "  - Moving the last (largest) disk directly to the target rod.\n",
    "  - Moving the `n-1` disks from the auxiliary rod to the target rod.\n",
    "- Link: [en.wikipedia.org/wiki/Tower_of_Hanoi](https://en.wikipedia.org/wiki/Tower_of_Hanoi)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move disk 1 from A to C\n",
      "Move disk 2 from A to B\n",
      "Move disk 1 from C to B\n",
      "Move disk 3 from A to C\n",
      "Move disk 1 from B to A\n",
      "Move disk 2 from B to C\n",
      "Move disk 1 from A to C\n"
     ]
    }
   ],
   "source": [
    "def hanoi_tower(n: int, source: str, target: str, auxiliary: str) -> None:\n",
    "    # base case: only one disk to move\n",
    "    if n == 1:\n",
    "        print(f\"Move disk 1 from {source} to {target}\")\n",
    "        return\n",
    "\n",
    "    # recursive case:\n",
    "    hanoi_tower(n - 1, source, auxiliary, target)  # Move n-1 disks from source to auxiliary\n",
    "    print(f\"Move disk {n} from {source} to {target}\")  # Move nth disk from source to target\n",
    "    hanoi_tower(n - 1, auxiliary, target, source)  # Move n-1 disks from auxiliary to target\n",
    "\n",
    "\n",
    "# log\n",
    "hanoi_tower(3, \"A\", \"C\", \"B\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_6_'></a>[First-Class Objects](#toc0_)\n",
    "\n",
    "- Functions can be `passed as arguments`, `returned by other functions`, and `assigned to variables`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_6_1_'></a>[Assigning Functions to Variables](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n"
     ]
    }
   ],
   "source": [
    "def greet(name):\n",
    "    return f\"Hello, {name}!\"\n",
    "\n",
    "\n",
    "# assign function to a variable\n",
    "say_hello = greet\n",
    "\n",
    "# log\n",
    "print(say_hello(\"Alice\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_6_2_'></a>[Passing Functions as Arguments](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Bob!\n"
     ]
    }
   ],
   "source": [
    "def greet(name):\n",
    "    return f\"Hello, {name}!\"\n",
    "\n",
    "\n",
    "# a function which accepts another function as an argument\n",
    "def apply_function(func, value):\n",
    "    return func(value)\n",
    "\n",
    "\n",
    "# log\n",
    "print(apply_function(greet, \"Bob\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a id='toc1_6_3_'></a>[Returning Functions from Functions](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# a function which creates and returns another function\n",
    "def create_multiplier(x):\n",
    "    def multiplier(n):\n",
    "        return x * n\n",
    "\n",
    "    return multiplier\n",
    "\n",
    "\n",
    "double = create_multiplier(2)\n",
    "\n",
    "# log\n",
    "print(double(5))"
   ]
  }
 ],
 "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
}