Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/logo_full.png'/>\n",
    "\n",
    "## <center> Python for Data Science </center>\n",
    "The course is offered by [Ai Adventures](https://aiadventures.in/). The notebooks are created by [Pranav Uikey](https://twitter.com/Pranav_Uikey_) and [Ankur Singh](https://twitter.com/I_ankursingh). This material is subject to the terms and conditions of the [Creative Commons CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) license. Any use for commercial purpose is strictly prohibited."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You’re already familiar with the *print()*, *input()*, and *len()* functions from the previous notebooks. Python provides several builtin functions like these, but you can also write your own functions. A **function** is like a mini-program within a program.\n",
    "\n",
    "To better understand how functions work, let’s create one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Howdy!\n",
      "Howdy!!!\n",
      "Hello there.\n",
      "Howdy!\n",
      "Howdy!!!\n",
      "Hello there.\n",
      "Howdy!\n",
      "Howdy!!!\n",
      "Hello there.\n"
     ]
    }
   ],
   "source": [
    "def hello(): # (1)\n",
    "    print('Howdy!') #(2)\n",
    "    print('Howdy!!!')\n",
    "    print('Hello there.')\n",
    "    \n",
    "hello() # (3)\n",
    "hello()\n",
    "hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first line is a *def* statement ❶, which defines a function named *hello()*. The code in the block that follows the *def* statement ❷ is the **body of the function**. This code is **executed when the function is called, not when the function is first defined**.\n",
    "\n",
    "The *hello()* lines after the function ❸ are function calls. In code, a function call is just the function’s name followed by parentheses, possibly with some number of arguments in between the parentheses. When the program execution reaches these calls, it will jump to the top line in the function and begin executing the code there. When it reaches the end of the function, the execution returns to the line that called the function and continues moving through the code as before."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A major purpose of functions is to group code that gets executed multiple times**. Without a function defined, you would have to copy and paste this code each time, and the program would look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Howdy!\n",
      "Howdy!!!\n",
      "Hello there.\n",
      "Howdy!\n",
      "Howdy!!!\n",
      "Hello there.\n",
      "Howdy!\n",
      "Howdy!!!\n",
      "Hello there.\n"
     ]
    }
   ],
   "source": [
    "print('Howdy!')\n",
    "print('Howdy!!!')\n",
    "print('Hello there.')\n",
    "print('Howdy!')\n",
    "print('Howdy!!!')\n",
    "print('Hello there.')\n",
    "print('Howdy!')\n",
    "print('Howdy!!!')\n",
    "print('Hello there.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, you always want to **avoid duplicating code**, because if you ever decide to update the code—if, for example, you find a bug you need to fix—you’ll have to remember to change the code everywhere you copied it.\n",
    "\n",
    "As you get more programming experience, you’ll often find yourself deduplicating code, which means getting rid of duplicated or copy-and-pasted code. Deduplication makes your programs shorter, easier to read, and easier to update."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *def* Statements with Parameters\n",
    "When you call the *print()* or *len()* function, you pass in values, called **arguments** in this context, by typing them between the parentheses. You can also define your own functions that accept arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Alice\n",
      "Hello Bob\n"
     ]
    }
   ],
   "source": [
    "def hello(name): # (1)\n",
    "    print('Hello '+ name) # (2)\n",
    "    \n",
    "hello('Alice') # (3)\n",
    "hello('Bob')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'name' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-9ba126b17b03>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'name' is not defined"
     ]
    }
   ],
   "source": [
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The definition of the *hello()* function in this program has a parameter called *name* ❶. A parameter is a variable that an argument is stored in when a function is called. The first time the *hello()* function is called, it’s with the argument 'Alice' ❸. The program execution enters the function, and the variable *name* is automatically set to 'Alice', which is what gets printed by the *print()* statement ❷."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One special thing to note about parameters is that the **value stored in a parameter is forgotten when the function returns**. For example, if you added `print(name)` after `hello('Bob')` in the previous program, the program would give you a *NameError* because there is no variable named *name*. This variable was **destroyed after the function call `hello('Bob')` had returned**, so `print(name)` would refer to a *name* variable that does not exist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return Values and return Statements\n",
    "When you call the *len()* function and pass it an argument such as 'Hello', the function call evaluates to the integer value 5, which is the length of the string you passed it. In general, the value that a function call evaluates to is called the **return value of the function**.\n",
    "\n",
    "When creating a function using the *def* statement, you can specify what the return value should be with a *return* statement. A *return* statement consists of the following:\n",
    "\n",
    "1. The *return* keyword\n",
    "\n",
    "2. The **value or expression** that the function should return\n",
    "\n",
    "When an expression is used with a *return* statement, the return value is what this expression evaluates to. For example, the following program defines a function that returns a different string depending on what number it is passed as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My reply is no\n"
     ]
    }
   ],
   "source": [
    "import random # (1) \n",
    "def getAnswer(answerNumber):# (2) \n",
    "    if answerNumber == 1:# (3) \n",
    "        return 'It is certain'\n",
    "    elif answerNumber == 2:\n",
    "        return 'It is decidedly so'\n",
    "    elif answerNumber == 3:\n",
    "        return 'Yes'\n",
    "    elif answerNumber == 4:\n",
    "        return 'Reply hazy try again'\n",
    "    elif answerNumber == 5:\n",
    "        return 'Ask again later'\n",
    "    elif answerNumber == 6:\n",
    "        return 'Concentrate and ask again'\n",
    "    elif answerNumber == 7:\n",
    "        return 'My reply is no'\n",
    "    elif answerNumber == 8:\n",
    "        return 'Outlook not so good'\n",
    "    elif answerNumber == 9:\n",
    "        return 'Very doubtful'\n",
    "\n",
    "r = random.randint(1, 9)  # (4)\n",
    "fortune = getAnswer(r) # (5)\n",
    "print(fortune) # (6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When this program starts, Python first imports the random module ❶. Then the *getAnswer()* function is defined ❷. Because the function is being defined (and not called), the execution skips over the code in it. Next, the *random.randint()* function is called with two arguments, 1 and 9 ❹. It evaluates to a random integer between 1 and 9 (including 1 and 9 themselves), and this value is stored in a variable named *r*.\n",
    "\n",
    "The *getAnswer()* function is called with *r* as the argument ❺. The program execution moves to the top of the *getAnswer()* function ❸, and the value *r* is stored in a parameter named *answerNumber*. Then, depending on this value in *answerNumber*, the function returns one of many possible string values. The program execution returns to the line at the bottom of the program that originally called *getAnswer()* ❺. The returned string is assigned to a variable named *fortune*, which then gets passed to a *print()* call ❻ and is printed to the screen.\n",
    "\n",
    "Note that since you can pass return values as an argument to another function call, you could shorten these three lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outlook not so good\n"
     ]
    }
   ],
   "source": [
    "r = random.randint(1, 9)\n",
    "fortune = getAnswer(r)\n",
    "print(fortune)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Concentrate and ask again\n"
     ]
    }
   ],
   "source": [
    "# to this single equivalent line:\n",
    "print(getAnswer(random.randint(1, 9)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, expressions are composed of values and operators. A function call can be used in an expression because it evaluates to its return value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The None Value\n",
    "In Python there is a value called ***None***, which represents the absence of a value. *None* is the only value of the **NoneType data type**. (Other programming languages might call this value **null, nil, or undefined**.) Just like the Boolean True and False values, *None* must be typed with a **capital N**.\n",
    "\n",
    "This value-without-a-value can be helpful when you need to store something that won’t be confused for a real value in a variable. One place where *None* is used is as the return value of *print()*. The *print()* function displays text on the screen, but it doesn’t need to return anything in the same way *len()* or *input()* does. But since all function calls need to evaluate to a return value, *print()* returns *None*. To see this in action, enter the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "spam = print('Hello!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "None == spam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Behind the scenes, Python adds return *None* to the end of any function definition with **no *return*** statement. If you use a *return* statement without a value (that is, just the return keyword by itself), then *None* is returned."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "Functions are the primary way to compartmentalize your code into logical groups. Since the variables in functions exist in their own local scopes, the code in one function cannot directly affect the values of variables in other functions. This limits what code could be changing the values of your variables, which can be helpful when it comes to debugging your code.\n",
    "\n",
    "Functions are a great tool to help you organize your code. You can think of them as black boxes: They have inputs in the form of parameters and outputs in the form of return values, and the code in them doesn’t affect variables in other functions."
   ]
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}