2_Conditionals_and_Loops.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.5"
    },
    "colab": {
      "name": "2_Conditionals_and_Loops.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/vksriharsha/Python_Workshop/blob/main/2_Conditionals_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": {
        "id": "NLyL22qTTltz"
      },
      "source": [
        "<h1><center>Conditionals and loops</center></h1>\n",
        "## Introduction\n",
        "Conditional and loop statements give us the ability to control the flow of programs. Using conditional statements we can selectively execute code blocks after checking certain conditions. Using loops we can iterate over statements a number of time. In this lesson we will learn how to write conditional and loop statements in python."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nOg3rQsQTlt1"
      },
      "source": [
        "## Conditional statements\n",
        "\n",
        "### The `if` statement\n",
        "As mentioned before conditional statements enable us to execute or skip code blocks based on a condition. The simplest conditional statement in python is the *if* statement. The general syntax for *if* statement is\n",
        "\n",
        "```\n",
        "if BOOLEAN_EXPRESSION:\n",
        "    statement\n",
        "```\n",
        "\n",
        " In the above code chunk, `statement` will execute only if the value of the `BOOLEAN_EXPRESSION` evaluates to true."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3cAeO33STlt2",
        "outputId": "2d2fbfff-009f-4d69-b2b8-84ca60d5ffe4"
      },
      "source": [
        "#example of if statement\n",
        "x=2\n",
        "y=4\n",
        "\n",
        "#an if statement block\n",
        "if y>3:\n",
        "    print(\"y is greater than 3\")\n",
        "\n",
        "#another if statement block\n",
        "if x>3:\n",
        "    print(\"x is greater than 3\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "y is greater than 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0R45vfA6Tlt3"
      },
      "source": [
        "### The `if-else` statement\n",
        "Often we want to choose between two options. For this case we use *if-else*. The general syntax for *if-else* statement is\n",
        "\n",
        "```\n",
        "if BOOLEAN_EXPRESSION:\n",
        "    statementA\n",
        "else:\n",
        "    statementB\n",
        "```\n",
        "\n",
        "In the above code chunk, `statementA` will execute only if the value of the `BOOLEAN_EXPRESSION` evaluates to true otherwise `statementB` will be executed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vaf1FW01Tlt3",
        "outputId": "c432e3d7-8be2-4781-b63a-c9c3ec8615bb"
      },
      "source": [
        "#example of if-else statement\n",
        "if y>3:\n",
        "    print(\"y is greater than 3\")\n",
        "else:\n",
        "    print(\"y is not greater than 3\")\n",
        "    \n",
        "if x>3:\n",
        "    print(\"x is greater than 3\")\n",
        "else:\n",
        "    print(\"x is not greater than 3\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "y is greater than 3\n",
            "x is not greater than 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0UM1VmUlTlt5"
      },
      "source": [
        "### The `if-elif` statement\n",
        "The *if-elif* statement allows to have more than two conditions checked. The general syntax for *if-elif* statement is\n",
        "\n",
        "```\n",
        "if BOOLEAN_EXPRESSION1:\n",
        "       statementA\n",
        "elif BOOLEAN_EXPRESSION2:\n",
        "       statementB\n",
        "elif BOOLEAN_EXPRESSION3:\n",
        "       statementC\n",
        "elif BOOLEAN_EXPRESSION4:\n",
        "       statementD\n",
        "else:\n",
        "       defaultStatement\n",
        "```\n",
        "\n",
        "The above code chunk checks for 4 coolean expressions and execute the block which first evalues to true. For example if `BOOLEAN_EXPRESSION2` is true `statementB` is executed. If `BOOLEAN_EXPRESSION2` and `BOOLEAN_EXPRESSION3` both are true then also `statementB` is executed as it appears first in the *if-elif* structure. If none of the expressions are true the statement under `else` gets executed. Note that it is optional to have the `else` part.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rncCGFCaTlt5",
        "outputId": "700534d7-f17c-45d0-ddc4-e210d753d3e3"
      },
      "source": [
        "if y>3:\n",
        "    print(\"y is more than 3\")\n",
        "elif y<3:\n",
        "    print(\"y is less than 3\")\n",
        "\n",
        "if x>2:\n",
        "    print(\"x is more than 2\")\n",
        "elif x<2:\n",
        "    print(\"x is less than 2\")\n",
        "else:\n",
        "    print(\"x is equal to 2\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "y is more than 3\n",
            "x is equal to 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qOQH58s4Tlt6"
      },
      "source": [
        "\n",
        "### Nested *if-else* statements\n",
        "We can write *if-else* statements inside othe *if-else* statements. These are called nested *if-else* statements. A general syntax for nested *if-else* statement is\n",
        "\n",
        "```\n",
        "if BOOLEAN_EXPRESSION1:\n",
        "       if BOOLEAN_EXPRESSION1A:\n",
        "           statement1A\n",
        "       elif BOOLEAN_EXPRESSION1B:\n",
        "           statement1B\n",
        "       else:\n",
        "           statement1C\n",
        "elif BOOLEAN_EXPRESSION2:\n",
        "       if BOOLEAN_EXPRESSION2A:\n",
        "           statement2A\n",
        "       else:\n",
        "           statement2B\n",
        "else:\n",
        "       statement3\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0yxPiL1bTlt6",
        "outputId": "2863fb8a-8816-418d-e8c5-13b60d3027bb"
      },
      "source": [
        "#nested if-else\n",
        "if y>=3:\n",
        "    if x>=2:\n",
        "        print(\"y is more than or equal to 3 and x more than equal to 2\")\n",
        "    else:\n",
        "        print(\"y is less than 3 or x less than 2\")\n",
        "elif y<3:\n",
        "    print(\"y is less than 3\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "y is more than or equal to 3 and x more than equal to 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WQ6VnZlJTlt7"
      },
      "source": [
        "### More *if-else* examples"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZrrpmCXPTlt7",
        "outputId": "cfd2036b-956b-4849-a12b-e85461d2888c"
      },
      "source": [
        "#Note: The function input() lets user give input during runtime\n",
        "#the number entered by user is stored in the variable \"number\"\n",
        "number = int(input(\"Enter any integer: \"))\n",
        "print (\"You entered:\" + str(number))\n",
        "\n",
        "print (\"Choose an option below then press enter:\")\n",
        "\n",
        "print (\"1. Find square of the number\")\n",
        "print (\"2. Find cube of the number\")\n",
        "print (\"3. Find any other power of the number\")\n",
        "\n",
        "#the option entered by user is stored in the variable \"option\"\n",
        "option = int(input(\"Enter option (1,2,3): \"))\n",
        "\n",
        "#use if-else statements and determine which code block to execute based on user's input\n",
        "if option==1:\n",
        "    print (\"Square = \"+str(number**2))\n",
        "elif option==2:\n",
        "    print (\"Cube = \"+str(number**3))\n",
        "elif option==3:\n",
        "    power = int(input(\"Enter the power: \"))\n",
        "    if power > 5:\n",
        "        print (\"power is to high...\")\n",
        "    else :\n",
        "        print (str(number)+\" to power \"+str(power)+\" is = \"+str(number**power))\n",
        "else:\n",
        "    print (\"Not a valid option\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter any integer: 5\n",
            "You entered:5\n",
            "Choose an option below then press enter:\n",
            "1. Find square of the number\n",
            "2. Find cube of the number\n",
            "3. Find any other power of the number\n",
            "Enter option (1,2,3): 2\n",
            "Cube = 125\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5y7Ev0LUTlt7"
      },
      "source": [
        "## Loops\n",
        "### The *for* loop\n",
        "The *for* loop can execute a code block  for a fixed number, *n*, times. The *for* loop in python can also iterate over any **iterable object** like list, strings, tuples etc.\n",
        "The next example uses the *range* function which returns a new list with numbers in the specified range. Note that python3 doesn't have *xrange*.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DO-JK9G8Tlt8",
        "outputId": "6aa7c963-81aa-48a6-f5ba-62184c834266"
      },
      "source": [
        "#print numbers 0 to 10 using a for loop\n",
        "\n",
        "for i in range(11):\n",
        "    print(i, end=' ')\n",
        "\n",
        "#print new line\n",
        "print()\n",
        "\n",
        "#define a list\n",
        "list1=['a','b','c','d','e']\n",
        "\n",
        "#iterate over the list using for\n",
        "for item in list1:\n",
        "    print(item, end=' ')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 2 3 4 5 6 7 8 9 10 \n",
            "a b c d e "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v5-o7UIhTlt9"
      },
      "source": [
        "### The *while* loop\n",
        "The *while* loop checks for a condition before executing the next iteration. The *while* loop will run as lon as the boolean expression evaluates to true."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZQNBQe7mTlt9",
        "outputId": "0d41e2c2-23c9-4b6d-eb1f-08b1b6bc2dc1"
      },
      "source": [
        "#print numbers 0 to 10 using a while loop\n",
        "\n",
        "i=0\n",
        "while(i<11):\n",
        "    print(i,end=' ')\n",
        "    i=i+1 #important to include the statement which will eventually break the loop"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 2 3 4 5 6 7 8 9 10 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-baq4nuoTlt-"
      },
      "source": [
        "### The *break* and *continue* statements\n",
        "*break* and *continue* are special statements within a loop. A *break* statement, when encountered, immediately terminates the execution of the loop and returns the control to the statement after the loop. When the *continue* statement is encountered, it immediately returns the control to the beggining of the loop. The *continue* statement skips the code below it inside the loop for the current iteration, whereas the *break* statement breaks out of the loop on to the next satement.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "41YKA-A6Tlt-",
        "outputId": "05b5022a-a1d3-467b-88cc-9460e649be4c"
      },
      "source": [
        "#break and continue example\n",
        "\n",
        "#print numbers 0 to 10 using a for loop, but stop if 7 is encountered\n",
        "for i in range(11):\n",
        "    if i==7:\n",
        "        break\n",
        "    print(i, end=' ')\n",
        "    \n",
        "#print new line\n",
        "print()\n",
        "\n",
        "#print numbers 0 to 10 using a for loop, but skip if 7 is encountered\n",
        "for i in range(11):\n",
        "    if i==7:\n",
        "        continue\n",
        "    print(i, end=' ')\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 2 3 4 5 6 \n",
            "0 1 2 3 4 5 6 8 9 10 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HPOxN3vITlt_",
        "outputId": "ce8e8e43-80d0-46e2-e539-ff92a0619105"
      },
      "source": [
        "#More for and while loop examples\n",
        "primes=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71]\n",
        "\n",
        "number = int(input(\"Enter any integer less than 20: \"))\n",
        "print (\"You entered:\" + str(number))\n",
        "\n",
        "print (\"Printing first \" + str(number)+\" primes using for loop\")\n",
        "#Note: the range(n,m) function generates a list of integers in range [n,m)\n",
        "#e.g. range(0,5): [0, 1, 2, 3, 4]\n",
        "#range(m) generates list of integers in range [0,m)\n",
        "#e.g. range(5): [0, 1, 2, 3, 4]\n",
        "for i in range(0,number): \n",
        "    print (primes[i])\n",
        "\n",
        "print (\"Printing first \" + str(number)+\" primes using while loop\")\n",
        "i=0\n",
        "while i<number:\n",
        "    print (primes[i])\n",
        "    i=i+1\n",
        "\n",
        "print (\"Printing first \" + str(number)+\" primes using for loop with break\")\n",
        "i=0\n",
        "for p in primes: \n",
        "    print (p)\n",
        "    i=i+1\n",
        "    if i == number:\n",
        "        break\n",
        "\n",
        "print (\"Printing first \" + str(number)+\" primes using while loop with break\")\n",
        "i=0\n",
        "while True:\n",
        "    print (primes[i])\n",
        "    i=i+1\n",
        "    if i == number:\n",
        "        break\n",
        "\n",
        "#using continue is not efficient in this case as the loop continues to run, doing nothing, until it reaches end of the list\n",
        "print (\"Printing first \" + str(number)+\" primes using for loop with continue\")\n",
        "i=0\n",
        "for p in primes:\n",
        "    if i >= number:\n",
        "        continue\n",
        "    print (p)\n",
        "    i=i+1\n",
        "    \n",
        "print (\"Printing first \" + str(number)+\" primes using while loop with continue\")\n",
        "i=0\n",
        "while i< len(primes):\n",
        "    #Note: the statement i=i+1. We have to increment i with each iteration otherwise we will no reach the stopping criteria and loop will continue indefinitely !!!\n",
        "    #If we choose to skip a code block we still must increment i by 1\n",
        "    if i >= number:\n",
        "        i=i+1\n",
        "        continue\n",
        "    print (primes[i])\n",
        "    i=i+1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter any integer less than 20: 12\n",
            "You entered:12\n",
            "Printing first 12 primes using for loop\n",
            "2\n",
            "3\n",
            "5\n",
            "7\n",
            "11\n",
            "13\n",
            "17\n",
            "19\n",
            "23\n",
            "29\n",
            "31\n",
            "37\n",
            "Printing first 12 primes using while loop\n",
            "2\n",
            "3\n",
            "5\n",
            "7\n",
            "11\n",
            "13\n",
            "17\n",
            "19\n",
            "23\n",
            "29\n",
            "31\n",
            "37\n",
            "Printing first 12 primes using for loop with break\n",
            "2\n",
            "3\n",
            "5\n",
            "7\n",
            "11\n",
            "13\n",
            "17\n",
            "19\n",
            "23\n",
            "29\n",
            "31\n",
            "37\n",
            "Printing first 12 primes using while loop with break\n",
            "2\n",
            "3\n",
            "5\n",
            "7\n",
            "11\n",
            "13\n",
            "17\n",
            "19\n",
            "23\n",
            "29\n",
            "31\n",
            "37\n",
            "Printing first 12 primes using for loop with continue\n",
            "2\n",
            "3\n",
            "5\n",
            "7\n",
            "11\n",
            "13\n",
            "17\n",
            "19\n",
            "23\n",
            "29\n",
            "31\n",
            "37\n",
            "Printing first 12 primes using while loop with continue\n",
            "2\n",
            "3\n",
            "5\n",
            "7\n",
            "11\n",
            "13\n",
            "17\n",
            "19\n",
            "23\n",
            "29\n",
            "31\n",
            "37\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1OL7vfQxTluA"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}