001_Python_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Functions\n",
    "\n",
    "In this class, you'll learn about functions, what a function is, the syntax, components, and types of functions. Also, you'll learn to create a function in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is a function in Python?\n",
    "\n",
    "In Python, a **function is a block of organized, reusable (DRY- Don’t Repeat Yourself) code with a name** that is used to perform a single, specific task. It can take arguments and returns the value.\n",
    "\n",
    "Functions help break our program into smaller and modular chunks. As our program grows larger and larger, functions make it more organized and manageable.\n",
    "\n",
    "Furthermore, it improves efficiency and reduces errors because of the reusability of a code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types of Functions\n",
    "\n",
    "Python support two types of functions\n",
    "\n",
    "1. **[Built-in](https://github.com/milaan9/04_Python_Functions/tree/main/002_Python_Functions_Built_in)** function\n",
    "2. **[User-defined](https://github.com/milaan9/04_Python_Functions/blob/main/Python_User_defined_Functions.ipynb)** function\n",
    "\n",
    "1.**Built-in function**\n",
    "\n",
    "The functions which are come along with Python itself are called a built-in function or predefined function. Some of them are:\n",
    "**`range()`**, **`print()`**, **`input()`**, **`type()`**, **`id()`**, **`eval()`** etc.\n",
    "\n",
    "**Example:** Python **`range()`** function generates the immutable sequence of numbers starting from the given start integer to the stop integer.\n",
    "\n",
    "```python\n",
    ">>> for i in range(1, 10):\n",
    ">>>     print(i, end=' ')\n",
    "\n",
    "1 2 3 4 5 6 7 8 9\n",
    "```\n",
    "\n",
    "2. **User-defined function**\n",
    "\n",
    "Functions which are created by programmer explicitly according to the requirement are called a user-defined function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "def function_name(parameter1, parameter2):\n",
    "    \"\"\"docstring\"\"\"\n",
    "    # function body    \n",
    "    # write some action\n",
    "return value\n",
    "```\n",
    "\n",
    "<div>\n",
    "<img src=\"img/f1.png\" width=\"550\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a Function\n",
    "\n",
    "1. **`def`** is a keyword that marks the start of the function header.\n",
    "\n",
    "2. **`function_name`** to uniquely identify the function. Function naming follows the same **[rules of writing identifiers in Python](https://github.com/milaan9/01_Python_Introduction/blob/main/005_Python_Keywords_and_Identifiers.ipynb)**.\n",
    "\n",
    "2. **`parameter`** is the value passed to the function. They are optional.\n",
    "\n",
    "3. **`:`** (colon) to mark the end of the function header.\n",
    "\n",
    "4. **`function body`** is a block of code that performs some task and all the statements in **`function body`** must have the same **indentation** level (usually 4 spaces). \n",
    "\n",
    "5. **\"\"\"docstring\"\"\"** documentation string is used to describe what the function does.\n",
    "\n",
    "6. **`return`** is a keyword to return a value from the function.. A return statement with no arguments is the same as return **`None`**.\n",
    "\n",
    ">**Note:** While defining a function, we use two keywords, **`def`** (mandatory) and **`return`** (optional).\n",
    "\n",
    "**Example:**\n",
    "\n",
    "```python\n",
    ">>> def add(num1,num2):           # Function name: 'add', Parameters: 'num1', 'num2'\n",
    ">>>     print(\"Number 1: \", num1) #  Function body\n",
    ">>>     print(\"Number 2: \", num2) #  Function body\n",
    ">>>     addition = num1 + num2    #  Function body\n",
    ">>>     return addition           # return value\n",
    "\n",
    "\n",
    ">>> res = add(2, 4)   # Function call\n",
    ">>> print(\"Result: \", res)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a function without any parameters\n",
    "\n",
    "Function can be declared without parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:57.838353Z",
     "start_time": "2021-10-08T17:47:57.814918Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Python for Data Science\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "    \n",
    "def greet():\n",
    "    print(\"Welcome to Python for Data Science\")\n",
    "\n",
    "# call function using its name\n",
    "greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:57.946753Z",
     "start_time": "2021-10-08T17:47:57.840309Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# Example 2: \n",
    "\n",
    "def add_two_numbers ():\n",
    "    num_one = 3\n",
    "    num_two = 6\n",
    "    total = num_one + num_two\n",
    "    print(total)\n",
    "add_two_numbers() # calling a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:58.053200Z",
     "start_time": "2021-10-08T17:47:57.950659Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan Parmar\n"
     ]
    }
   ],
   "source": [
    "# Example 3: \n",
    "\n",
    "def generate_full_name ():\n",
    "    first_name = 'Milaan'\n",
    "    last_name = 'Parmar'\n",
    "    space = ' '\n",
    "    full_name = first_name + space + last_name\n",
    "    print(full_name)\n",
    "generate_full_name () # calling a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a function without parameters and `return` value\n",
    "\n",
    "Function can also return values, if a function does not have a **`return`** statement, the value of the function is None. Let us rewrite the above functions using **`return`**. From now on, we get a value from a function when we call the function and print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:58.176733Z",
     "start_time": "2021-10-08T17:47:58.057106Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "\n",
    "def add_two_numbers ():\n",
    "    num_one = 3\n",
    "    num_two = 6\n",
    "    total = num_one + num_two\n",
    "    return total\n",
    "print(add_two_numbers())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:58.298319Z",
     "start_time": "2021-10-08T17:47:58.185523Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan Parmar\n"
     ]
    }
   ],
   "source": [
    "# Example 2: \n",
    "\n",
    "def generate_full_name ():\n",
    "    first_name = 'Milaan'\n",
    "    last_name = 'Parmar'\n",
    "    space = ' '\n",
    "    full_name = first_name + space + last_name\n",
    "    return full_name\n",
    "print(generate_full_name())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a function with parameters\n",
    "\n",
    "In a function we can pass different data types(number, string, boolean, list, tuple, dictionary or set) as a parameter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Single Parameter: \n",
    "\n",
    "If our function takes a parameter we should call our function with an argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:58.422343Z",
     "start_time": "2021-10-08T17:47:58.301246Z"
    }
   },
   "outputs": [],
   "source": [
    "# Example 1: Gereeting\n",
    "\n",
    "def greet(name):\n",
    "    \"\"\"\n",
    "    This function greets to the person passed in as a parameter\n",
    "    \"\"\"\n",
    "    print(\"Hello, \" + name + \". Good morning!\")   # No output!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:58.545876Z",
     "start_time": "2021-10-08T17:47:58.430154Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "None\n",
      "5050\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Example 2: \n",
    "\n",
    "def sum_of_numbers(n):\n",
    "    total = 0\n",
    "    for i in range(n+1):\n",
    "        total+=i\n",
    "    print(total)\n",
    "print(sum_of_numbers(10))  # 55\n",
    "print(sum_of_numbers(100)) # 5050"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Two Parameter: \n",
    "\n",
    "A function may or may not have a parameter or parameters. A function may also have two or more parameters. If our function takes parameters we should call it with arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:58.652810Z",
     "start_time": "2021-10-08T17:47:58.552712Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Arthur Welcome to Python for Data Science\n",
      "Your course name is Python\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "\n",
    "def course(name, course_name):\n",
    "    print(\"Hello\", name, \"Welcome to Python for Data Science\")\n",
    "    print(\"Your course name is\", course_name)\n",
    "\n",
    "course('Arthur', 'Python')   # call function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a function with parameters and `return` value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:58.761206Z",
     "start_time": "2021-10-08T17:47:58.657692Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan, welcome to Python for Data Science\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "\n",
    "def greetings (name):  # single parameter\n",
    "    message = name + ', welcome to Python for Data Science'\n",
    "    return message\n",
    "\n",
    "print(greetings('Milaan'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:58.853005Z",
     "start_time": "2021-10-08T17:47:58.764137Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "# Example 2: \n",
    "\n",
    "def add_ten(num):  # single parameter\n",
    "    ten = 10\n",
    "    return num + ten\n",
    "print(add_ten(90))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:58.976051Z",
     "start_time": "2021-10-08T17:47:58.855934Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# Example 3: \n",
    "\n",
    "def square_number(x):  # single parameter\n",
    "    return x * x\n",
    "print(square_number(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:59.084452Z",
     "start_time": "2021-10-08T17:47:58.978980Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "314.0\n"
     ]
    }
   ],
   "source": [
    "# Example 4: \n",
    "\n",
    "def area_of_circle (r):  # single parameter\n",
    "    PI = 3.14\n",
    "    area = PI * r ** 2\n",
    "    return area\n",
    "print(area_of_circle(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:59.192846Z",
     "start_time": "2021-10-08T17:47:59.087380Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition : 36\n"
     ]
    }
   ],
   "source": [
    "# Example 5: \n",
    "\n",
    "def calculator(a, b):  # two parameter\n",
    "    add = a + b   \n",
    "    return add    # return the addition\n",
    "\n",
    "result = calculator(30, 6)   # call function & take return value in variable\n",
    "print(\"Addition :\", result)   # Output Addition : 36"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:59.299295Z",
     "start_time": "2021-10-08T17:47:59.199687Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full Name:  Milaan Parmar\n"
     ]
    }
   ],
   "source": [
    "# Example 6: \n",
    "\n",
    "def generate_full_name (first_name, last_name):  # two parameter\n",
    "    space = ' '\n",
    "    full_name = first_name + space + last_name\n",
    "    return full_name\n",
    "print('Full Name: ', generate_full_name('Milaan','Parmar'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:59.422342Z",
     "start_time": "2021-10-08T17:47:59.302224Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of two numbers:  10\n"
     ]
    }
   ],
   "source": [
    "# Example 7: \n",
    "\n",
    "def sum_two_numbers (num_one, num_two):  # two parameter\n",
    "    sum = num_one + num_two\n",
    "    return sum\n",
    "print('Sum of two numbers: ', sum_two_numbers(1, 9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:59.530738Z",
     "start_time": "2021-10-08T17:47:59.425271Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age:  202\n"
     ]
    }
   ],
   "source": [
    "# Example 8: \n",
    "\n",
    "def calculate_age (current_year, birth_year):  # two parameter\n",
    "    age = current_year - birth_year\n",
    "    return age;\n",
    "\n",
    "print('Age: ', calculate_age(2021, 1819))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:59.623513Z",
     "start_time": "2021-10-08T17:47:59.533669Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weight of an object in Newtons:  981.0 N\n"
     ]
    }
   ],
   "source": [
    "# Example 9: \n",
    "\n",
    "def weight_of_object (mass, gravity):  # two parameter\n",
    "    weight = str(mass * gravity)+ ' N' # the value has to be changed to a string first\n",
    "    return weight\n",
    "print('Weight of an object in Newtons: ', weight_of_object(100, 9.81))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function `return` Statement\n",
    "\n",
    "In Python, to return value from the function, a **`return`** statement is used. It returns the value of the expression following the returns keyword.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "def fun():\n",
    "    statement-1\n",
    "    statement-2\n",
    "    statement-3\n",
    "    .          \n",
    "    .          \n",
    "    return [expression]\n",
    "```\n",
    "\n",
    "The **`return`** value is nothing but a outcome of function.\n",
    "\n",
    "* The **`return`** statement ends the function execution.\n",
    "* For a function, it is not mandatory to return a value.\n",
    "* If a **`return`** statement is used without any expression, then the **`None`** is returned.\n",
    "* The **`return`** statement should be inside of the function block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return Single Value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:59.718728Z",
     "start_time": "2021-10-08T17:47:59.626442Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Cory. Good morning!\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(greet(\"Cory\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, **`None`** is the returned value since **`greet()`** directly prints the name and no **`return`** statement is used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passing Arguments with Key and Value\n",
    "\n",
    "If we pass the arguments with key and value, the order of the arguments does not matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:59.854957Z",
     "start_time": "2021-10-08T17:47:59.727520Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan Parmar\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "\n",
    "def print_fullname(firstname, lastname):\n",
    "    space = ' '\n",
    "    full_name = firstname  + space + lastname\n",
    "    print(full_name)\n",
    "print(print_fullname(firstname = 'Milaan', lastname = 'Parmar'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:47:59.978006Z",
     "start_time": "2021-10-08T17:47:59.860817Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "def add_two_numbers (num1, num2):\n",
    "    total = num1 + num2\n",
    "    print(total)\n",
    "print(add_two_numbers(num2 = 3, num1 = 2)) # Order does not matter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we do not **`return`** a value with a function, then our function is returning **`None`** by default. To return a value with a function we use the keyword **`return`** followed by the variable we are returning. We can return any kind of data types from a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:00.178202Z",
     "start_time": "2021-10-08T17:47:59.981912Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan Parmar\n"
     ]
    }
   ],
   "source": [
    "# Example 1:  with return statement\n",
    "\n",
    "def print_fullname(firstname, lastname):\n",
    "    space = ' '\n",
    "    full_name = firstname  + space + lastname\n",
    "    return full_name\n",
    "print(print_fullname(firstname = 'Milaan', lastname = 'Parmar'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:00.286600Z",
     "start_time": "2021-10-08T17:48:00.182107Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# Example 2:  with return statement\n",
    "\n",
    "def add_two_numbers (num1, num2):\n",
    "    total = num1 + num2\n",
    "    return total\n",
    "print(add_two_numbers(num2 = 3, num1 = 2)) # Order does not matter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:00.394507Z",
     "start_time": "2021-10-08T17:48:00.300275Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "def absolute_value(num):\n",
    "    \"\"\"This function returns the absolute\n",
    "    value of the entered number\"\"\"\n",
    "\n",
    "    if num >= 0:\n",
    "        return num\n",
    "    else:\n",
    "        return -num\n",
    "\n",
    "print(absolute_value(2))\n",
    "print(absolute_value(-4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:00.529768Z",
     "start_time": "2021-10-08T17:48:00.400370Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adding the two values\n",
      "Printing within Function\n",
      "30\n",
      "total :  30\n",
      "Hello\n",
      "Rest of code\n"
     ]
    }
   ],
   "source": [
    "# Example 4:\n",
    "\n",
    "def sum(a,b):  # Function 1\n",
    "    print(\"Adding the two values\")\n",
    "    print(\"Printing within Function\")\n",
    "    print(a+b)\n",
    "    return a+b\n",
    "\n",
    "def msg():  # Function 2\n",
    "    print(\"Hello\")\n",
    "    return\n",
    "\n",
    "total=sum(10,20)\n",
    "print('total : ',total)\n",
    "msg()\n",
    "print(\"Rest of code\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:00.672343Z",
     "start_time": "2021-10-08T17:48:00.537579Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Even numbers are: [2, 46, 72, 90]\n"
     ]
    }
   ],
   "source": [
    "# Example 5:\n",
    "\n",
    "def is_even(list1):\n",
    "    even_num = []\n",
    "    for n in list1:\n",
    "        if n % 2 == 0:\n",
    "            even_num.append(n)\n",
    "    # return a list\n",
    "    return even_num\n",
    "\n",
    "# Pass list to the function\n",
    "even_num = is_even([2, 3, 46, 63, 72, 83, 90, 19])\n",
    "print(\"Even numbers are:\", even_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return Multiple Values\n",
    "\n",
    "You can also return multiple values from a function. Use the return statement by separating each expression by a comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:00.795876Z",
     "start_time": "2021-10-08T17:48:00.677226Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition:  12\n",
      "Subtraction:  8\n",
      "Multiplication:  20\n",
      "Division:  5.0\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "def arithmetic(num1, num2):\n",
    "    add = num1 + num2\n",
    "    sub = num1 - num2\n",
    "    multiply = num1 * num2\n",
    "    division = num1 / num2\n",
    "    # return four values\n",
    "    return add, sub, multiply, division\n",
    "\n",
    "a, b, c, d = arithmetic(10, 2)  # read four return values in four variables\n",
    "\n",
    "print(\"Addition: \", a)\n",
    "print(\"Subtraction: \", b)\n",
    "print(\"Multiplication: \", c)\n",
    "print(\"Division: \", d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return Boolean Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:00.903786Z",
     "start_time": "2021-10-08T17:48:00.803691Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "even\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "def is_even (n):\n",
    "    if n % 2 == 0:\n",
    "        print('even')\n",
    "        return True    # return stops further execution of the function, similar to break \n",
    "    return False\n",
    "print(is_even(10)) # True\n",
    "print(is_even(7)) # False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return a List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:01.028789Z",
     "start_time": "2021-10-08T17:48:00.906718Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "def find_even_numbers(n):\n",
    "    evens = []\n",
    "    for i in range(n + 1):\n",
    "        if i % 2 == 0:\n",
    "            evens.append(i)\n",
    "    return evens\n",
    "print(find_even_numbers(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to call a function in python?\n",
    "\n",
    "Once we have defined a function, we can call it from another function, program or even the Python prompt. To call a function we simply type the function name with appropriate parameters.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/f2.png\" width=\"500\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:01.135232Z",
     "start_time": "2021-10-08T17:48:01.031717Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alan. Good morning!\n"
     ]
    }
   ],
   "source": [
    "greet('Alan')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**Note:** Try running the above code in the Python program with the function definition to see the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:01.243633Z",
     "start_time": "2021-10-08T17:48:01.140118Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Happy birthday, Bill. Hope you have a wonderful day!\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "\n",
    "def wish(name):\n",
    "    \"\"\"\n",
    "    This function wishes to the person passed in as a parameter\n",
    "    \"\"\"\n",
    "    print(\"Happy birthday, \" + name + \". Hope you have a wonderful day!\")\n",
    "\n",
    "wish('Bill')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:01.446289Z",
     "start_time": "2021-10-08T17:48:01.251445Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clark, welcome to Python for Data Science\n",
      "Milaan, welcome to Python for Data Science\n"
     ]
    }
   ],
   "source": [
    "# Example 2: \n",
    "\n",
    "def greetings (name = 'Clark'):\n",
    "    message = name + ', welcome to Python for Data Science'\n",
    "    return message\n",
    "print(greetings())\n",
    "print(greetings('Milaan'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:01.699688Z",
     "start_time": "2021-10-08T17:48:01.454570Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan Parmar\n",
      "Ethan Hunt\n"
     ]
    }
   ],
   "source": [
    "# Example 3: \n",
    "\n",
    "def generate_full_name (first_name = 'Milaan', last_name = 'Parmar'):\n",
    "    space = ' '\n",
    "    full_name = first_name + space + last_name\n",
    "    return full_name\n",
    "print(generate_full_name())\n",
    "print(generate_full_name('Ethan','Hunt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:01.793476Z",
     "start_time": "2021-10-08T17:48:01.702617Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age:  200\n"
     ]
    }
   ],
   "source": [
    "# Example 4: \n",
    "\n",
    "def calculate_age (birth_year,current_year = 2021):\n",
    "    age = current_year - birth_year\n",
    "    return age;\n",
    "print('Age: ', calculate_age(1821))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:01.900373Z",
     "start_time": "2021-10-08T17:48:01.797831Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value of x is: 9\n",
      "value of y is: 6\n"
     ]
    }
   ],
   "source": [
    "# Example 5: \n",
    "\n",
    "def swap(x, y):\n",
    "    \"\"\"\n",
    "    This function swaps the value of two variables\n",
    "    \"\"\"\n",
    "    temp = x;  # value of x will go inside temp\n",
    "    x = y;     # value of y will go inside x\n",
    "    y = temp;  # value of temp will go inside y\n",
    "    print(\"value of x is:\", x)\n",
    "    print(\"value of y is:\", y)\n",
    "    return     # \"return\" is optional\n",
    "\n",
    "x = 6\n",
    "y = 9\n",
    "swap(x, y)     #call function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:02.023908Z",
     "start_time": "2021-10-08T17:48:01.903301Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 is a Odd Number\n"
     ]
    }
   ],
   "source": [
    "# Example 6: \n",
    "\n",
    "def even_odd(n):    \n",
    "    if n % 2 == 0:   # check number is even or odd\n",
    "        print(n, 'is a Even number')\n",
    "    else:\n",
    "        print(n, 'is a Odd Number')\n",
    "\n",
    "even_odd(9)   # calling function by its name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:02.147933Z",
     "start_time": "2021-10-08T17:48:02.026837Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weight of an object in Newtons:  981.0 N\n",
      "Weight of an object in Newtons:  162.0 N\n"
     ]
    }
   ],
   "source": [
    "# Example 7: \n",
    "\n",
    "def weight_of_object (mass, gravity = 9.81):\n",
    "    weight = str(mass * gravity)+ ' N' # the value has to be changed to string first\n",
    "    return weight\n",
    "print('Weight of an object in Newtons: ', weight_of_object(100)) # 9.81 - average gravity on Earth's surface\n",
    "print('Weight of an object in Newtons: ', weight_of_object(100, 1.62)) # gravity on the surface of the Moon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Docstrings\n",
    "\n",
    "The first string after the function header is called the **docstring** and is short for documentation string. It is a descriptive text (like a comment) written by a programmer to let others know what block of code does.\n",
    "\n",
    "Although **optional**, documentation is a good programming practice. Unless you can remember what you had for dinner last week, always document your code.\n",
    "\n",
    "It is being declared using triple single quotes **`''' '''`** or triple-double quote **`\"\"\" \"\"\"`** so that docstring can extend up to multiple lines.\n",
    "\n",
    "We can access docstring using doc attribute **`__doc__`** for any object like list, tuple, dict, and user-defined function, etc.\n",
    "\n",
    "In the above example, we have a docstring immediately below the function header."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:02.284654Z",
     "start_time": "2021-10-08T17:48:02.154767Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    This function greets to the person passed in as a parameter\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(greet.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To learn more about docstrings in Python, visit **[Python Docstrings](https://github.com/milaan9/04_Python_Functions/blob/main/Python_Docstrings.ipynb)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function `pass` Statement\n",
    "\n",
    "In Python, the **`pass`** is the keyword, which won’t do anything. Sometimes there is a situation where we need to define a syntactically empty block. We can define that block using the **`pass`** keyword.\n",
    "\n",
    "When the interpreter finds a **`pass`** statement in the program, it returns no operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-08T17:48:02.420395Z",
     "start_time": "2021-10-08T17:48:02.294414Z"
    }
   },
   "outputs": [],
   "source": [
    "# Example 1:\n",
    "\n",
    "def addition(num1, num2):\n",
    "    # Implementation of addition function in comming release\n",
    "    # Pass statement \n",
    "    pass\n",
    "\n",
    "addition(10, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💻 Exercises ➞ <span class='label label-default'>Functions</span>\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 1</span>\n",
    "\n",
    "1. Area of a circle is calculated as follows: **area = π x r x r** and **perimeter = 2 x π x r**. Write a function that calculates **`area_of_circle`** and **`perimeter_of_circle`**.\n",
    "2. Write a function called **`add_all_nums`** which takes arbitrary number of arguments and sums all the arguments. Check if all the list items are number types. If not do give a reasonable feedback.\n",
    "3. Temperature in **°C** can be converted to **°F** using this formula: **°F = (°C x 9/5) + 32**. Write a function which converts **°C to °F**, **`convert_celsius_2_fahrenheit`**.\n",
    "4. Write a function called **`check_season`**, it takes a month parameter and returns the season: Autumn, Winter, Spring or Summer.\n",
    "5. Write a function called **`calculate_slope`** which return the slope of a linear equation\n",
    "6. Quadratic equation is calculated as follows: **ax² + bx + c = 0**. Write a function which calculates solution set of a quadratic equation, **`solve_quadratic_eqn`**.\n",
    "7. Declare a function named **`print_list`**. It takes a list as a parameter and it prints out each element of the list.\n",
    "8. Declare a function named **`reverse_list`**. It takes an array as a parameter and it returns the reverse of the array (use loops).\n",
    "\n",
    "    - ```py\n",
    "print(reverse_list([1, 2, 3, 4, 5]))\n",
    "#[5, 4, 3, 2, 1]\n",
    "print(reverse_list1([\"A\", \"B\", \"C\"]))\n",
    "#[\"C\", \"B\", \"A\"]\n",
    "    ```\n",
    "\n",
    "9. Declare a function named **`capitalize_list_items`**. It takes a list as a parameter and it returns a capitalized list of items\n",
    "10. Declare a function named **`add_item`**. It takes a list and an item parameters. It returns a list with the item added at the end.\n",
    "\n",
    "    - ```py\n",
    "food_staff = ['Potato', 'Tomato', 'Mango', 'Milk']\n",
    "print(add_item(food_staff, 'Fungi'))  #['Potato', 'Tomato', 'Mango', 'Milk', 'Fungi']\n",
    "numbers = [2, 3, 7, 9]\n",
    "print(add_item(numbers, 5))      #[2, 3, 7, 9, 5]\n",
    "    ```\n",
    "\n",
    "11. Declare a function named **`remove_item`**. It takes a list and an item parameters. It returns a list with the item removed from it.\n",
    "\n",
    "    - ```py\n",
    "food_staff = ['Potato', 'Tomato', 'Mango', 'Milk']\n",
    "print(remove_item(food_staff, 'Mango'))  # ['Potato', 'Tomato', 'Milk']\n",
    "numbers = [2, 3, 7, 9]\n",
    "print(remove_item(numbers, 3))  # [2, 7, 9]\n",
    "    ```\n",
    "\n",
    "12. Declare a function named **`sum_of_numbers`**. It takes a number parameter and it adds all the numbers in that range.\n",
    "\n",
    "    - ```py\n",
    "print(sum_of_numbers(5))  # 15\n",
    "print(sum_all_numbers(10)) # 55\n",
    "print(sum_all_numbers(100)) # 5050\n",
    "     ```\n",
    "\n",
    "13. Declare a function named **`sum_of_odds`**. It takes a number parameter and it adds all the odd numbers in that range.\n",
    "14. Declare a function named **`sum_of_even`**. It takes a number parameter and it adds all the even numbers in that - range.\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 2</span>\n",
    "\n",
    "1.  Declare a function named **`evens_and_odds`**. It takes a positive integer as parameter and it counts number of evens and odds in the number.\n",
    "\n",
    "    - ```py\n",
    "    print(evens_and_odds(100))\n",
    "    #The number of odds are 50.\n",
    "    #The number of evens are 51.\n",
    "    ```\n",
    "\n",
    "2. Call your function **`factorial`**, it takes a whole number as a parameter and it return a factorial of the number\n",
    "3. Call your function **`is_empty`**, it takes a parameter and it checks if it is empty or not\n",
    "4. Write different functions which take lists. They should **`calculate_mean`**, **`calculate_median`**, **`calculate_mode`**, **`calculate_range`**, **`calculate_variance`**, **`calculate_std`** (standard deviation).\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 3</span>\n",
    "\n",
    "1. Write a function called **`is_prime`**, which checks if a number is prime.\n",
    "2. Write a functions which checks if all items are unique in the list.\n",
    "3. Write a function which checks if all the items of the list are of the same data type.\n",
    "4. Write a function which check if provided variable is a valid python variable\n",
    "5. Go to the data folder and access the **[countries-data.py](https://github.com/milaan9/03_Python_Flow_Control/blob/main/countries_details_data.py)** file.\n",
    "\n",
    "- Create a function called the **`most_spoken_languages`** in the world. It should return 10 or 20 most spoken languages in the world in descending order\n",
    "- Create a function called the **`most_populated_countries`**. It should return 10 or 20 most populated countries in descending order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "gist": {
   "data": {
    "description": "01_Learn_Python4Data/04_Python_Functions/001_Python_Functions.ipynb",
    "public": true
   },
   "id": ""
  },
  "hide_input": false,
  "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}