Copy_of_Python_Programming_Functions.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Python Programming: Functions",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/theBuluku/my-data-science-work/blob/master/Copy_of_Python_Programming_Functions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "at-j61Sw1cxq",
        "colab_type": "text"
      },
      "source": [
        "<font color=\"green\">*To start working on this notebook, or any other notebook that we will use in the Moringa Data Science Course, we will need to save our own copy of it. We can do this by clicking File > Save a Copy in Drive. We will then be able to make edits to our own copy of this notebook.*</font>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ME3zPRU_ulWC",
        "colab_type": "text"
      },
      "source": [
        "# Python Programming: Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qbHky4L6u0GF",
        "colab_type": "text"
      },
      "source": [
        "## 1.0 Overview"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xf2uz7Zgu26f",
        "colab_type": "code",
        "outputId": "f32a65c4-ec87-4e5d-8677-6827663a418d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Example 1\n",
        "# Below is an example of a function - my_function.\n",
        "#\n",
        "\n",
        "# This function is called my_function and contains only one line of code\n",
        "# tasked with printing.\n",
        "\n",
        "# We define our function as shown;\n",
        "# Def is the keyword used to define the function, my_function is the name of our function\n",
        "# and print() is the operation that the function undertakes;\n",
        "def my_function():\n",
        "    print(\"Hello, This is from my function!\")\n",
        "\n",
        "# Upon defining the function, we can then call it as shown below\n",
        "my_function()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, This is from my function!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nhLXZF7HuiBJ",
        "colab_type": "code",
        "outputId": "b04c3411-6456-4f49-f667-4bdd95085453",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Example 2\n",
        "# Below is is an example of a built in function\n",
        "#\n",
        "\n",
        "# what we've done in the line below is to call the print function and passed a string Hello!. \n",
        "# We will learn more about passing to functions later in this session.\n",
        "print(\"Hello!\")\n",
        "\n",
        "# print() is the built - in function. \n",
        "# Examples of other built - in python functions include range(), str(), max(), min() etc. "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bOvvo7FLXmks",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Example 3\n",
        "# We can also use a function to perform a custom complex mathematical operation\n",
        "# just as shown in the newtons_method function. \n",
        "# Bear with us for now, you do not necessarily need to understand what the newtons method\n",
        "# which is the complex mathematical operation entails. \n",
        "# What you need to know for now is that functions are used to perform a specific\n",
        "# set of operations then return an output as shown below. \n",
        "#\n",
        "\n",
        "\n",
        "def newtons_method(num, estimate):\n",
        "    # Computing a new_estimate\n",
        "    new_estimate = (estimate + num / estimate) / 2\n",
        "    print(new_estimate)\n",
        "    # Base Case: Comparing our estimate with built-in functions value\n",
        "    if new_estimate == math.sqrt(num):\n",
        "        return True\n",
        "    else:\n",
        "        # let's return our output.\n",
        "        return newtons_method(num, new_estimate)\n",
        "      \n",
        "# As we have noticed, we defined our fuction - newtons_method, then passed num and estimate \n",
        "# to the function. These values that we have passed are referred to as parameters. \n",
        "# Values can be passed to functions, then the functions perform a set of operations \n",
        "# and provide an output based on the given input. \n",
        "# More about parameters will be covered later in this session. "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4id48OhWr7L2",
        "colab_type": "text"
      },
      "source": [
        "## 1.1 Using Built-in Functions "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1Xg3vxh8sASM",
        "colab_type": "code",
        "outputId": "0417a5a8-be07-4064-d6f2-604c35bdeba4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "# Example 1\n",
        "# Let's now see how to work with a few built-in python functions\n",
        "# We will start learning about the max() built-in function\n",
        "# \n",
        "\n",
        "# The max() function will return the item with the highest value as shown\n",
        "# in the given arrays \n",
        "x = max([15, 20, 43, 33, 43])\n",
        "print(x)\n",
        "\n",
        "# Using the max() function, we can return the items with the highest value alphabetically\n",
        "y = max([\"Alice\", \"James\", \"Valerie\"])\n",
        "print(y)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "43\n",
            "Valerie\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MwsgXFvQsAMZ",
        "colab_type": "code",
        "outputId": "315f091d-f984-473a-e7e2-e7bd35878334",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        }
      },
      "source": [
        "# Example 2\n",
        "# Another built-in function that we can use is the type() function.\n",
        "# Let's use it to return the data type of the specified object. \n",
        "#\n",
        "w = 12.2\n",
        "x = 100\n",
        "y = ['Samsung', 'Sony', 'Panasonic']\n",
        "z = \"Upendo\"\n",
        "\n",
        "print(type(w))\n",
        "\n",
        "# Find out the type of x\n",
        "print(type(x))\n",
        "\n",
        "# Find out the type of y\n",
        "print(type(y))\n",
        "\n",
        "# Find out the type of z\n",
        "print(type(z))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'float'>\n",
            "<class 'int'>\n",
            "<class 'list'>\n",
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AqJAthgIr__w",
        "colab_type": "code",
        "outputId": "66116520-fbc2-4ba6-e36e-73c2b5e3ee20",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Example 3\n",
        "# This is how we can also use the built in sum() function\n",
        "# \n",
        "\n",
        "a = [232, 323, 434, 523, 323, 232] \n",
        "print(sum(a))\n",
        "\n",
        "# As we have already mentioned, examples of other built - in python functions \n",
        "# include range(), str(), max(), min() etc. "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2067\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "51m8VyKYs_e3",
        "colab_type": "text"
      },
      "source": [
        "### <font color=\"green\">1.1 Challenges</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VP7RNa_5tYiL",
        "colab_type": "code",
        "outputId": "d3df8d3c-fb9d-42e1-8c51-c0c136659afa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Challenge 1\n",
        "# Now that we have learnt to use some built-in functions, \n",
        "# Let's use the min() function to return the item with the lowest value below\n",
        "#\n",
        "z=min([70,10,30,20,40,50])\n",
        "print(z)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7OFu5O7JtZJy",
        "colab_type": "code",
        "outputId": "2a49343a-f42b-4f0f-d672-bc319b2eff93",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Challenge 2\n",
        "# Let's also round off the number 23.43 using the round() function\n",
        "#Assigning a value a and rounding it off\n",
        "a=round(23.43)\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "23\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ogr-yc4BtZIf",
        "colab_type": "code",
        "outputId": "0cafb491-5fc9-4dfc-83e5-ce8bf6e38bbb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Challenge 3\n",
        "# Lastly, let's give an example where the sorted() function can be used;\n",
        "# Hint: Feel free to perform some external research \n",
        "# \n",
        "integers=[9,6,7,5,4,0,8,5,3,4,1,2-1,-4,-5,-8,-9]\n",
        "# Sorting list of Integers in ascending\n",
        "integers.sort()\n",
        "print(integers)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[-9, -8, -5, -4, 0, 1, 1, 3, 4, 4, 5, 5, 6, 7, 8, 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-yVfw__Bu4Sl",
        "colab_type": "text"
      },
      "source": [
        "## 1.2 Creating a Function"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w4tM_RB3yPT4",
        "colab_type": "text"
      },
      "source": [
        "We will now create functions. \n",
        "\n",
        "Below are steps that we can use to create a function: \n",
        "\n",
        "*  **Step 1**: We first declare the function with the keyword `def` followed by the function name and brackets.\n",
        "*   **Step 2**: Add the program statements to be executed.\n",
        "*   **Step 3** End the function with/without return statement.\n",
        "*  **Step 4**: We will learn more about this step later in this session. If our function takes parameters, we write the arguments inside the opening and closing parentheses of the function, and end the declaration with a colon. \n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SkEtwBmMzb8k",
        "colab_type": "code",
        "outputId": "1e8f1b4a-8824-41c2-fa11-a8f854a6616e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Example 1\n",
        "# To start, we will create a function to find out which \n",
        "# of two numbers is greater than the other \n",
        "# \n",
        "\n",
        "# we define it by giving it the name max_of_two\n",
        "def max_of_two():\n",
        "  \n",
        "  # we then define our variables that will contain the numbers to be manipulated\n",
        "  first_number  = 10\n",
        "  second_number = 5\n",
        "  \n",
        "  # then we perform our operations i.e. in this case,\n",
        "  # if first_number is greater than second_number etc.\n",
        "  if first_number > second_number:\n",
        "    \n",
        "      # the return keyword allows us to provide back the result/output of our function\n",
        "    return first_number\n",
        "  \n",
        "    # the return key word allows us to provide back the result/output of our function\n",
        "  return second_number\n",
        " \n",
        "# Lastly, we do the most important step; which is to call the function that \n",
        "# we have just created above. Calling allows us to use the function. \n",
        "# We have also been calling our built-in functions from the previous section.\n",
        "#\n",
        "max_of_two()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3P8OAAcGyOP7",
        "colab_type": "code",
        "outputId": "1627bdb6-4a6d-4680-da65-6e5d2998b056",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Example 2\n",
        "# Let's now create another function to find out the square of a certain number \n",
        "# \n",
        "\n",
        "# defining our function name\n",
        "def square_of_number():\n",
        "  \n",
        "  # assigning 6 to our variable number \n",
        "  number = 6\n",
        "  \n",
        "\n",
        "  square_square_of_number = number ** 2\n",
        "  \n",
        "  # the return keyword allows us to provide back the result/output of our function\n",
        "  return square_square_of_number\n",
        "\n",
        "# now calling our function\n",
        "square_of_number()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "36"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QZFwx1lgyOhh",
        "colab_type": "code",
        "outputId": "79469731-c42e-42e8-964e-d233b6e812b7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Example 3\n",
        "# Lastly, we create another function to sum all the numbers in a list a = [6, 5, 4, 3, 2, 1]\n",
        "# \n",
        "\n",
        "def sum():\n",
        "  a = [6, 5, 4, 3, 2, 1]\n",
        "  total = 0\n",
        "  \n",
        "    # performing our operation by using a for loop to iterate through our list\n",
        "  for x in a:\n",
        "    \n",
        "    # for each iteration we perform total = total + 1;  which can be simply be written as shown below\n",
        "    total += x\n",
        "    \n",
        "  # Then lastly return our output which is to print out the value of the total variable \n",
        "  return print(total)\n",
        "\n",
        "# Lastly we call the function in order to use it\n",
        "sum()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "21\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ArRLPeQ0zTD7",
        "colab_type": "text"
      },
      "source": [
        "### <font color=\"green\">1.2 Challenges</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NQ87DKM9zaMG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a3c7e1c0-15fb-440d-a104-0f10ecaf30d1"
      },
      "source": [
        "# Challenge 1\n",
        "# Now that we have seen how to create functions, \n",
        "# let's create one that returns the maximum of two numbers;\n",
        "#\n",
        "def max_no():\n",
        "    first_no=10\n",
        "    second_no=5\n",
        "    if first_no>second_no:\n",
        "        return first_no\n",
        "    return second_no\n",
        "max_no()"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zFnXOKg5zaBc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Challenge 2\n",
        "# Let's write another function that tell us whether if a variable is between 3 and 10\n",
        "#\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6SvU7V_LzZuK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Challenge 3\n",
        "# Lastly, an online retailer provides express shipping \n",
        "# for many of its items at a rate of Ksh 200 \n",
        "# for the first item, and Ksh. 25 for each subsequent item. \n",
        "# Write a function that takes the number of items in the order from the user. \n",
        "# Return the shipping charge for the order as the function’s result. \n",
        "#\n",
        "def shipping_charge():\n",
        "    f_item=200\n",
        "    sub=25\n",
        "    no_item=int(input(\"enter the no of items\"))\n",
        "    cost = f_item + (no_item-1)*25\n",
        "    return cost\n",
        "shipping_charge()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zpJ7dsVWyURZ",
        "colab_type": "text"
      },
      "source": [
        "## 1.3 Passing Parameters and Returning Values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oGbSQfdDyy91",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "9e3919f1-2139-4493-e586-d16244f7ea2f"
      },
      "source": [
        "# Example 1\n",
        "# Parameters are variables that give to a function. The function later use the values \n",
        "# of those parameters which we call arguments to perform operations then return an output.\n",
        "# The ability for functions to take in parameter is important because it allows \n",
        "# for code re-use in different contexts. \n",
        "# To see this, let's create a function that finds the average of two numbers a and b.\n",
        "# These numbers a and b are referred to as parameters and their values are referred to arguements.\n",
        "# The parameters will be provided to the function and the function will \n",
        "# perform the average and return the result of these operations as show.\n",
        "# \n",
        "\n",
        "# Defining our function\n",
        "def avg(a,b):\n",
        "  \n",
        "  # Performing the operation\n",
        "  two_numbers_avg = (a + b)/2\n",
        "  \n",
        "  # Returning the result of our function\n",
        "  return print(two_numbers_avg) \n",
        "\n",
        "# Calling our function with arguments\n",
        "avg(2,4)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eAMUefKlyzA1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "56fa54b0-099c-4ad5-9c09-eb33419468b2"
      },
      "source": [
        "# Example 2\n",
        "# Let's create another function that takes in the name and age of a person\n",
        "# then prints out their name \n",
        "# \n",
        "\n",
        "def lastFirst(firstName, lastName):\n",
        "    separator = ', '\n",
        "    result = lastName + separator + firstName\n",
        "    return print(result)\n",
        " \n",
        "lastFirst('Tomanzi', 'Chitanda')"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Chitanda, Tomanzi\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YxUu-a7AzzcP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "43ba5f7a-3c0b-486e-996f-321b15e4ff62"
      },
      "source": [
        "# Example 3\n",
        "# Let's create another function that calculates the area of a cirlce when\n",
        "# the value radius is passed to the function\n",
        "# \n",
        "\n",
        "def circleArea(radius):\n",
        "    area = 3.14 * radius * radius \n",
        "    return print(area)\n",
        "  \n",
        "# Calling our function and passing an argumement\n",
        "circleArea(4)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "50.24\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qmwPuSsPyqff",
        "colab_type": "text"
      },
      "source": [
        "### <font color=\"green\">1.3 Challenges</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8pa4b5Jcz1kf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Challenge 1\n",
        "# Write a function that determines how many days there are in a particular month. \n",
        "# Your function will have two parameters: The month as an integer between 1 and 12, \n",
        "# and the year as a four digit integer. \n",
        "# Ensure that your function reports the correct number of days in February for leap years.\n",
        "# \n",
        "def number_days(month,year):\n",
        "    month_31 =[1,3,5,7,8,10,12]\n",
        "    month_30= [4,6,9,11]\n",
        "    if (month==2 and year%4==0):\n",
        "        print(\"This month has 29 days and is a leap year\")\n",
        "    elif(month==2 and year%4==1):\n",
        "        print(\"This is not a leap year\")\n",
        "    elif(month in month_31):\n",
        "        print(\"This month has 31 days\")\n",
        "    elif(month in month_30):\n",
        "        print(\"This month has 30 days\")\n",
        "    else:\n",
        "        print(\"invalid entry\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uyz_9HC9y4XT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Challenge 2\n",
        "# In a particular company, taxi fares consist of a base fare of Ksh.200, \n",
        "# plus Ksh.25 for every 140 meters traveled. \n",
        "# Write a function that takes the distance traveled (in kilometers) \n",
        "# as its only parameter and returns the total fare as its only result.\n",
        "#\n",
        "OUR CODE GOES HERE"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a93DEIfI1Xkc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Challenge 3\n",
        "# A particular cell phone plan includes 20 minutes of air time and 20 text messages \n",
        "# for Ksh. 50.00 a month. Each additional minute of air time costs Ksh. 3.00, \n",
        "# while additional text messages cost Ksh. 2.00 each. \n",
        "# The entire bill (including the 999 charge) is subject to 16 percent VAT tax.\n",
        "# Write a program that reads the number of minutes and text messages used in a month from the user. \n",
        "# Display the base charge, additional minutes charge (if any), \n",
        "# additional text message charge (if any), tax and total bill amount. \n",
        "# Only display the additional minute and text message charges if the user incurred costs in these categories. \n",
        "# Ensure that all of the charges are displayed using 2 decimal places.\n",
        "#\n",
        "OUR CODE GOES HERE"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}