Day2-Python-Control Flow and Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python-Control Flow and Functions\n",
    "\n",
    "In this lecture, We'll learn about the following topics:\n",
    "\n",
    "    1.) if, elif, else Statements\n",
    "    2.) loops (For loop, while loop)\n",
    "    3.) Break, Continue & Pass statements\n",
    "    4.) Object Methods & User defined Functions\n",
    "    5.) A look at some Built-in Functions in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# if, elif, else Statements\n",
    "\n",
    "<code>if</code> Statements in Python allows us to tell the computer to perform alternative actions based on a certain set of results.\n",
    "\n",
    "Verbally, we can imagine we are telling the computer:\n",
    "\n",
    "\"Hey if this case happens, perform some action\"\n",
    "\n",
    "We can then expand the idea further with <code>elif</code> and <code>else</code> statements, which allow us to tell the computer:\n",
    "\n",
    "\"Hey if this case happens, perform some action. Else, if another case happens, perform some other action. Else, if *none* of the above cases happened, perform this action.\"\n",
    "\n",
    "Let's go ahead and look at the syntax format for <code>if</code> statements to get a better idea of this:\n",
    "\n",
    "    if case1:\n",
    "        perform action1\n",
    "    elif case2:\n",
    "        perform action2\n",
    "    else: \n",
    "        perform action3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First Example\n",
    "\n",
    "Let's see a quick example of this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "if False:\n",
    "    print('It was true!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add in some else logic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x was True!\n",
      "Here it is\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "\n",
    "if (x):\n",
    "    print('x was True!')\n",
    "else:\n",
    "    print('I will be printed in any case where x is not true')\n",
    "    print('Here it is')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Branches\n",
    "\n",
    "Let's get a fuller picture of how far <code>if</code>, <code>elif</code>, and <code>else</code> can take us!\n",
    "\n",
    "We write this out in a nested structure. Take note of how the <code>if</code>, <code>elif</code>, and <code>else</code> line up in the code. This can help you see what <code>if</code> is related to what <code>elif</code> or <code>else</code> statements.\n",
    "\n",
    "We'll reintroduce a comparison syntax for Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Where are you?\n"
     ]
    }
   ],
   "source": [
    "loc = 'Banksdfsdf'\n",
    "\n",
    "if loc == 'Auto Shop':\n",
    "    print('Welcome to the Auto Shop!')\n",
    "elif loc == 'Bank':\n",
    "    print('Welcome to the bank!')\n",
    "else:\n",
    "    print('Where are you?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how the nested <code>if</code> statements are each checked until a True boolean causes the nested code below it to run. You should also note that you can put in as many <code>elif</code> statements as you want before you close off with an <code>else</code>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if-elif-else Exercise\n",
    "Write code to check weather condition with following senarios:\n",
    "\n",
    "    1.) Sunny and Hot (temp is higher than 30)\n",
    "    2.) Sunny and Moderate (temp is between 20 and 30)\n",
    "    3.) Rainy and Cold (temp is less than 20)\n",
    "    4.) Rainy and Very Cold (temp is less than 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wrong input\n"
     ]
    }
   ],
   "source": [
    "# Write your code here\n",
    "temp = 20\n",
    "\n",
    "if temp > 30:\n",
    "    print(\"Sunny and Hot\")\n",
    "elif temp > 20 and temp < 30:\n",
    "    print(\"Sunny and Moderate\")\n",
    "elif temp < 5:\n",
    "    print(\"Rainy and Very Cold\")\n",
    "elif temp < 20:\n",
    "    print(\"Rainy and Cold\")\n",
    "else:\n",
    "    print(\"Wrong input\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# for Loops\n",
    "\n",
    "A <code>for</code> loop acts as an iterator in Python; it goes through items that are in a *sequence* or any other iterable item. Objects that we've learned about that we can iterate over include strings, lists, tuples, and even built-in iterables for dictionaries, such as keys or values.\n",
    "\n",
    "We've already seen the <code>for</code> statement a little bit in past lectures but now let's formalize our understanding.\n",
    "\n",
    "Here's the general format for a <code>for</code> loop in Python:\n",
    "\n",
    "    for item in object:\n",
    "        statements to do stuff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variable name used for the item is completely up to the coder, so use your best judgment for choosing a name that makes sense and you will be able to understand when revisiting your code. This item name can then be referenced inside your loop, for example if you wanted to use <code>if</code> statements to perform checks.\n",
    "\n",
    "Let's go ahead and work through several example of <code>for</code> loops using a variety of data object types. We'll start simple and build more complexity later on.\n",
    "\n",
    "## Example 1\n",
    "Iterating through a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "# We'll learn how to automate this sort of list in the next lecture\n",
    "list1 = [1,2,3,4,5,6,7,8,9,10]\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for num in list1:\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Prints out the numbers 0,1,2,3,4\n",
    "for x in range(5):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Prints out 3,4,5\n",
    "for x in range(3, 6):\n",
    "    print(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "# Prints out 3,5,7\n",
    "for x in range(3, 8, 2):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! Hopefully this makes sense. Now let's add an <code>if</code> statement to check for even numbers. We'll first introduce a new concept here--the modulo.\n",
    "### Modulo\n",
    "The modulo allows us to get the remainder in a division and uses the % symbol. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "17 % 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This makes sense since 17 divided by 5 is 3 remainder 2. Let's see a few more quick examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3 Remainder 1\n",
    "10 % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2 no remainder\n",
    "4 % 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that if a number is fully divisible with no remainder, the result of the modulo call is 0. We can use this to test for even numbers, since if a number modulo 2 is equal to 0, that means it is an even number!\n",
    "\n",
    "Back to the <code>for</code> loops!\n",
    "\n",
    "## Example 2\n",
    "Let's print only the even numbers from that list!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for num in list1:\n",
    "    if num % 2 == 0:\n",
    "        print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could have also put an <code>else</code> statement in there:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 is Odd number\n",
      "2 is Even number\n",
      "3 is Odd number\n",
      "4 is Even number\n",
      "5 is Odd number\n",
      "6 is Even number\n",
      "7 is Odd number\n",
      "8 is Even number\n",
      "9 is Odd number\n",
      "10 is Even number\n"
     ]
    }
   ],
   "source": [
    "for num in list1:\n",
    "    if num % 2 == 0:\n",
    "        print(str(num) + ' is Even number' ) # typecasting with string concatenation \n",
    "    else:\n",
    "        print(\"%d is Odd number\" %num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['w', 'o', 'r', 'd']\n"
     ]
    }
   ],
   "source": [
    "list1=['w','o','r','d']\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "result=''\n",
    "\n",
    "for elements in list1:\n",
    "    result +=elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please notice here that <code>result +=elements</code> is equivallent to <code>result=result+elements</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "word\n"
     ]
    }
   ],
   "source": [
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loop Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create empty list\n",
    "word_list = []\n",
    "\n",
    "#write for loop to assign each letter of \"result\" separately to list\n",
    "\n",
    "for x in list(result):\n",
    "    word_list += x\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['w', 'o', 'r', 'd']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#print list\n",
    "word_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# while Loops\n",
    "\n",
    "The <code>while</code> statement in Python is one of most general ways to perform iteration. A <code>while</code> statement will repeatedly execute a single statement or group of statements as long as the condition is true. The reason it is called a 'loop' is because the code statements are looped through over and over again until the condition is no longer met.\n",
    "\n",
    "The general format of a while loop is:\n",
    "\n",
    "    while test:\n",
    "        code statements\n",
    "    else:\n",
    "        final code statements\n",
    "\n",
    "Let’s look at a few simple <code>while</code> loops in action. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how many times the print statements occurred and how the <code>while</code> loop kept going until the True condition was met, which occurred once x==10. It's important to note that once this occurred the code stopped. Also see how we could add an <code>else</code> statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently:  0\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  1\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  2\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  3\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  4\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  5\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  6\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  7\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  8\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  9\n",
      " x is still less than 10, adding 1 to x\n",
      "All Done!\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 10:\n",
    "    print('x is currently: ',x)\n",
    "    print(' x is still less than 10, adding 1 to x')\n",
    "    x+=1\n",
    "    \n",
    "else:\n",
    "    print('All Done!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# break, continue, pass\n",
    "\n",
    "We can use <code>break</code>, <code>continue</code>, and <code>pass</code> statements in our loops to add additional functionality for various cases. The three statements are defined by:\n",
    "\n",
    "    break: Breaks out of the current closest enclosing loop.\n",
    "    continue: Goes to the top of the closest enclosing loop.\n",
    "    pass: Does nothing at all.\n",
    "    \n",
    "    \n",
    "Thinking about <code>break</code> and <code>continue</code> statements, the general format of the <code>while</code> loop looks like this:\n",
    "\n",
    "    while test: \n",
    "        code statement\n",
    "        if test: \n",
    "            break\n",
    "        if test: \n",
    "            continue \n",
    "    else:\n",
    "\n",
    "<code>break</code> and <code>continue</code> statements can appear anywhere inside the loop’s body, but we will usually put them further nested in conjunction with an <code>if</code> statement to perform an action based on some condition.\n",
    "\n",
    "Let's go ahead and look at some examples!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently:  0\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  1\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  2\n",
      " x is still less than 10, adding 1 to x\n",
      "x==3\n",
      "x is currently:  3\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  4\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 5:\n",
    "    print('x is currently: ',x)\n",
    "    print(' x is still less than 10, adding 1 to x')\n",
    "    x+=1\n",
    "    if x==3:\n",
    "        print('x==3')\n",
    "    else:\n",
    "        print('continuing...')\n",
    "        continue\n",
    "        print('is this executed?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how we have a printed statement when x==3, and a continue being printed out as we continue through the outer while loop. Let's put in a break once x ==3 and see if the result makes sense:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently:  0\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  1\n",
      " x is still less than 10, adding 1 to x\n",
      "continuing...\n",
      "x is currently:  2\n",
      " x is still less than 10, adding 1 to x\n",
      "Breaking because x==3\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 5:\n",
    "    print('x is currently: ',x)\n",
    "    print(' x is still less than 10, adding 1 to x')\n",
    "    x+=1\n",
    "    if x==3:\n",
    "        print('Breaking because x==3')\n",
    "        break\n",
    "    else:\n",
    "        print('continuing...')\n",
    "        continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**A word of caution however! It is possible to create an infinitely running loop with <code>while</code> statements.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Methods\n",
    "\n",
    "Methods are essentially functions for the objects. Methods perform specific actions on an object and can also take arguments, just like a function. This lecture will serve as just a brief introduction to methods and get you thinking about overall design methods that we will touch back upon when we reach OOP in the course.\n",
    "\n",
    "Methods are in the form:\n",
    "\n",
    "    object.method(arg1,arg2,etc...)\n",
    "    \n",
    "You'll later see that we can think of methods as having an argument 'self' referring to the object itself. You can't see this argument but we will be using it later on in the course during the OOP lectures.\n",
    "\n",
    "Let's take a quick look at what an example of the various methods a list has:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a simple list\n",
    "lst = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fortunately, with iPython and the Jupyter Notebook we can quickly see all the possible methods using the tab key. \n",
    "The common methods for a list are:\n",
    "\n",
    "* append\n",
    "* count\n",
    "* extend\n",
    "* insert\n",
    "* pop\n",
    "* remove\n",
    "* reverse\n",
    "* sort\n",
    "\n",
    "Let's try out a few of them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.append(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst.clear()\n",
    "lst\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check how many times 2 shows up in the list\n",
    "print(lst)\n",
    "lst.count(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The methods for a string are:\n",
    "\n",
    "* lower\n",
    "* upper\n",
    "* replace\n",
    "* split\n",
    "* count\n",
    "* join\n",
    "* find\n",
    "* endswith"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Home Task"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a string having two words, starting with same letters and separated by a space like **'Abrar Ahmed'** and perform the following tasks using methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "#declare a string\n",
    "\n",
    "n_str = \"Abrar Ahmed\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hint: s.split('Letter to split with', maxsplit=no. of splits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Abrar', 'Ahmed']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# split the string\n",
    "n_str.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABRAR AHMED'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# apply upper() method on the string\n",
    "n_str.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abrar ahmed'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# apply lower() method on the string\n",
    "n_str.lower()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "## Introduction to Functions\n",
    "\n",
    "**So what is a function?**\n",
    "\n",
    "Formally, a function is a useful device that groups together a set of statements so they can be run more than once. They can also let us specify parameters that can serve as inputs to the functions.\n",
    "\n",
    "On a more fundamental level, functions allow us to not have to repeatedly write the same code again and again. \n",
    "\n",
    "Functions will be one of most basic levels of reusing code in Python, and it will also allow us to start thinking of program design. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## def Statements\n",
    "\n",
    "Let's see how to build out a function's syntax in Python. It has the following form:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def name_of_function(arg1,arg2):\n",
    "    '''\n",
    "    This is where the function's Document String (docstring) goes\n",
    "    '''\n",
    "    print(arg1+arg2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "name_of_function(1,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We begin with <code>def</code> then a space followed by the name of the function. Try to keep names relevant, for example len() is a good name for a length() function. Also be careful with names, you wouldn't want to call a function the same name as a [built-in function in Python](https://docs.python.org/2/library/functions.html) (such as len).\n",
    "\n",
    "Next come a pair of parentheses with a number of parameters separated by a comma. These parameters are the inputs for your function. You'll be able to use these inputs in your function and reference them. After this you put a colon.\n",
    "\n",
    "The important step is that you must indent to begin the code inside your function correctly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 1: A simple print 'hello' function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_hello():\n",
    "    print('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Call the Function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "say_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2: A simple greeting function\n",
    "Let's write a function that greets people with their name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(name):\n",
    "    print('Hello',(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Daniyal\n"
     ]
    }
   ],
   "source": [
    "greeting('Daniyal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using return\n",
    "Let's see some example that use a <code>return</code> statement. <code>return</code> allows a function to *return* a result that can then be stored as a variable, or used in whatever manner a user wants.\n",
    "\n",
    "### Example 3: Addition function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_num(num1,num2): \n",
    "    return num1+num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n"
     ]
    }
   ],
   "source": [
    "# Can save as variable due to return\n",
    "result = add_num(4,10)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 4: Function with default arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_power(num,n=3):\n",
    "    '''\n",
    "    Method to get power of number\n",
    "    '''\n",
    "    return num**n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "125\n"
     ]
    }
   ],
   "source": [
    "print(my_power(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "print(my_power(5,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions exercise\n",
    "Write a Python program to reverse a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define the function\n",
    "\n",
    "def string_reverse(str1):\n",
    "    rstr1 = ''\n",
    "    index = len(str1)\n",
    "    while index > 0:\n",
    "        rstr1 += str1[ index - 1 ]\n",
    "        index = index - 1\n",
    "    return rstr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dcba\n"
     ]
    }
   ],
   "source": [
    "#call the function\n",
    "s=string_reverse('abcd')\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Built-in Functions in Python\n",
    "We will discuss some built in functions provided to us by Python. They are as following:\n",
    "* Filter\n",
    "* Map\n",
    "* Lambda\n",
    "* Range\n",
    "* Min, Max\n",
    "* Enumerate\n",
    "\n",
    "Let's have a look at the following examples and see how they work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## map function\n",
    "\n",
    "The **map** function allows you to \"map\" a function to an iterable object. That is to say you can quickly call the same function to every item in an iterable, such as a list. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(num):\n",
    "    return num**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_nums = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "new_num=[]\n",
    "for i in my_nums:\n",
    "    new_num.append(square(i))\n",
    "print(new_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using the map() function:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#printing results\n",
    "list(map(square,my_nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## filter function\n",
    "\n",
    "The filter function returns an iterator yielding those items of iterable for which function(item)\n",
    "is true. Meaning you need to filter by a function that returns either True or False. Then passing that into filter (along with your iterable) and you will get back only the results that would return True when passed to the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_even(num):\n",
    "    return num % 2 == 0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [0,1,2,3,4,5,6,7,8,9,10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(check_even,nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lets try that with map function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, False, True, False, True, False, True, False, True, False, True]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(check_even,nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## lambda expression\n",
    "\n",
    "lambda expressions allow us to create \"anonymous\" functions. This basically means we can quickly make ad-hoc functions without needing to properly define a function using def.\n",
    "\n",
    "**lambda's body is a single expression, not a block of statements.**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(num):\n",
    "    result = num**2\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could actually even write this all on one line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(num)>"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda num: num ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for displaying results\n",
    "square = lambda num: num **2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's repeat some of the examples from above with a lambda expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda num: num ** 2, my_nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task\n",
    "\n",
    "Repeat the **filter()** function example with the **lambda()** functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_nums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# wrtite the code here\n",
    "list(filter(lambda num: num % 2 == 0 , my_nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## range\n",
    "\n",
    "The range function allows you to quickly *generate* a list of integers, this comes in handy a lot, so take note of how to use it! There are 3 parameters you can pass, a start, a stop, and a step size. Let's see some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0,11))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this is a **generator** function, so to actually get a list out of it, we need to cast it to a list with **list()**. What is a generator? Its a special type of function that will generate information and not need to save it to memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 3, 6, 9]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0,11,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## enumerate\n",
    "\n",
    "enumerate is a very useful function to use with for loops. It allows us to loop over something and have an automatic counter. \n",
    "\n",
    "Here is an example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At index 0 the letter is a\n",
      "At index 0 the letter is b\n",
      "At index 0 the letter is c\n",
      "At index 0 the letter is d\n",
      "At index 0 the letter is e\n"
     ]
    }
   ],
   "source": [
    "index_count = 0\n",
    "mylist=['a','b','c','d','e']\n",
    "for letter in mylist:\n",
    "    print(\"At index \" + str(index_count) +\" the letter is \" + str(letter))\n",
    "    index_count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keeping track of how many loops you've gone through is so common, that enumerate was created so you don't need to worry about creating and updating this index_count or loop_count variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At index 0 the letter is a\n",
      "At index 1 the letter is b\n",
      "At index 2 the letter is c\n",
      "At index 3 the letter is d\n",
      "At index 4 the letter is e\n"
     ]
    }
   ],
   "source": [
    "for i,letter in enumerate(mylist):\n",
    "    print(\"At index \" + str(i) +\" the letter is \" + str(letter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And there is more! enumerate also accepts an optional argument which makes it even more useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At index 1 the letter is a\n",
      "At index 2 the letter is b\n",
      "At index 3 the letter is c\n",
      "At index 4 the letter is d\n",
      "At index 5 the letter is e\n"
     ]
    }
   ],
   "source": [
    "for i,letter in enumerate(mylist, 1):\n",
    "    print(\"At index \" + str(i) +\" the letter is \" + str(letter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## min and max\n",
    "\n",
    "Quickly check the minimum or maximum of a list with these functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [10,20,30,40,100]\n",
    "# mylist =['ab','ab']\n",
    "# mylist.count('ab')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ab'"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ac'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## random\n",
    "\n",
    "Python comes with a built in random library. There are a lot of functions included in this random library, we will check out two useful functions for now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import shuffle, randint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[30, 20, 100, 40, 10]"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10,20,30,40,100]\n",
    "shuffle(mylist)\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[30, 20, 100, 40, 10]\n"
     ]
    }
   ],
   "source": [
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from random import randint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "62"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "randint(0,100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## input\n",
    "\n",
    "This function is used in python to take input from user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Something into this box: 123123\n"
     ]
    }
   ],
   "source": [
    "a=input('Enter Something into this box: ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123123\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}