07_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Python Code Challenges: Functions"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "1264503afef8ade1"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Python Code Challenges involving functions.\n",
    "\n",
    "This article will help you review Python functions by providing some code challenges.\n",
    "\n",
    "Some of these challenges are difficult! Take some time to think about them before starting to code.\n",
    "\n",
    "You might not get the solution correct on your first try — look at your output, try to find where you’re going wrong, and iterate on your solution.\n",
    "\n",
    "Finally, if you get stuck, use our solution code! If you “Check Answer” twice with an incorrect solution, you should see an option to get our solution code. However, truly investigate that solution — experiment and play with the solution code until you have a good grasp of how it is working. Good luck!\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "93e9a4e3d799bd00"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Function Syntax\n",
    "As a refresher, function syntax looks like this:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b6c7ba1d47d896ba"
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "outputs": [],
   "source": [
    "def some_function(some_input1, some_input2):\n",
    "  # … do something with the inputs …\n",
    "  return output"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:48:11.875864Z",
     "start_time": "2023-09-25T22:48:11.669417Z"
    }
   },
   "id": "6392f2d6cee3f2f9"
  },
  {
   "cell_type": "markdown",
   "source": [
    "For example, a function that returns the sum of the first and last elements of a given list might look like this:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "41e6314f664ebdf"
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "outputs": [],
   "source": [
    "def first_plus_last(lst):\n",
    "  return lst[0] + lst[-1]"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:48:11.956528Z",
     "start_time": "2023-09-25T22:48:11.679674Z"
    }
   },
   "id": "ce0b254be1fab466"
  },
  {
   "cell_type": "markdown",
   "source": [
    "And this would produce output like:"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "f8cf52d1dc627701"
  },
  {
   "cell_type": "raw",
   "source": [
    ">>> first_plus_last([1, 2, 3, 4])\n",
    "5\n",
    ">>> first_plus_last([8, 2, 5, -8])\n",
    "0\n",
    ">>> first_plus_last([-10, 2, 3, -4])\n",
    "-14\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "ac70cc306ae0c532"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Challenges\n",
    "We’ve included 5 challenges below. Try to answer all of them and polish up your problem-solving skills and your function expertise."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "3aece099516b5dc2"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1. Tenth Power\n",
    "Let’s create some functions which can help us solve math problems! For this first function, we are going to take the tenth power of a number. In order to do this we need to do three things:\n",
    "\n",
    "1. Set up the function header for tenth_power which accepts one parameter\n",
    "2. Take the tenth power of the input value\n",
    "3. Return the result"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "710c53c8a24d3a72"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Write a function named tenth_power() that has one parameter named num.\n",
    "\n",
    "The function should return num raised to the 10th power."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "6bc52336be0b9be5"
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n",
      "1024\n"
     ]
    }
   ],
   "source": [
    "# Write your tenth_power function here:\n",
    "def tenth_power(num):\n",
    "  return num ** 10\n",
    "# Uncomment these function calls to test your tenth_power function:\n",
    "print(tenth_power(1))\n",
    "# 1 to the 10th power is 1\n",
    "print(tenth_power(0))\n",
    "# 0 to the 10th power is 0\n",
    "print(tenth_power(2))\n",
    "# 2 to the 10th power is 1024"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:48:11.995847Z",
     "start_time": "2023-09-25T22:48:11.699546Z"
    }
   },
   "id": "a30204b974ca953c"
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "outputs": [],
   "source": [
    "# Let’s go over this solution:\n",
    "\n",
    "def tenth_power(num):\n",
    "  return num ** 10"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:48:12.024377Z",
     "start_time": "2023-09-25T22:48:11.711809Z"
    }
   },
   "id": "2bce157d1cdf3608"
  },
  {
   "cell_type": "markdown",
   "source": [
    "This is one way to solve this problem using two lines of code.\n",
    "\n",
    "The first line is the function header which uses def to define the function followed by the function name. Within the parentheses we include num which is our formal parameter. Because of this, num is the variable name for the value we pass into this function.\n",
    "\n",
    "On our next line, we use return to show that this function is going to return a value when it is called. Next to the return keyword, we define what value is going to be returned. Since we need the tenth power of our input value, we can use the power operator in python which is **. Using this knowledge, in order to get the tenth power of our input value, we use num ** 10."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b206570c5d7e971b"
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   },
   "id": "cf337a266c5a29cf"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 2. Square Root\n",
    "Another useful function for solving math problems is the square root function. We can create this using similar steps from the last problem. The code will look very similar. We need to:\n",
    "\n",
    "1. Set up the function header for square_root which accepts one parameter\n",
    "2. Take the square root of the input value\n",
    "3. Return the result"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "9cbb503870b1dfaa"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Write a function named square_root() that has one parameter named num.\n",
    "\n",
    "Use exponents (**) to return the square root of num."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "3af362b890fe52f4"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Write your square_root function here:\n",
    "def square_root(num):\n",
    "  return num**(1/2)\n",
    "# Uncomment these function calls to test your square_root function:\n",
    "print(square_root(16))\n",
    "# should print 4\n",
    "print(square_root(100))\n",
    "# should print 10"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-09-25T22:48:11.756844Z"
    }
   },
   "id": "c2afbbdc194da765"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Let’s go over one possible solution:\n",
    "\n",
    "def square_root(num):\n",
    "  return num ** 0.5"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-09-25T22:48:11.770569Z"
    }
   },
   "id": "c1ccad83c17fd71"
  },
  {
   "cell_type": "markdown",
   "source": [
    "As you can see, this solution is very similar to the last problem. In this case, the only changes we need are the function name and changing the power value to 0.5. We define the function called square_root with one parameter. We then take the one half power of the input value which is mathematically the same as taking the square root and return it."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "9a6574101dda6d84"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 3. Win Percentage\n",
    "Next, we will create a function which calculates the percentage of games won. In order to do this, we will need to know how many total games there were and divide the number of wins by the total number of games. For this function, there will be two input parameters, the number of wins and the number of losses. We also need to make sure that we return the result as a percentage (in the range of 0 to 100). In order to create this method we need the following steps:\n",
    "\n",
    "1. Define the function header with two parameters, wins and losses\n",
    "2. Calculate the total number of games using the number of wins and losses\n",
    "3. Get the ratio of winning using the number of wins out of the total number of games.\n",
    "4. Convert the ratio to a percentage\n",
    "5. Return the percentage"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "c76de8b475d90ac1"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Create a function called win_percentage() that takes two parameters named wins and losses.\n",
    "\n",
    "This function should return out the total percentage of games won by a team based on these two numbers."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "25b3583dcba2d6b1"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Write your win_percentage function here:\n",
    "def win_percentage(wins, losses):\n",
    "  return int(100 * wins / (wins + losses))\n",
    "# Uncomment these function calls to test your win_percentage function:\n",
    "print(win_percentage(5, 5))\n",
    "# should print 50\n",
    "print(win_percentage(10, 0))\n",
    "# should print 100"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-09-25T22:48:11.779109Z"
    }
   },
   "id": "ec6945136bdb9f3b"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Let’s go over how we completed this function:\n",
    "\n",
    "def win_percentage(wins, losses):\n",
    "  total_games = wins + losses\n",
    "  ratio_won = wins / total_games\n",
    "  return ratio_won * 100\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-09-25T22:48:11.785544Z"
    }
   },
   "id": "3ff4f017e7968c72"
  },
  {
   "cell_type": "markdown",
   "source": [
    "First, we defined our function with two parameters, one for games won and one for games lost. Next, we calculated the total number of games using the number of wins + losses. After that, we use calculate the ratio of wins out of the total number of games by dividing wins by our total_games variable. Since this gives us a ratio and we want it in percentage form, we multiply the answer by 100 and return it."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "2bf3afc0fc81a5db"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 4. Average\n",
    "Let’s create a function which takes the average of two numbers. These two numbers will be the input of the function and the output will be the average of the two. In order to do this, we need to do a few steps:\n",
    "\n",
    "1. Define the function with two input parameters, num1 and num2\n",
    "2. Calculate the sum of the two numbers\n",
    "3. Divide the sum by the number of inputs to the function\n",
    "4. Return the answer"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "cab82477b8ac351e"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Write a function named average() that has two parameters named num1 and num2.\n",
    "\n",
    "The function should return the average of these two numbers."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "e63e8c6870779e27"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Write your average function here:\n",
    "def average(num1, num2):\n",
    "  return (num1 + num2) / 2\n",
    "# Uncomment these function calls to test your average function:\n",
    "print(average(1, 100))\n",
    "# The average of 1 and 100 is 50.5\n",
    "print(average(1, -1))\n",
    "# The average of 1 and -1 is 0"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-09-25T22:48:11.797509Z"
    }
   },
   "id": "743194f40a406c42"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Let’s look at this solution:\n",
    "\n",
    "def average(num1, num2):\n",
    "  return (num1 + num2) / 2"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2023-09-25T22:48:11.805225Z"
    }
   },
   "id": "e442bc77b3999618"
  },
  {
   "cell_type": "markdown",
   "source": [
    "In this solution, we defined the function with two parameters one line and returned the average on the next line. When returning the value, we used parentheses around the addition to cause the two numbers to be added together first before dividing by two."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "7c22b7640099e658"
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 5. Remainder\n",
    "For the final challenge in this group, we are going to take the remainder of two numbers while performing other mathematical operations on them. We are going to multiply the numerator by 2 and divide the denominator by 2. After the two values have been modified, we will divide them and return the remainder. In order to do this we will need to:\n",
    "\n",
    "1. Define the function to accept two parameters\n",
    "2. Multiply the first input value by 2\n",
    "3. Divide the second input value by 2\n",
    "4. Calculate the remainder of the modified first input value divided by the modified second input value (using modulus)\n",
    "5. Return the answer"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "bdc1af95685fa557"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Coding question\n",
    "Write a function named remainder() that has two parameters named num1 and num2.\n",
    "\n",
    "The function should return the remainder of twice num1 divided by half of num2."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "632d036d68d83e69"
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "# Write your remainder function here:\n",
    "def remainder(num1, num2):\n",
    "  return (num1 * 2) % (num2 / 2)\n",
    "\n",
    "# Uncomment these function calls to test your remainder function:\n",
    "print(remainder(15, 14))\n",
    "# should print 2\n",
    "print(remainder(9, 6))\n",
    "# should print 0"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:48:12.162700Z",
     "start_time": "2023-09-25T22:48:11.811211Z"
    }
   },
   "id": "ad6970eb9148974b"
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "outputs": [],
   "source": [
    "# Let’s go over how we did it:\n",
    "\n",
    "def remainder(num1, num2):\n",
    "  return (2 * num1) % (num2 / 2)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-09-25T22:48:12.163186Z",
     "start_time": "2023-09-25T22:48:11.827620Z"
    }
   },
   "id": "a09720364f87e44"
  },
  {
   "cell_type": "markdown",
   "source": [
    "Our solution is shortened to use only two lines of code. The first line defines the function with two input parameters. The second line performs the two mathematical operations on either side of the modulus within parenthesis. This causes the two calculations to be performed before taking the remainder of the left side divided by the right side."
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "30fe0a6435ac4ff"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}