12. Python Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4a622bb8",
   "metadata": {},
   "source": [
    "# Python Functions\n",
    "\n",
    "- A function is a block of code which only runs when it is called.\n",
    "\n",
    "- You can pass data, known as parameters, into a function.\n",
    "\n",
    "- A function can return data as a result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b666dddf",
   "metadata": {},
   "source": [
    "## 1. Creating a Function\n",
    "- In Python a function is defined using the def keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ee4b72ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function():\n",
    "    print(\"Hello, Welcome to the Python Programming\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d908a674",
   "metadata": {},
   "source": [
    "## 2. Calling a Function\n",
    "- To call a function, use the function name followed by parenthesis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "84c61000",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Welcome to the Python Programming\n"
     ]
    }
   ],
   "source": [
    "#Creating a function\n",
    "def my_function():\n",
    "    print(\"Hello, Welcome to the Python Programming\")\n",
    "\n",
    "#calling a function\n",
    "my_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01c2d5c3",
   "metadata": {},
   "source": [
    "## 3. Arguments\n",
    "- Information can be passed into functions as arguments.\n",
    "\n",
    "- Arguments are specified after the function name, inside the parentheses. You can add as many arguments as you want, just separate them with a comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3bd21270",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Parmeet Welcome to the Python Programming\n",
      "Hello, Trishaan Welcome to the Python Programming\n",
      "Hello, Anit Welcome to the Python Programming\n"
     ]
    }
   ],
   "source": [
    "#Creating a function\n",
    "def my_function(name):\n",
    "    print(\"Hello, {} Welcome to the Python Programming\".format(name))\n",
    "\n",
    "#Calling functions with different arguments\n",
    "my_function(\"Parmeet\")\n",
    "my_function(\"Trishaan\")\n",
    "my_function(\"Anit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58964bd1",
   "metadata": {},
   "source": [
    "<b>Arguments are often shortened to args in Python documentations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3c2ff76",
   "metadata": {},
   "source": [
    "### Difference between Parameter and Argument.\n",
    "\n",
    "- From a function's perspective:\n",
    "\n",
    "    - A parameter is the variable listed inside the parentheses in the function definition.\n",
    "\n",
    "    - An argument is the value that is sent to the function when it is called."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a5dd53c",
   "metadata": {},
   "source": [
    "## 4. Number of Arguments\n",
    "- By default, a function must be called with the correct number of arguments. \n",
    "- If your function expects 2 arguments, you have to call the function with 2 arguments, not more, and not less"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d96571f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello \"Parmeet Dang\" Welcome to the Python Programming\n"
     ]
    }
   ],
   "source": [
    "#This function expects 2 arguments, and gets 2 arguments\n",
    "\n",
    "#Creating the function with 2 arguments\n",
    "def my_function(fname, lname):\n",
    "    print(\"Hello \\\"{} {}\\\" Welcome to the Python Programming\".format(fname, lname))\n",
    "\n",
    "#calling function with 2 arguments\n",
    "my_function(\"Parmeet\", \"Dang\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b13518bf",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "my_function() missing 1 required positional argument: 'lname'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-3573b60e5560>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#calling same above function with 1 argument will result in error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mmy_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Parmeet\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: my_function() missing 1 required positional argument: 'lname'"
     ]
    }
   ],
   "source": [
    "#calling same above function with 1 argument will result in error\n",
    "my_function(\"Parmeet\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53f23015",
   "metadata": {},
   "source": [
    "## 5. Arbitrary Arguments, *args\n",
    "- If you do not know how many arguments that will be passed into your function, add a * before the parameter name 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": 6,
   "id": "91725110",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome all the Python Users : ('Parmeet', 'Trishan', 'Anit') \n"
     ]
    }
   ],
   "source": [
    "#If the number of arguments is unknown, add a * before the parameter name:\n",
    "\n",
    "def my_function(*users):\n",
    "    print(\"Welcome all the Python Users : {} \".format(users))\n",
    "\n",
    "my_function(\"Parmeet\", \"Trishan\", \"Anit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b587690",
   "metadata": {},
   "source": [
    "## 5. Keyword Arguments\n",
    "- You can also send arguments with the key = value syntax.\n",
    "\n",
    "- This way the order of the arguments does not matter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1a3f0071",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi, my name is Parmeet age 28 and I belong to Indore\n"
     ]
    }
   ],
   "source": [
    "def my_function(Name, Age, Location):\n",
    "    print(\"Hi, my name is {} age {} and I belong to {}\".format(Name,Age,Location))\n",
    "\n",
    "my_function(Name = \"Parmeet\", Age = 28, Location = \"Indore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b9ea25a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Welcome\n",
      "to\n",
      "Python\n",
      "Programming\n"
     ]
    }
   ],
   "source": [
    "#function can take n number of arguments\n",
    "def myFun(*argv):\n",
    "    for arg in argv:\n",
    "        print(arg)\n",
    " \n",
    " \n",
    "myFun('Hello', 'Welcome', 'to', 'Python', 'Programming')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eacb7844",
   "metadata": {},
   "source": [
    "## 6. Arbitrary Keyword Arguments, **kwargs\n",
    "- If you do not know how many keyword arguments that will be passed into your function, add two asterisk: ** before the parameter name in the function definition.\n",
    "\n",
    "- This way the function will receive a dictionary of arguments, and can access the items accordingly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "dc63a10e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi, my name is Parmeet age 28 and I belong to Indore\n"
     ]
    }
   ],
   "source": [
    "def my_function(**details):\n",
    "    print(\"Hi, my name is {} age {} and I belong to {}\".format(details[\"Name\"],details[\"Age\"],details[\"Location\"]))\n",
    "\n",
    "my_function(Name = \"Parmeet\", Age = 28, Location = \"Indore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4f11ee83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name == Parmeet\n",
      "Age == 28\n",
      "Location == Indore\n"
     ]
    }
   ],
   "source": [
    "#function can take n number of keyword arguments\n",
    "def myFun(**kwargs):\n",
    "    for key, value in kwargs.items():\n",
    "        print(\"%s == %s\" % (key, value))\n",
    " \n",
    " \n",
    "myFun(Name = \"Parmeet\", Age = 28, Location = \"Indore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fedce9d5",
   "metadata": {},
   "source": [
    "## 7. Default Parameter Value\n",
    "- The following example shows how to use a default parameter value.\n",
    "\n",
    "- If we call the function without argument, it uses the default value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "bad0b1f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am from Sweden\n",
      "I am from Norway\n",
      "I am from India\n",
      "I am from Brazil\n"
     ]
    }
   ],
   "source": [
    "def my_function(country = \"India\"):\n",
    "    print(\"I am from \" + country)\n",
    "\n",
    "#calling the functions\n",
    "my_function(\"Sweden\")\n",
    "my_function(\"Norway\")\n",
    "my_function() #calling function with no argument will return India\n",
    "my_function(\"Brazil\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b802203f",
   "metadata": {},
   "source": [
    "## 8. Passing a List as an Argument\n",
    "- You can send any data types of argument to a function (string, number, list, dictionary etc.), and it will be treated as the same data type inside the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1be5cd85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pizza\n",
      "sandwich\n",
      "Burger\n",
      "Pasta\n"
     ]
    }
   ],
   "source": [
    "#creating a function\n",
    "def my_function(food):\n",
    "    for x in food:\n",
    "        print(x)\n",
    "\n",
    "items = [\"Pizza\", \"sandwich\", \"Burger\",\"Pasta\"]\n",
    "\n",
    "my_function(items) #passing list as an argument"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fc06db8",
   "metadata": {},
   "source": [
    "## 9. Return Values\n",
    "- To let a function return a value, use the return statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9dccc2b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "25\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "#function that return square of any number\n",
    "def square(x):\n",
    "    return x**2\n",
    "\n",
    "print(square(3))\n",
    "print(square(5))\n",
    "print(square(9))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8fb5799",
   "metadata": {},
   "source": [
    "## 10. The pass Statement\n",
    "- function definitions cannot be empty, but if you for some reason have a function definition with no content, put in the pass statement to avoid getting an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "98752b1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunction():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26189df4",
   "metadata": {},
   "source": [
    "## 11. Recursion\n",
    "- Python also accepts function recursion, which means a defined function can call itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "de5dbbf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n==1:\n",
    "        return n\n",
    "    else:\n",
    "        return n * factorial(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e5e37996",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d24dc494",
   "metadata": {},
   "source": [
    "## 12.  Python program to demonstrate default arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9b5ffe42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x:  10\n",
      "y:  100\n"
     ]
    }
   ],
   "source": [
    "#creating a function with default arguments \n",
    "def myFun(x, y=100):\n",
    "    print(\"x: \", x)\n",
    "    print(\"y: \", y)\n",
    " \n",
    " \n",
    "# Calling the function\n",
    "myFun(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e028fc3",
   "metadata": {},
   "source": [
    "## 13. Adding Docstring to the function\n",
    "- <b>Syntax: print(function_name.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b9a7e045",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evenOdd(x):\n",
    "    \"\"\"Function to check if the number is even or odd\"\"\"\n",
    "     \n",
    "    if (x % 2 == 0):\n",
    "        print(\"even\")\n",
    "    else:\n",
    "        print(\"odd\")\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a72f9904",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Function to check if the number is even or odd\n"
     ]
    }
   ],
   "source": [
    "print(evenOdd.__doc__) #printing function docstring"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1aefde0",
   "metadata": {},
   "source": [
    "## 14. Python Function within Functions\n",
    "- A function that is defined inside another function is known as the inner function or nested function. \n",
    "- Nested functions are able to access variables of the enclosing scope. \n",
    "- Inner functions are used so that they can be protected from everything happening outside the function.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "debbc658",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start of Outer Function\n",
      "Hello..!!\n",
      "End of Outer Function\n",
      "Start of Inner Function\n",
      "I love Python Programming..!!!\n",
      "End of Iner Function\n"
     ]
    }
   ],
   "source": [
    "def f1():\n",
    "    print(\"Start of Outer Function\")\n",
    "    print(\"Hello..!!\")\n",
    "    s = 'I love Python Programming..!!!'\n",
    "    print(\"End of Outer Function\") \n",
    "    def f2():\n",
    "        print(\"Start of Inner Function\")\n",
    "        print(s)\n",
    "        print(\"End of Iner Function\")\n",
    "         \n",
    "    f2()\n",
    " \n",
    "#calling function\n",
    "f1() #This function internally calls f2 and print the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c4c9baa",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}