Part_03_Writing_Functions_and_loops.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Part 03: Writing Functions and loops.ipynb",
      "provenance": []
    },
    "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"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "pQdItNpOppe8"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/WPSYG/Python-2-day-workshop/blob/master/Part_03_Writing_Functions_and_loops.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "-er6IUdUt3k3"
      },
      "source": [
        "<img src=\"https://raw.githubusercontent.com/WPSYG/Python-2-day-workshop/master/images/logo_color_v1.jpeg?token=AIW35UAKBBELC5SYDUECSYC7HQ4FW\">"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "eYVU4vuN5SsW"
      },
      "source": [
        "# Writing Functions and  Loops\n",
        "In Python, there are [built-in functions](https://docs.python.org/3/library/functions.html)  which you may have probably come across. An example is the **print()** function. However, there are often many times when you need to write your own function in order to solve a specific problem. These functions are called **user defined functions**\n",
        "\n",
        "At this point, you may be wondering what a function is in the first place?, When and why do you need it?, and most importantly how do you create one. These are very good questions to be thinking about now, but do not worry because WPSYG will digest everything for you soon.\n",
        "\n",
        "**So what is a function?**\n",
        "\n",
        "A function simply takes a set of inputs, process them and then produces some output. For instance, one can have a function that takes in your height and weight as input, and then gives your body mass index (BMI) as output. Inside the function, the height and weight are combined to produce the BMI. An already familiar function which we mentioned earlier is the *print()* function. This function takes some statements as input, and then prints them out.\n",
        "\n",
        "Here are some examples:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "b_lrwHi3n5Y9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "7e2e7a6a-4bb9-40ca-e225-b360ee941689"
      },
      "source": [
        "print(\"I love Women Promoting Science to the Younger Generation\")\n",
        "print(3+5) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I love Women Promoting Science to the Younger Generation\n",
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Zmyj9xmloIXu"
      },
      "source": [
        "The *print()* function takes the text we give as input, and prints it exactly the way it is. But then, did you notice what happened when we asked Python to print (3+5)? it rather printed 8. Why did Python do this? Discuss with your peers and TA.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "RiVbOvhtZw2Z"
      },
      "source": [
        "**Why do we need functions?**\n",
        "\n",
        "It may not yet be clear why it is worth the trouble learning about functions, but the following reasons will hopefully cheer you up.\n",
        "\n",
        "1 - Creating a new function gives you an opportunity to name a group of statements, thus making your program easier to read, understand and debug.\n",
        "\n",
        "2 - Functions make your program smaller by eliminating repetitive codes, in such a way that if you want to make a small change, you only have to make it in one place.\n",
        "\n",
        "3 - Dividing a long program into functions allows you to debug different parts one at a time, and then assembling this small parts into a whole workable unit."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "sQRIFzzWf1cv"
      },
      "source": [
        "## **How to create a function**\n",
        "\n",
        "**def Statements**\n",
        "\n",
        "The syntax for creating a function is as follows;\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "YPqxD_MShLol",
        "colab": {}
      },
      "source": [
        "def name_of_function(arg1, arg2): # step 1\n",
        "    '''\n",
        "    This is where the function's Document String (docstring) goes  # step 2\n",
        "    '''\n",
        "    # Do stuff here             # step 3\n",
        "    # Return desired result"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "DsLMTLHphprq"
      },
      "source": [
        "In step 1, we begin with *def* then a space followed by the name of the function. Next come a pair of parentheses with a number of arguments separated by a comma. After this, you put a colon.\n",
        "\n",
        "**Note:** \n",
        "\n",
        "- Be careful with the names you give to your functions. Try to keep the names relevant, and make sure that they do not have the same names as Python's [built-in functions](https://docs.python.org/3/library/functions.html)\n",
        "- In step 1, the arguments in your parantheses are the inputs for your function. You'll be able to use these inputs in your function and reference them, as we shall see in some examples.\n",
        "\n",
        "In step 2, you have the docstring. This step is important because this is where you put the description of your function. It is a very good practice to put them as it helps you and other people easily understand the code you write.\n",
        "\n",
        "Step 3 is the most important part because this is actually where you start writing your codes. What you have to keep in mind is that, for your codes to run correctly, the block of statements written here must be indented.\n",
        "\n",
        "Waooh! Great! I am sure you have learned quite alot. I believe the best way to grasp all these, is by going through some examples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "n7BkyR2IozlT"
      },
      "source": [
        "**Examples**\n",
        "\n",
        "1- **A simple Hello message**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "yPHUdhyxpzFl",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "7668442a-0d30-493b-97a1-e197c45270a6"
      },
      "source": [
        "mymessage= 'Welcome to the introductory Python course offered by WPSYG, we are happy to see you.'\n",
        "myname='friends'\n",
        "\n",
        "def intro(name, message):     # Here is the function defintion\n",
        "  print('Hello ' + name + ',' + '\\n' + message)  # Here, we are telling the function what to do     \n",
        "\n",
        "intro(myname, mymessage) # This line calls the function"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello friends,\n",
            "Welcome to the introductory Python course offered by WPSYG, we are happy to see you.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wXgFmNYhtmh6"
      },
      "source": [
        "In this example, our function name is *intro*, and it takes two inputs variables ( or arguments ) which are *name* and *message*. Its role is to print a welcome message as seen above.\n",
        "\n",
        "Now, after creating the function and telling it specifically what to do, we now need to call the function inorder to check whether it does what it is expected to do.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "fAImXa4j03jB"
      },
      "source": [
        "2- **A fun cooking recipe**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "y5JWHjIs6H2T",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "cb3af196-bca1-40ad-8b34-0e22e6337d66"
      },
      "source": [
        "b=['oil','onions','salt','eggs','bread']\n",
        "def cooking_recipe(a):\n",
        "  print('Put '+ a[0] + ' in a hot frying pan and add a misture of whipped ' + a[1] + ', ' + a[2] +' and '+ a[3] + \n",
        "        ', and let it sit for few minutes.' +'\\n'+'If the omelette has cooked to your taste, ' \n",
        "        'enjoy it with french '+ a[4] +' and a cup of hot chocolate, ummh....Yummy!!')\n",
        "\n",
        "cooking_recipe(b)  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Put oil in a hot frying pan and add a misture of whipped onions, salt and eggs, and let it sit for few minutes.\n",
            "If the omelette has cooked to your taste, enjoy it with french bread and a cup of hot chocolate, ummh....Yummy!!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "St7aJp2RJfnf"
      },
      "source": [
        "**Using return**\n",
        "\n",
        "The *return* statement 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",
        "To better appreciate its usefulness, let us consider the following examples.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "AljrTd2yLqv7"
      },
      "source": [
        "**Examples**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "V0bbWLauLppT",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9fb01dc2-538b-4256-9230-52086f23eda4"
      },
      "source": [
        "\"We define a function which adds any two numbers\"\n",
        "\n",
        "def add(x,y):\n",
        "    \n",
        "    return x + y\n",
        "\n",
        "add(2,3)"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "crB17ZImO7rJ"
      },
      "source": [
        "You can also save the result obtained when the function is called in a variable, as shown below"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "kC8VJFTuPdiU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b4eeafd8-f1b4-4cc3-de12-d458f2d4a9b4"
      },
      "source": [
        "addition= add(3.14, 5)\n",
        "print(\"The sum of 3.14 and 5 is\", addition)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The sum of 3.14 and 5 is 8.14\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "8PckEoVlWSG3"
      },
      "source": [
        "What happens if we input two strings?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "9YbPKXOzWZfz",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a635ee6f-726e-461d-dab0-c77d781c61e4"
      },
      "source": [
        "add_num('heart', 'beat')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'heartbeat'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "z3BriqNiWwZH"
      },
      "source": [
        "In the next example, we will define a function which checks whether a number is even or not. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "sLwA3f8LYRsF",
        "colab": {}
      },
      "source": [
        "\"A function which checks whether a number is even or not \"\n",
        "def iseven(num):\n",
        "    if num %2 == 0:\n",
        "        print(\"The number\", num , \"is even\")     \n",
        "    else: \n",
        "        print(\"The number\", num , \"is not even\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "GdM6bLu1Z3O3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d08bc277-bc0c-4663-d6ae-d4152fa5bf3b"
      },
      "source": [
        "iseven(320)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The number 320 is even\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Td4dzTPZZ8-H",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "250772d7-7e29-4a15-c432-e21afa0273af"
      },
      "source": [
        "iseven(11)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The number 11 is not even\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "P0YK8hqNaAwV"
      },
      "source": [
        "I guess you must be having lots of questions running through your mind. If you are puzzled, and keep wondering what these **for, if** and **else** statements above mean, *keep calm, you are perfectly right to think like this*.\n",
        "\n",
        "All your worries and questioning will hopefully be cleared off in the next section.\n",
        "\n",
        "In the meantime, *Congratulations, you have learned a lot and you are making progress. So, cheer up!! :)*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "BLoC6tw2Dltm"
      },
      "source": [
        "## **If Statements**\n",
        "\n",
        "They allow conditional execution of a code; for example,"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "eZ4RZkEYD-H6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "03d51436-706a-4397-bcc1-fe9ca505ea53"
      },
      "source": [
        "a=5\n",
        "if a>0:\n",
        "    print(\"The number is positive\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The number is positive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Yp1wJoFqEX3F"
      },
      "source": [
        "The If statement can also have an *else* branch which is executed if the condition is wrong."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gGy3WKSWEvbh",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "44961015-6964-4ef6-d342-197243829d41"
      },
      "source": [
        "a = -5\n",
        "if a>0:\n",
        "    print(\"a is positive\")\n",
        "else:\n",
        "    print(\"a is non-positive (i.e. negative or zero)\")  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a is non-positive (i.e. negative or zero)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "U7JEY2j7FaS-"
      },
      "source": [
        "Finally, there is the *elif* (read \"else if\") keyword that allows checking for several (exclusive) possibilities:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "jJ6Lw1SnGD2Z",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8324a292-b992-4d58-e146-5b88f7f77b07"
      },
      "source": [
        "a=0\n",
        "if a==0:\n",
        "    print(\"a is zero\")\n",
        "elif a<0:\n",
        "    print(\"a is negative \")\n",
        "else:\n",
        "    print(\"a is positive\")  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a is zero\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "nNRYWRr3Twq8"
      },
      "source": [
        "## **Loops** \n",
        " \n",
        "There are two types of loops in Python; **For and While**.  \n",
        "We will first look at the For Loop and then later understand how to use the While loop.\n",
        "\n",
        " **A- For Loops**\n",
        " \n",
        " A for loop is a programming concept which when implemented, executes a piece of code over and over again \"for\" a certain number of times, based on a sequence. That is, given a sequence of items or list, the for loop is used to iterate over these given sequence, as seen in the examples below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "aWn4Gx0fVyzl",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        },
        "outputId": "83ce801f-0160-4096-ac85-39a86a28c4ab"
      },
      "source": [
        "even = [2, 4, 6, 10, 12] #List of even numbers\n",
        "for num in even: # Iterate through each item in the list (even)\n",
        "    print(num) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "4\n",
            "6\n",
            "10\n",
            "12\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "bJxQhrZOWDBJ"
      },
      "source": [
        "In the above example, we have iterated over a list using for loop. However we can also use a **range()** function in for loop. Surprised to see another Python function here? Yes, **range()** is also an in built function in python. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "bjKIdcDC9Mz4"
      },
      "source": [
        "**range(n)**: It generates a set of whole numbers starting from 0 to (n-1). \n",
        "\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "4rnDF1GzZ_Xc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "f50abf1c-96ae-47c3-ce33-99c4b28e3c42"
      },
      "source": [
        "for num in range(5):\n",
        "    print(num)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "DWGvXdLN99I-"
      },
      "source": [
        "**range(start, stop)**: It generates a set of whole numbers starting from *start* to *stop-1*.\n",
        "\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "XIpqgBC6-taQ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "fe64fe20-c9e3-4dbf-ed34-0357660b9a8f"
      },
      "source": [
        "for num in range(2,7):\n",
        "    print(num)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "26e9D4io_lCN"
      },
      "source": [
        "**range(start, stop, step_size)**: It generates numbers having the difference of *step_size*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "zXXF8K3o_5wi",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "7126787b-276e-44ed-f959-5baef94896d0"
      },
      "source": [
        "'''This piece of code generates odd numbers'''\n",
        "\n",
        "for num in range(1,14,2):\n",
        "    print(num)           "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n",
            "5\n",
            "7\n",
            "9\n",
            "11\n",
            "13\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wz4kQA58aP-R"
      },
      "source": [
        "## **Format for writing a For loop**\n",
        "\n",
        "for var in iterable:\n",
        "> statement(s)\n",
        "\n",
        "\"iterable\" is a collection of objects (for example, it could be a list, tuple, etc), whereas the statement(s) in the loop are the instruction that should be excuted for each \"var\". It should be noted that the value of \"var\" continues to change after each iteration till it completes the length or items in \"iterable\". \n",
        "\n",
        "The following examples will provide a better understanding."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "35plgPyciE90",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "b5d45f38-8773-45dc-d7aa-2af340e1f18b"
      },
      "source": [
        "wpsyg_members= [\"Sokhar\", \"Bernard\", \"Yolande\", \"Faith\",\"Salomon\",\n",
        "                \"Salomey\",\"Deo\",\"Foutse\" ,\"Elkanah\", \"Deborah\"]\n",
        "\n",
        "for member in wpsyg_members:\n",
        "    print(member)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Sokhar\n",
            "Bernard\n",
            "Yolande\n",
            "Faith\n",
            "Salomon\n",
            "Salomey\n",
            "Deo\n",
            "Foutse\n",
            "Elkanah\n",
            "Deborah\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "YRYmQK9qSsZB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "d73e0cd8-978a-4c98-8381-855bdc37ac7f"
      },
      "source": [
        "words= [\"cool,\", \"readable,\", \"powerful.\"]\n",
        "\n",
        "for word in words :\n",
        "    if word == word.upper():\n",
        "        print(\"Error, none of these words are capitalized\")\n",
        "    else:  \n",
        "        print('Python is', word)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Python is cool,\n",
            "Python is readable,\n",
            "Python is powerful.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "0tV-X_3AbGjK"
      },
      "source": [
        "In the example above, the *if-else* statement inside the For loop, and we are also using another built_in function called **upper()**.\n",
        "\n",
        "**upper()**: It converts all lowercase characters to uppercase. If no lowercase characters exist, it returns the original string."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "I3JONftEir2Y"
      },
      "source": [
        "Not everything can be iterable in python. Integers , float or built in function are not iterable because we cannot use them in iteration. See the following examples;\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "K_Wb9L2Xp3ln",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "9f4ee27d-1431-457a-eb2b-8aa9fc89a171"
      },
      "source": [
        "iter(\"foobar\")\n",
        "iter([\"foo\", \"cat\", \"dog\"])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<list_iterator at 0x7f735b841510>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gPhOrdpEppgJ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 197
        },
        "outputId": "b7afd1b6-c189-4dff-ab29-29112fd04ee2"
      },
      "source": [
        "iter(3.1)\n",
        "iter(42)\n",
        "iter(len)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "'float' object is not iterable",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-60-ca20e6eba2f5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m42\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[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'float' object is not iterable"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "EonyHyPo4RqN"
      },
      "source": [
        "This throws an error message simply because the *int* object is not iterable"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "RJy0ecAmGz5y"
      },
      "source": [
        "In Python we can have an optional ‘else’ block associated with the For loop. The ‘else’ block executes only when the loop has completed all the iterations. Let's take an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Qdrr5camG-90",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "b0c08380-bc3a-415f-be1c-8eeee00e74e9"
      },
      "source": [
        "languages=['R','C++','Java','Python']\n",
        "for index in range(len(languages)):\n",
        "    print('Programming language:', languages[index])\n",
        "else:\n",
        "    print(\"Loop execution is complete\")    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Programming language: R\n",
            "Programming language: C++\n",
            "Programming language: Java\n",
            "Programming language: Python\n",
            "Loop execution is complete\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "oc69xwdOKCn_"
      },
      "source": [
        "In the example above, we are printing the various programming languages from the list named languages, and we made use of yet another built_in function called **len()**. \n",
        "\n",
        "**len()**: It returns the number of items in an object (e.g a list, tuple, array, dictionary, etc)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "F61PPuvaQc-q"
      },
      "source": [
        "**B. While Loops:**\n",
        "\n",
        "A while loop executes a piece of code over and over again \"while\" a given condition still holds true.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "xOFvXFF1XnCl"
      },
      "source": [
        "## **Syntax for While loop**\n",
        "\n",
        "while condition:\n",
        "> body of the loop\n",
        "\n",
        "The *body of the loop*  is set of Python statements which requires repeated execution. These set of statements execute repeatedly until the given *condition* returns false."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "pd5hYwBaaJYt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "18fba993-c6b9-415f-a211-4c40e4977add"
      },
      "source": [
        "# Initialises input variable\n",
        "num = 0  \n",
        "\n",
        "# Condition of the while loop\n",
        "while num < 3 :  \n",
        "    print(\"Thank you for joining WPSYG.\")\n",
        "    # Increment the value of the variable \"num\" by 1\n",
        "    num = num+1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Thank you for joining WPSYG.\n",
            "Thank you for joining WPSYG.\n",
            "Thank you for joining WPSYG.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "7-ZBpz-BcJKJ"
      },
      "source": [
        "As we earlier saw in For loops, we can also have a ‘else’ block associated with a while loop. This ‘else’ block is optional. It executes only after the loop finishes execution, as we shall see in the following example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "k9WfmYBGcHNZ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "f9c4da47-b8c7-4954-ddda-483f89390e06"
      },
      "source": [
        "num = 16\n",
        "while num > 10:\n",
        "    print(num)\n",
        "    num = num-2\n",
        "else:\n",
        "    print(\"loop execution has ended\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "16\n",
            "14\n",
            "12\n",
            "loop execution has ended\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "XENWEHmvppgM"
      },
      "source": [
        "# **Exercises**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2KpQw47u0xLy",
        "colab_type": "text"
      },
      "source": [
        "1. Write a function that takes two numbers and returns their sum "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uabfYgAa0xL0",
        "colab_type": "text"
      },
      "source": [
        "**Double-click_here_for the solution**\n",
        "\n",
        "<!-- Your Answer here:\n",
        "\n",
        "def add_num(p,q):\n",
        "  return p + q\n",
        "\n",
        "-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5PLnIYZX0xL2",
        "colab_type": "text"
      },
      "source": [
        "2. Define a function that calculates the cube of a given number"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hnzuPcIG0xL4",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "**Double-click_here_for the solution**\n",
        "\n",
        "<!-- Your Answer here:\n",
        "def cube(x):\n",
        "  return x*x*x\n",
        "-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "beF_CFuJppgM"
      },
      "source": [
        "3. Write a function func1() such that it can accept a variable length of  argument and print all arguments value\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OZKwJSG11yhv",
        "colab_type": "text"
      },
      "source": [
        "**Double-click_here_for the solution**\n",
        "\n",
        "<!-- Your Answer here:\n",
        "\n",
        "def arg1(*args):\n",
        "    for n in args:\n",
        "        print(n)\n",
        "        \n",
        "-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "CwpvtCErppgQ"
      },
      "source": [
        "4. Create a function showEmployee() in such a way that it should accept employee name, and it’s salary and display both, and if the salary is missing in function call it should show it as 9000"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_kRKSOg22BYC",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "**Double-click_here_for the solution**\n",
        "\n",
        "<!-- Your Answer here:\n",
        "\n",
        "def showEmployee(nam, sal=9000):\n",
        "    print(\"Employee\", nam, \"salary is:\", sal)\n",
        "        \n",
        "-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "oZYb-tRrenud"
      },
      "source": [
        "5. Define a function that displays and counts the vowels in the following sentence:\n",
        "\"Today is a beautiful sunny day I hope it will not rain \""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M6YUnyCS2HLY",
        "colab_type": "text"
      },
      "source": [
        "**Double-click_here_for the solution**\n",
        "\n",
        "<!-- Your Answer here:\n",
        "def vowels(sentence= \"Today is a beautiful sunny day I hope it will not rain\"):\n",
        "    sentence= sentence.lower()\n",
        "    count = 0\n",
        "    vowel_set = (\"a\", \"e\", \"i\", \"o\", \"u\")\n",
        "    for i in sentence:\n",
        "        if i in vowel_set:\n",
        "            count+=1\n",
        "    return sentence, count    \n",
        "vowels(sentence= \"Today is a beautiful sunny day I hope it will not rain\")    \n",
        "-->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4La-dfFF0xMc",
        "colab_type": "text"
      },
      "source": [
        "**Additional Exerices:**\n",
        "\n",
        "Try these exercises only if you are done with the first exercises and still have time. Otherwise, you can try it by yourself at home."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "AuHK1p7jgMWN"
      },
      "source": [
        "6. Write a program which asks the user to input two numbers, and then prints out the biggest value."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "CjZJUmrogmxT"
      },
      "source": [
        "7. Use the For and While loop to write a program which prints out all the days of the week, and the months of the year."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BZeALlD90xMg",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "8. We wish to write a program which calculates how much costs one incures when one decides to daily consume atleast 2 bottles of 330ml Guiness  for a period of 15 years."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hLg9vEY_0xMh",
        "colab_type": "text"
      },
      "source": [
        "**Double-click_here_for the solution**\n",
        "\n",
        "\"\"\"Program that calculates how much money an individual spends\n",
        "   when he/she decides to drink 2 bottles of 330ml Guiness for \n",
        "   a period of 15 years.\n",
        "\"\"\"\n",
        "\n",
        "<!-- Your Answer here:\n",
        "\n",
        "cost_per_bottle_in_cedis = 3.99\n",
        "days_per_week=7\n",
        "weeks_per_month=4\n",
        "months_per_year=12\n",
        "Total=0\n",
        "year=1\n",
        "\n",
        "def bottles_consumed_yearly(bottles_consumed_daily):\n",
        "    return bottles_consumed_daily * days_per_week * weeks_per_month * months_per_year\n",
        "\n",
        "while year <= 15:\n",
        "    yearly_cost= cost_per_bottle_in_cedis * bottles_consumed_yearly(2)  \n",
        "    Total= Total + yearly_cost\n",
        "    year= year + 1\n",
        "\n",
        "print(\"In\", year-1, \"years, one has wasted\", Total, \"cedis in Guiness.\") \n",
        "-->\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "mPddAUtAt_UD"
      },
      "source": [
        "___\n",
        "**Course Content Creators**: Sokhar Samb, [Foutse Yuehgoh](https://twitter.com/yuehgoh),  [Deborah D Kanubala](https://www.linkedin.com/in/ddk2018/), Faith Benson, Salomey Osei, [Yolande Ngueabou](https://www.linkedin.com/in/yolande-ngueabou-1826a6132/), Deo Byabazaire, Bernard Osei, Elkanah Nyabuto.\n",
        "\n",
        "\n",
        "\n",
        "**Course Reviewer:** [Salomon Kabongo](https://twitter.com/SalomonKabongo1)"
      ]
    }
  ]
}