{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. Functions\n",
    "\n",
    "**Functions** are reusable blocks of code that perform specific tasks. They are a fundamental building block of Python programming, allowing you to organize your code, improve readability, and promote reusability.\n",
    "\n",
    "We'll learn about the following topics:\n",
    "\n",
    "   - [11.1. Creating Functions](#Creating_Functions)\n",
    "   - [11.2. Nested Functions](#Nested_Functions)\n",
    "   - [11.3. Special Built-in Functions (map, filter, lambda, all, any)](#Special_Builtin_Functions)\n",
    "   - [11.4. *args and *kargs](#args_kargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"center\">\n",
    "  <img width=\"550\" height=\"300\" src=\"https://realpython.com/cdn-cgi/image/width=960,format=auto/https://files.realpython.com/media/Defining-Your-Own-Python-Function_Watermarked.d18ffb243c6e.jpg\">\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Creating_Functions'></a>\n",
    "\n",
    "## 11.1. Creating Functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In programming, a function is a reusable block of code that performs a specific task. It takes input arguments (optional) and returns an output value (optional). Functions provide a way to organize code into logical and reusable units, making it easier to manage and maintain your program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Defining a Function**: In Python, you can define a function using the **def** keyword, followed by the function name and a pair of parentheses. The general syntax is as follows:\n",
    "\n",
    "``def function_name(arguments):\n",
    "    Function body\n",
    "    Code block to perform specific tasks\n",
    "    Return statement (optional)``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet():\n",
    "    print('Hello, there!')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(greet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we defined a function named greet without any arguments. The function body consists of a single line that prints the greeting message."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Calling a Function**: To execute a function and perform its defined tasks, you need to call it by its name followed by parentheses. For example, to call the greet() function we defined earlier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, there!\n"
     ]
    }
   ],
   "source": [
    "greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Function Arguments**: Functions can accept input values called arguments or parameters. Arguments allow you to pass data to the function for it to process. You can define multiple arguments by separating them with commas inside the parentheses when defining the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(name):\n",
    "    print(f'Hello, {name}!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can call the greet() function by passing a name as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Pegah!\n"
     ]
    }
   ],
   "source": [
    "greet('Pegah')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Return Statement**: Functions can also return values back to the caller using the return statement. This allows you to use the result of a function in further computations or store it in a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(name):\n",
    "    return f'Hello, {name}!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can call the greet() function and capture its return value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Pegah!\n"
     ]
    }
   ],
   "source": [
    "message = greet('Pegah')\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Function with Multiple Arguments**: You can define functions with multiple arguments by separating them with commas when defining the function, and pass corresponding values in the same order when calling the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_numbers(a, b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can call the add_numbers() function by passing two numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "result = add_numbers(5, 7)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Default Arguments**: Python allows you to specify default values for function arguments. These default values are used if no argument is provided when calling the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(name='there'):\n",
    "    return f'Hello, {name}!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can call the greet() function without providing an argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, there!\n"
     ]
    }
   ],
   "source": [
    "message = greet()\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we provide an argument, it will override the default value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Pegah!\n"
     ]
    }
   ],
   "source": [
    "message = greet('Pegah')\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Variable Scope**: Variables defined inside a function have local scope, which means they are only accessible within that function. Similarly, variables defined outside of any function have global scope and can be accessed from any part of the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "def multiply(a, b):\n",
    "    result = a * b\n",
    "    return result\n",
    "\n",
    "product = multiply(3, 4)\n",
    "print(product)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the variable result is defined within the multiply() function and can't be accessed outside of it. However, the variable product is defined outside of any function and can be printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def even_check(number):\n",
    "    return number % 2 == 0\n",
    "\n",
    "even_check(25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def check_even_list(num_list):\n",
    "    for number in num_list:\n",
    "        if number % 2 != 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "check_even_list([2,6,12]), check_even_list([9,5,7])     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def check_even_list(num_list):\n",
    "    \n",
    "    even_numbers = []\n",
    "    \n",
    "    for number in num_list:\n",
    "        if number % 2 == 0:\n",
    "            even_numbers.append(number)\n",
    "        else:\n",
    "            pass\n",
    "    return even_numbers\n",
    "\n",
    "check_even_list([2,5,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pick a number: 0, 1, or 2:  3\n",
      "Pick a number: 0, 1, or 2:  2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def player_guess():    \n",
    "    guess = ''   \n",
    "    while guess not in ['0','1','2']:        \n",
    "        guess = input('Pick a number: 0, 1, or 2:  ')    \n",
    "    return int(guess)    \n",
    "\n",
    "player_guess()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The provided Python code defines a function named player_guess() that prompts the user to input a number between 0 and 2. It continues to prompt the user until a valid input is provided."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Nested_Functions'></a>\n",
    "\n",
    "## 11.2. Nested Functions:\n",
    "\n",
    "Nested functions in Python refer to the concept of defining a function inside another function. In other words, a function can be declared and defined within the body of another function. These nested functions are also known as inner functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the outer function.\n",
      "This is the inner function.\n"
     ]
    }
   ],
   "source": [
    "def outer_function():\n",
    "    print('This is the outer function.')\n",
    "\n",
    "    def inner_function():\n",
    "        print('This is the inner function.')\n",
    "\n",
    "    inner_function()\n",
    "\n",
    "outer_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, we have an outer function named outer_function(). Inside this function, there is another function called inner_function(). The inner_function() is defined and declared within the body of the outer_function()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "def outer_function(x):\n",
    "    def inner_function(y):\n",
    "        return x + y\n",
    "    \n",
    "    result = inner_function(5)\n",
    "    return result\n",
    "\n",
    "result = outer_function(10)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Special_Builtin_Functions'></a>\n",
    "\n",
    "## 11.3. Special Built-in Functions (map, filter, lambda, all, any):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`map`**: The map() function in Python is a built-in function that applies a given function to each item of an iterable (like a list, tuple, or string) and returns a new iterable.\n",
    "\n",
    "`map(function, iterable)`\n",
    "\n",
    "- function: The function to be applied to each item in the iterable.\n",
    "- iterable: The iterable object (list, tuple, string, etc.) whose elements will be passed to the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_root(num):\n",
    "    return num**0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [4, 9, 16, 25, 36]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x24d2c29bd30>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(get_root, nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the results, either iterate through map() or cast the results to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.0, 3.0, 4.0, 5.0, 6.0]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(get_root, nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`filter`**: The filter() function in Python is a built-in function that creates a new iterator object containing elements from an iterable that satisfy a given function.\n",
    "\n",
    "`filter(function, iterable)`\n",
    "\n",
    "- function: A function that takes an element as input and returns a boolean value. Elements that return True are included in the filtered iterator.\n",
    "- iterable: Any iterable object, such as a list, tuple, or string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_even(num):\n",
    "    return num % 2 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<filter at 0x24d2c2b2040>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filter(get_even, nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 16, 36]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(get_even, nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`lambda`**: A lambda function is a small, anonymous function defined using the lambda keyword. It's often used for simple, one-line functions that are needed temporarily.\n",
    "\n",
    "`lambda arguments: expression`\n",
    "\n",
    "- lambda: A keyword indicating that you're defining a lambda function.\n",
    "- arguments: A list of arguments that the function takes.\n",
    "- expression: The expression that is evaluated and returned by the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "add = lambda x, y: x + y\n",
    "result = add(5, 3)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we've defined a lambda function add that takes two arguments x and y and returns their sum. We then call the function and print the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "squared_numbers = list(map(lambda x: x**2, numbers))\n",
    "print(squared_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "even_numbers = list(filter(lambda x: x % 2 == 0, numbers))\n",
    "print(even_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 1, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "sorted_numbers = sorted(numbers, key=lambda x: x % 2)\n",
    "print(sorted_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "str_list = ['apple', 'banana', 'peach', 'melon']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['elppa', 'ananab', 'hcaep', 'nolem']\n"
     ]
    }
   ],
   "source": [
    "reverse_str = list(map(lambda x: x[::-1], str_list))\n",
    "print(reverse_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`all`**: The all() function in Python is a built-in function that returns True if all elements in an iterable are true, otherwise it returns False.\n",
    "\n",
    "`all(iterable)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "all_positive = all(num > 0 for num in numbers)\n",
    "print(all_positive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, -3, 4, 5]\n",
    "all_positive = all(num > 0 for num in numbers)\n",
    "print(all_positive)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`any`**: any() is a built-in function in Python that takes an iterable (like a list, tuple, or dictionary) as input and returns True if any of the elements in the iterable are True. If all elements are False or the iterable is empty, it returns False.\n",
    "\n",
    "`any(iterable)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "numbers = [-1, -2, -3, -4, -5]\n",
    "atleast_one_positive = any(num > 0 for num in numbers)\n",
    "print(atleast_one_positive)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='args_kargs'></a>\n",
    "\n",
    "## 11.4. *args and *kargs:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`*args`**: *args in Python functions is a special syntax used to pass a variable number of arguments to a function. These arguments are collected into a tuple and can be accessed within the function using the args variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def myfunc(*args):\n",
    "    return sum(args) / 2\n",
    "\n",
    "myfunc(25, 60, 35)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The term args is just a convention; you can use any word as long as it's preceded by an asterisk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60.0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def myfunc(*nums):\n",
    "    return sum(nums) / 2\n",
    "\n",
    "myfunc(25, 60, 35)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can combine *args with other parameters, but the *args parameter must be the last parameter in the function definition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "110\n"
     ]
    }
   ],
   "source": [
    "def calculate_total(price, *quantities):\n",
    "    total = price\n",
    "    for quantity in quantities:\n",
    "        total += price * quantity\n",
    "    return total\n",
    "\n",
    "price = 10\n",
    "quantities = (5, 3, 2)\n",
    "total_cost = calculate_total(price, *quantities)\n",
    "print(total_cost)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`*kargs`**: *kargs in Python is a special syntax used to pass a variable number of keyword arguments to a function. These arguments are collected into a dictionary, where the keys are the argument names and the values are the corresponding values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name Alice\n",
      "age 30\n",
      "city New York\n"
     ]
    }
   ],
   "source": [
    "def print_kwargs(**kwargs):\n",
    "    for key, value in kwargs.items():\n",
    "        print(key, value)\n",
    "\n",
    "print_kwargs(name=\"Alice\", age=30, city=\"New York\")"
   ]
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}