Python_Lecture_2_PYTHON_FUNCTIONS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a group of statements that exist within a program for the purpose of performing a specific task.\n",
    "\n",
    "This approach is sometimes called divide and conquer because a large task is divided into several smaller tasks that are easily performed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Simpler Code\n",
    "2. Code Reuse\n",
    "3. Better Testing\n",
    "4. Faster Development\n",
    "5. Easier Facilitation of Teamwork"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function Names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. A function name cannot contain spaces.\n",
    "2. The first character must be one of the letters a through z, A through Z, or an underscore character (_).\n",
    "3. After the first character you may use the letters a through z or A through 2, the digits O through 9, or underscores.\n",
    "4. Uppercase and lowercase characters are distinct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defining and Calling a Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code for a function is known as a function definition. To execute the function, you write a statement that calls it.\n",
    "\n",
    "//function defining\n",
    "\n",
    "def function-name( ):\n",
    "\n",
    "\tstatement \n",
    "\tstatement \n",
    "\tetc.\n",
    "    \n",
    "//function calling  \n",
    "\n",
    "function-name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am Arthur,\n",
      "King of the Britons.\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates a function. \n",
    "# First , we define a function namedmessage. \n",
    "def message(): \n",
    "    print 'I am Arthur,' \n",
    "    print 'King of the Britons.' \n",
    "# Call the message function. \n",
    "message()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have a message for you. \n",
      "I a m Arthur, \n",
      "King of the Britons. \n",
      "Goodbye!\n"
     ]
    }
   ],
   "source": [
    "# This program has two functions. First we \n",
    "# define the main function. \n",
    "def main(): \n",
    "    print 'I have a message for you. ' \n",
    "    message ( ) \n",
    "    print 'Goodbye!' \n",
    "# Next we define the message function. \n",
    "def message ( ) : \n",
    "    print 'I a m Arthur, ' \n",
    "    print 'King of the Britons. ' \n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. What is a function? \n",
    "2. What is meant by the phrase \"divide and conquer?\" \n",
    "3. How do functions help you reuse code in a program? \n",
    "4. How can functions make the development of multiple programs faster? \n",
    "5. How can functions make it easier for programs to be developed by teams of programmers?\n",
    "6. A function definition has what two parts? \n",
    "7. What does the phrase \"calling a function\" mean? \n",
    "8. When a function is executing, what happens when the end of the function's block is reached? \n",
    "9. Why must you indent the statements in a block?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indentation in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, each line in a block must be indented. The last indented line after a function header is the last line in the function's block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Designing a Program to Use Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programmers commonly use a technique known as top-down design to break down an algorithm into functions. The process of top-down design is performed in the following manner:\n",
    "\n",
    "1. The overall task that the program is to perform is broken down into a series of subtasks.\n",
    "2. Each of the subtasks is examined to determine whether it can be further broken down into more subtasks. This step is repeated until no more subtasks can be identified.\n",
    "3. Once all of the subtasks have been identified, they are written in code.\n",
    "\n",
    "This process is called top-down design because the programmer begins by looking at the topmost level of tasks that must be performed, and then breaks down those tasks into lower levels of subtasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Local Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A local variable is created inside a function and cannot be accessed by statements that are outside the function. Different functions can have local variables with the same names because the functions cannot see each other's local variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Enter your name : 7k\n",
      "Hello"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "global 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-1-2dcb1977fdf3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mraw_input\u001b[0m \u001b[0;34m(\u001b[0m \u001b[0;34m' Enter your name : '\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;31m# Call the main function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-1-2dcb1977fdf3>\u001b[0m in \u001b[0;36mmain\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mget_name\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0;32mprint\u001b[0m \u001b[0;34m'Hello'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m \u001b[0;31m# This causes an error!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;31m# Definition of the get-name function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_name\u001b[0m \u001b[0;34m(\u001b[0m \u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: global name 'name' is not defined"
     ]
    }
   ],
   "source": [
    "# Definition of the main function. \n",
    "def main( ) : \n",
    "    get_name() \n",
    "    print 'Hello', name # This causes an error! \n",
    "# Definition of the get-name function. \n",
    "def get_name ( ) : \n",
    "    name = raw_input ( ' Enter your name : ' ) \n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This program has two functions: main and g e t name. In line 8 the name variable is assigned a value that is entered by the user. This statement is inside the get_name function, so the name variable is local to that function. This means that the name variable can not be accessed by statements outside the get_name function.The main function calls the get-name function in line 3. Then, the print statement in line 4 tries to access the name variable. This results in an error because the name variable is local to the get_name function, and statements in the main function cannot access it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scope and Local Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A variable's scope is the part of a program in which the variable may be accessed. A variable is visible only to statements in the variable's scope. A local variable's scope is the function in which the variable is created.\n",
    "\n",
    "In addition, a local variable cannot be accessed by code that appears inside the function at a point before the variable has been created. For example,\n",
    "\n",
    "def bad-function(): \n",
    "\n",
    "\tprint ' The value is ' , val # This will cause an error!\n",
    "\tval = 99 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " texas has 5000 birds.\n",
      "california has 8000 birds.\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates two functions that \n",
    "# have local variables with the same name. \n",
    "def main( ) : \n",
    "    # Call the texas function. \n",
    "    texas ( ) \n",
    "    # Call the california function. \n",
    "    california () \n",
    "# Definition of the texas function. It creates \n",
    "# a local variable named birds. \n",
    "def texas(): \n",
    "    birds = 5000 \n",
    "    print 'texas has', birds, 'birds.' \n",
    "# Definition of the california function. It also \n",
    "# creates a local variable named birds. \n",
    "def california(): \n",
    "    birds = 8000 \n",
    "    print 'california has', birds, 'birds.' \n",
    "# Call the main function. \n",
    "main ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. What is a local variable? How is access to a local variable restricted?\n",
    "2. What is a variable's scope?\n",
    "3. Is it permissible for a local variable in one function to have the same name as a local variable in a different function?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Passing Arguments to Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An argument is any piece of data that is passed into a function when the function is called. A parameter is a variable that receives an argument that is passed into a function.If you want a function to receive arguments when it is called, you must equip the function with one or more parameter variables. A parameter variable, often simply called a parameter, is a special variable that is assigned the value of an argument when a function is called.\n",
    "\n",
    "def show_double(number):\n",
    "\n",
    "    result = number * 2 \n",
    "    print result\n",
    "    \n",
    "This function's name is show-double. Its purpose is to accept a number as an argument and display the value of that number doubled. Look at the function header and notice the word number that appear inside the parentheses. This is the name of a parameter variable. This variable will be assigned the value of an argument when the function is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates an argument being \n",
    "# passed to a function. \n",
    "def main(): \n",
    "    value = 5\n",
    "    show_double(value)\n",
    "# The show-double function accepts an argument \n",
    "# and displays double its value. \n",
    "def show_double(number):\n",
    "    result = number*2\n",
    "    print result \n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parameter Variable Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A parameter variable's scope is the function in which the parameter is used. All of the statements inside the function can access the parameter variable, but no statement outside the function can access it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Passing Multiple Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of 12 and 45 is\n",
      "57\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates a function that accepts \n",
    "# two arguments. \n",
    "\n",
    "def main( ) : \n",
    "\tprint 'The sum of 12 and 45 is'\n",
    "\tshow_sum(12, 45)\n",
    "# The show-sum function accepts two arguments \n",
    "# and displays their sum. \n",
    "def show_sum(num1, num2): \n",
    "\tresult = num1 + num2 \n",
    "\tprint result \n",
    "# Call the main function. \n",
    "main ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that two parameter variable names, num1 and num2, appear inside the parentheses in the show_sum function header. This is often referred to as a parameter list. Also notice that a comma separates the variable names. The statement in line 6 calls the show_sum function and passes two arguments: 12 and 45. These arguments are passed by position to the corresponding parameter variables in the function. In other words, the first argument is passed to the first parameter variable, and the second argument is passed to the second parameter variable. So, this statement causes 12 to be assigned to the num1 parameter and 45 to be assigned to the num2 parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your first name: russel\n",
      "Enter your last name: khan\n",
      "Your name reversed is\n",
      "khan russel\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates passing two string \n",
    "# arguments to a function. \n",
    "def main(): \n",
    "\tfirst_name = raw_input( 'Enter your first name: ' ) \n",
    "\tlast_name = raw_input('Enter your last name: ' ) \n",
    "\tprint 'Your name reversed is' \n",
    "\treverse_name(first_name, last_name) \n",
    "def reverse_name(first, last): \n",
    "\tprint last, first \n",
    "# Call the main function. \n",
    "main ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making changes to Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value is  99\n",
      "I am changing the value.\n",
      "Now the value is  0\n",
      "Back in main the value is 99\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates what happens when you \n",
    "# change the value of a parameter.\n",
    "def main ( ) :\n",
    "    value=99\n",
    "    print 'The value is ', value\n",
    "    change_me(value)\n",
    "    print 'Back in main the value is', value \n",
    "def change_me(arg):\n",
    "    print 'I am changing the value.'\n",
    "    arg = 0\n",
    "    print 'Now the value is ', arg \n",
    "# Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Keyword Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Previous programs demonstrate how arguments are passed by position to parameter\n",
    "variables in a function. Most programming languages match function arguments and\n",
    "parameters this way. In addition to this conventional form of argument passing, the Python\n",
    "language allows you to write an argument in the following format, to specify which param-\n",
    "eter variable the argument should be passed to:\n",
    "\n",
    "parameter_name = value\n",
    "\n",
    "In this format, parameter_name is the name of a parameter variable and value is the\n",
    "value being passed to that parameter. An argument that is written in accordance with this\n",
    "syntax is known as a keyword argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The simple interest will be 1000.00\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates keyword arguments. \n",
    "def main():\n",
    "    # Show the amount of simple interest, using 0.01 as\n",
    "    # interest rate per period, 10 as the number of periods,\n",
    "    # and $10,000 as the principal.\n",
    "    show_interest(rate=0.01, periods=10, principal=10000.0)\n",
    "    # The show-interest function displays the amount of\n",
    "    # simple interest for a given principal, interest rate\n",
    "    # per period, and number of periods.\n",
    "def show_interest(principal, rate, periods):\n",
    "    interest = principal*rate*periods\n",
    "    print 'The simple interest will be %.2f'% interest\n",
    "    # Call the main function.\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice in line 7 that the order of the keyword arguments does not match the order of the \n",
    "parameters in the function header in line 13. Because a keyword argument specifies which \n",
    "parameter the argument should be passed into, its position in the function call does not matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your first name: russel\n",
      "Enter your last name: khan\n",
      " Your name reversed is \n",
      "khan russel\n"
     ]
    }
   ],
   "source": [
    "# This program demonstrates passing two strings as \n",
    "# keyword arguments to a function. \n",
    "def main(): \n",
    "\tfirst_name = raw_input('Enter your first name: ' ) \n",
    "\tlast_name = raw_input('Enter your last name: ' ) \n",
    "\tprint ' Your name reversed is ' \n",
    "\treverse_name(last=last_name, first=first_name) \n",
    "def reverse_name(first, last): \n",
    "\tprint last, first \n",
    "# Call the main function. \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Global Variables and Global Constants"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A global variable is accessible to all the functions in a program file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# Create a global variable. \n",
    "my_value = 10 \n",
    "# The show-value function prints \n",
    "# the value of the global variable.\n",
    "def show_value(): \n",
    "\tprint my_value\n",
    "# Call the show-value function. \n",
    "show_value ( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Enter a number : 2\n",
      "The number you entered is 2\n"
     ]
    }
   ],
   "source": [
    "# Create a global variable. \n",
    "number = 0 \n",
    "def main(): \n",
    "\tglobal number \n",
    "\tnumber = input ( ' Enter a number : ' ) \n",
    "\tshow_number() \n",
    "def show_number(): \n",
    "\tprint 'The number you entered is', number, \n",
    "# Call the main function. \n",
    "main ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The assignment statement in line 2 creates a global variable named number. Notice that inside \n",
    "the main function, line 4 uses the global key word to declare the number variable. This state- \n",
    "ment tells the interpreter that the main function intends to assign a value to the global number \n",
    "variable. That's just what happens in line 5. The value entered by the user is assigned to number."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. What are the pieces of data that are passed Into a function called?\n",
    "2. What are the variables that receive pieces of data in a function called?\n",
    "3. What is a parameter variable's scope?\n",
    "4. When a parameter is changed, does this affect the argument that was passed into the parameter?\n",
    "5. What is the scope of a global variable?\n",
    "6. Give one good reason that you should not use global variables in a program.\n",
    "7. What is a global constant? Is it permissible to use global constants in a program?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Returning values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "68\n"
     ]
    }
   ],
   "source": [
    "# Here is a simple function that converts temperatures from Celsius to Fahrenheit.\n",
    "def convert(t):\n",
    "    return t*9/5+32\n",
    "print(convert(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The return statement is used to send the result of a function’s calculations back to the caller. Notice that the function itself does not do any printing. The printing is done outside of the function.\n",
    "That way, we can do math with the result, like below.\n",
    "\n",
    "print(convert(20)+5)\n",
    "\n",
    "If we had just printed the result in the function instead of returning it, the result would have been\n",
    "printed to the screen and forgotten about, and we would never be able to do anything with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.707106781187\n"
     ]
    }
   ],
   "source": [
    "# the Python math module contains trig functions, but they only\n",
    "#work in radians. Let us write our own sine function that works in degrees.\n",
    "from math import pi, sin\n",
    "def deg_sin(x):\n",
    "    return sin(pi*x/180)\n",
    "print deg_sin(45)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function can return multiple values as a list.\n",
    "\n",
    "Say we want to write a function that solves the system of equations ax + b y = e and c x + d y = f .\n",
    "It turns out that if there is a unique solution, then it is given by x = (de − b f )/(ad − bc) and\n",
    "y = (a f − ce)/(ad − bc) . We need our function to return both the x and y solutions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(' The solution is x = ', 1, ' and y = ', -1)\n"
     ]
    }
   ],
   "source": [
    "def solve(a,b,c,d,e,f):\n",
    "    x = (d*e-b*f)/(a*d-b*c)\n",
    "    y = (a*f-c*e)/(a*d-b*c)\n",
    "    return [x,y]\n",
    "xsol, ysol = solve(2,3,4,1,2,5)\n",
    "print( ' The solution is x = ' , xsol, ' and y = ' , ysol)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A return statement by itself can be used to end a function early."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hellohello\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "def multiple_print(string, n, bad_words):\n",
    "    if string in bad_words:\n",
    "        return\n",
    "    print(string * n)\n",
    "    print()\n",
    "multiple_print('hello',2,'helllo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same effect can be achieved with an if/else statement, but in some cases, using return can\n",
    "make your code simpler and more readable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some Technical Details"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def func1(x):\n",
    "    x = x + 1\n",
    "    return x\n",
    "   # print x\n",
    "def func2(L):\n",
    "    L = L + [1]\n",
    "    return L\n",
    "    #print L\n",
    "a=3\n",
    "M=[1,2,3]\n",
    "func1(a)\n",
    "print a\n",
    "func2(M)\n",
    "#print a\n",
    "print M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "[1, 2, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "def func1(x):\n",
    "    x = x + 1\n",
    "    return x\n",
    "def func2(L):\n",
    "    copy = L[:]\n",
    "    copy = copy + [1]\n",
    "    return copy\n",
    "a=3\n",
    "M=[1,2,3]\n",
    "a=func1(a)\n",
    "# note change on this line\n",
    "M= func2(M)\n",
    "print a\n",
    "print M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a function called rectangle that takes two integers m and n as arguments and prints out an m × n box consisting of asterisks.\n",
    "\n",
    "2. Write a function called add_excitement that takes a list of strings and adds an exclamation point ( ! ) to the end of each string in the list. The program should modify the original list and not return anything.\n",
    "\n",
    "3. Write the same function except that it should not modify the original list and should instead return a new list.\n",
    "\n",
    "4. The digital root of a number n is obtained as follows: Add up the digits n to get a new number. Add up the digits of that to get another new number. Keep doing this until you get a number that has only one digit. That number is the digital root. For example, if n = 45893 , we add up the digits to get 4 + 5 + 8 + 9 + 3 = 29 . We then add up the digits of 29 to get 2 + 9 = 11 . We then add up the digits of 11 to get 1 + 1 = 2 . Since 2 has only one digit, 2 is our digital root. Write a function that returns the digital root of an integer n . [Note: there is a shortcut, where the digital root is equal to n mod 9, but do not use that here.]\n",
    "\n",
    "5. Write a function that takes an integer n and returns a random integer with exactly n digits. For instance, if n is 3, then 125 and 593 would be valid return values, but 093 would not because that is really 93, which is a two-digit number.\n",
    "\n",
    "6. Write a function called matches that takes two strings as arguments and returns how many matches there are between the strings. A match is where the two strings have the same character at the same index. For instance, ' python ' and ' path ' match in the first, third, and fourth characters, so the function should return 3.\n",
    "\n",
    "7. Write a function called primes that is given a number n and returns a list of the first n primes. Let the default value of n be 100.\n",
    "\n",
    "8. Recall that if s is a string, then s.find( ' a ' ) will find the location of the first a in s . The problem is that it does not find the location of every a. Write a function called findall that given a string and a single character, returns a list containing all of the locations of that character in the string. It should return an empty list if there are no occurrences of the character in the string."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}