python-branching-and-loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Branching using Conditional Statements and Loops in Python\n",
    "\n",
    "![](https://i.imgur.com/7RfcHV0.png)\n",
    "\n",
    "### Part 3 of \"Data Analysis with Python: Zero to Pandas\"\n",
    "\n",
    "\n",
    "This tutorial series is a beginner-friendly introduction to programming and data analysis using the Python programming language. These tutorials take a practical and coding-focused approach. The best way to learn the material is to execute the code and experiment with it yourself. Check out the full series here: \n",
    "\n",
    "1. [First Steps with Python and Jupyter](https://jovian.ai/aakashns/first-steps-with-python)\n",
    "2. [A Quick Tour of Variables and Data Types](https://jovian.ai/aakashns/python-variables-and-data-types)\n",
    "3. [Branching using Conditional Statements and Loops](https://jovian.ai/aakashns/python-branching-and-loops)\n",
    "4. [Writing Reusable Code Using Functions](https://jovian.ai/aakashns/python-functions-and-scope)\n",
    "5. [Reading from and Writing to Files](https://jovian.ai/aakashns/python-os-and-filesystem)\n",
    "6. [Numerical Computing with Python and Numpy](https://jovian.ai/aakashns/python-numerical-computing-with-numpy)\n",
    "7. [Analyzing Tabular Data using Pandas](https://jovian.ai/aakashns/python-pandas-data-analysis)\n",
    "8. [Data Visualization using Matplotlib & Seaborn](https://jovian.ai/aakashns/python-matplotlib-data-visualization)\n",
    "9. [Exploratory Data Analysis - A Case Study](https://jovian.ai/aakashns/python-eda-stackoverflow-survey)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial covers the following topics:\n",
    "\n",
    "- Branching with `if`, `else` and `elif`\n",
    "- Nested conditions and `if` expressions\n",
    "- Iteration with `while` loops\n",
    "- Iterating over containers with `for` loops\n",
    "- Nested loops, `break` and `continue` statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to run the code\n",
    "\n",
    "This tutorial is an executable [Jupyter notebook](https://jupyter.org) hosted on [Jovian](https://www.jovian.ai). You can _run_ this tutorial and experiment with the code examples in a couple of ways: *using free online resources* (recommended) or *on your computer*.\n",
    "\n",
    "#### Option 1: Running using free online resources (1-click, recommended)\n",
    "\n",
    "The easiest way to start executing the code is to click the **Run** button at the top of this page and select **Run on Binder**. You can also select \"Run on Colab\" or \"Run on Kaggle\", but you'll need to create an account on [Google Colab](https://colab.research.google.com) or [Kaggle](https://kaggle.com) to use these platforms.\n",
    "\n",
    "\n",
    "#### Option 2: Running on your computer locally\n",
    "\n",
    "To run the code on your computer locally, you'll need to set up [Python](https://www.python.org), download the notebook and install the required libraries. We recommend using the [Conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/) distribution of Python. Click the **Run** button at the top of this page, select the **Run Locally** option, and follow the instructions.\n",
    "\n",
    ">  **Jupyter Notebooks**: This tutorial is a [Jupyter notebook](https://jupyter.org) - a document made of _cells_. Each cell can contain code written in Python or explanations in plain English. You can execute code cells and view the results, e.g., numbers, messages, graphs, tables, files, etc., instantly within the notebook. Jupyter is a powerful platform for experimentation and analysis. Don't be afraid to mess around with the code & break things - you'll learn a lot by encountering and fixing errors. You can use the \"Kernel > Restart & Clear Output\" menu option to clear all outputs and start again from the top."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Branching with `if`, `else` and `elif`\n",
    "\n",
    "One of the most powerful features of programming languages is *branching*: the ability to make decisions and execute a different set of statements based on whether one or more conditions are true.\n",
    "\n",
    "### The `if` statement\n",
    "\n",
    "In Python, branching is implemented using the `if` statement, which is written as follows:\n",
    "\n",
    "```\n",
    "if condition:\n",
    "    statement1\n",
    "    statement2\n",
    "```\n",
    "\n",
    "The `condition` can be a value, variable or expression. If the condition evaluates to `True`, then the statements within the *`if` block* are executed. Notice the four spaces before `statement1`, `statement2`, etc. The spaces inform Python that these statements are associated with the `if` statement above. This technique of structuring code by adding spaces is called *indentation*.\n",
    "\n",
    "> **Indentation**: Python relies heavily on *indentation* (white space before a statement) to define code structure. This makes Python code easy to read and understand. You can run into problems if you don't use indentation properly. Indent your code by placing the cursor at the start of the line and pressing the `Tab` key once to add 4 spaces. Pressing `Tab` again will indent the code further by 4 more spaces, and press `Shift+Tab` will reduce the indentation by 4 spaces. \n",
    "\n",
    "\n",
    "For example, let's write some code to check and print a message if a given number is even."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_number = 34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We're inside an if block\n",
      "The given number 34 is even.\n",
      "The given number 34 is even.\n"
     ]
    }
   ],
   "source": [
    "if a_number % 2 == 0:\n",
    "    print(\"We're inside an if block\")\n",
    "    print('The given number {} is even.'.format(a_number))\n",
    "    print('The given number {} is even.'.format(a_number))    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the modulus operator `%` to calculate the remainder from the division of `a_number` by `2`. Then, we use the comparison operator `==` check if the remainder is `0`, which tells us whether the number is even, i.e., divisible by 2.\n",
    "\n",
    "Since `34` is divisible by `2`, the expression `a_number % 2 == 0` evaluates to `True`, so the `print` statement under the `if` statement is executed. Also, note that we are using the string `format` method to include the number within the message.\n",
    "\n",
    "Let's try the above again with an odd number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "another_number = 33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "if another_number % 2 == 0:\n",
    "    print('The given number {} is even.'.format(a_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, since the condition `another_number % 2 == 0` evaluates to `False`, no message is printed. \n",
    "\n",
    "### The `else` statement\n",
    "\n",
    "We may want to print a different message if the number is not even in the above example. This can be done by adding the `else` statement. It is written as follows:\n",
    "\n",
    "```\n",
    "if condition:\n",
    "    statement1\n",
    "    statement2\n",
    "else:\n",
    "    statement4\n",
    "    statement5\n",
    "\n",
    "```\n",
    "\n",
    "If `condition` evaluates to `True`, the statements in the `if` block are executed. If it evaluates to `False`, the statements in the `else` block are executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_number = 34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The given number 34 is even.\n"
     ]
    }
   ],
   "source": [
    "if a_number % 2 == 0:\n",
    "    print('The given number {} is even.'.format(a_number))\n",
    "else:\n",
    "    print('The given number {} is odd.'.format(a_number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "another_number = 33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The given number 33 is odd.\n"
     ]
    }
   ],
   "source": [
    "if another_number % 2 == 0:\n",
    "    print('The given number {} is even.'.format(another_number))\n",
    "else:\n",
    "    print('The given number {} is odd.'.format(another_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's another example, which uses the `in` operator to check membership within a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "the_3_musketeers = ('Athos', 'Porthos', 'Aramis')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_candidate = \"Athos\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Athos is a musketeer\n"
     ]
    }
   ],
   "source": [
    "if a_candidate in the_3_musketeers:\n",
    "    print(\"{} is a musketeer\".format(a_candidate))\n",
    "else:\n",
    "    print(\"{} is not a musketeer\".format(a_candidate))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `elif` statement\n",
    "\n",
    "Python also provides an `elif` statement (short for \"else if\") to chain a series of conditional blocks. The conditions are evaluated one by one. For the first condition that evaluates to `True`, the block of statements below it is executed. The remaining conditions and statements are not evaluated. So, in an `if`, `elif`, `elif`... chain, at most one block of statements is executed, the one corresponding to the first condition that evaluates to `True`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "today = 'Wednesday'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today is the day of Odin, the supreme diety.\n"
     ]
    }
   ],
   "source": [
    "if today == 'Sunday':\n",
    "    print(\"Today is the day of the sun.\")\n",
    "elif today == 'Monday':\n",
    "    print(\"Today is the day of the moon.\")\n",
    "elif today == 'Tuesday':\n",
    "    print(\"Today is the day of Tyr, the god of war.\")\n",
    "elif today == 'Wednesday':\n",
    "    print(\"Today is the day of Odin, the supreme diety.\")\n",
    "elif today == 'Thursday':\n",
    "    print(\"Today is the day of Thor, the god of thunder.\")\n",
    "elif today == 'Friday':\n",
    "    print(\"Today is the day of Frigga, the goddess of beauty.\")\n",
    "elif today == 'Saturday':\n",
    "    print(\"Today is the day of Saturn, the god of fun and feasting.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, the first 3 conditions evaluate to `False`, so none of the first 3 messages are printed. The fourth condition evaluates to `True`, so the corresponding message is printed. The remaining conditions are skipped. Try changing the value of `today` above and re-executing the cells to print all the different messages.\n",
    "\n",
    "\n",
    "To verify that the remaining conditions are skipped, let us try another example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_number = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 is divisible by 3\n"
     ]
    }
   ],
   "source": [
    "if a_number % 2 == 0:\n",
    "    print('{} is divisible by 2'.format(a_number))\n",
    "elif a_number % 3 == 0:\n",
    "    print('{} is divisible by 3'.format(a_number))\n",
    "elif a_number % 5 == 0:\n",
    "    print('{} is divisible by 5'.format(a_number))\n",
    "elif a_number % 7 == 0:\n",
    "    print('{} is divisible by 7'.format(a_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the message `15 is divisible by 5` is not printed because the condition `a_number % 5 == 0` isn't evaluated, since the previous condition `a_number % 3 == 0` evaluates to `True`. This is the key difference between using a chain of `if`, `elif`, `elif`... statements vs. a chain of `if` statements, where each condition is evaluated independently."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 is divisible by 3\n",
      "15 is divisible by 5\n"
     ]
    }
   ],
   "source": [
    "if a_number % 2 == 0:\n",
    "    print('{} is divisible by 2'.format(a_number))\n",
    "if a_number % 3 == 0:\n",
    "    print('{} is divisible by 3'.format(a_number))\n",
    "if a_number % 5 == 0:\n",
    "    print('{} is divisible by 5'.format(a_number))\n",
    "if a_number % 7 == 0:\n",
    "    print('{} is divisible by 7'.format(a_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using `if`, `elif`, and `else` together\n",
    "\n",
    "You can also include an `else` statement at the end of a chain of `if`, `elif`... statements. This code within the `else` block is evaluated when none of the conditions hold true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_number = 49"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All checks failed!\n",
      "49 is not divisible by 2, 3 or 5\n"
     ]
    }
   ],
   "source": [
    "if a_number % 2 == 0:\n",
    "    print('{} is divisible by 2'.format(a_number))\n",
    "elif a_number % 3 == 0:\n",
    "    print('{} is divisible by 3'.format(a_number))\n",
    "elif a_number % 5 == 0:\n",
    "    print('{} is divisible by 5'.format(a_number))\n",
    "else:\n",
    "    print('All checks failed!')\n",
    "    print('{} is not divisible by 2, 3 or 5'.format(a_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditions can also be combined using the logical operators `and`, `or` and `not`. Logical operators are explained in detail in the [first tutorial](https://jovian.ml/aakashns/first-steps-with-python/v/4#C49)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_number = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 12 is not divisible by 5\n"
     ]
    }
   ],
   "source": [
    "if a_number % 3 == 0 and a_number % 5 == 0:\n",
    "    print(\"The number {} is divisible by 3 and 5\".format(a_number))\n",
    "elif a_number % 5 != 0:\n",
    "    print(\"The number {} is not divisible by 5\".format(a_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Non-Boolean Conditions\n",
    "\n",
    "Note that conditions do not necessarily have to be booleans. In fact, a condition can be any value. The value is converted into a boolean automatically using the `bool` operator. This means that falsy values like `0`, `''`, `{}`, `[]`, etc. evaluate to `False` and all other values evaluate to `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The condition evaluted to False\n"
     ]
    }
   ],
   "source": [
    "if '':\n",
    "    print('The condition evaluted to True')\n",
    "else:\n",
    "    print('The condition evaluted to False')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The condition evaluted to True\n"
     ]
    }
   ],
   "source": [
    "if 'Hello':\n",
    "    print('The condition evaluted to True')\n",
    "else:\n",
    "    print('The condition evaluted to False')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The condition evaluted to True\n"
     ]
    }
   ],
   "source": [
    "if { 'a': 34 }:\n",
    "    print('The condition evaluted to True')\n",
    "else:\n",
    "    print('The condition evaluted to False')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The condition evaluted to False\n"
     ]
    }
   ],
   "source": [
    "if None:\n",
    "    print('The condition evaluted to True')\n",
    "else:\n",
    "    print('The condition evaluted to False')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested conditional statements\n",
    "\n",
    "The code inside an `if` block can also include an `if` statement inside it. This pattern is called `nesting` and is used to check for another condition after a particular condition holds true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_number = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 is odd\n",
      "15 is also divisible by 5\n"
     ]
    }
   ],
   "source": [
    "if a_number % 2 == 0:\n",
    "    print(\"{} is even\".format(a_number))\n",
    "    if a_number % 3 == 0:\n",
    "        print(\"{} is also divisible by 3\".format(a_number))\n",
    "    else:\n",
    "        print(\"{} is not divisibule by 3\".format(a_number))\n",
    "else:\n",
    "    print(\"{} is odd\".format(a_number))\n",
    "    if a_number % 5 == 0:\n",
    "        print(\"{} is also divisible by 5\".format(a_number))\n",
    "    else:\n",
    "        print(\"{} is not divisibule by 5\".format(a_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the `print` statements are indented by 8 spaces to indicate that they are part of the inner `if`/`else` blocks.\n",
    "\n",
    "> Nested `if`, `else` statements are often confusing to read and prone to human error. It's good to avoid nesting whenever possible, or limit the nesting to 1 or 2 levels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shorthand `if` conditional expression\n",
    "\n",
    "A frequent use case of the `if` statement involves testing a condition and setting a variable's value based on the condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 13 is odd.\n"
     ]
    }
   ],
   "source": [
    "a_number = 13\n",
    "\n",
    "if a_number % 2 == 0:\n",
    "    parity = 'even'\n",
    "else:\n",
    "    parity = 'odd'\n",
    "\n",
    "print('The number {} is {}.'.format(a_number, parity))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides a shorter syntax, which allows writing such conditions in a single line of code. It is known as a *conditional expression*, sometimes also referred to as a *ternary operator*. It has the following syntax:\n",
    "\n",
    "```\n",
    "x = true_value if condition else false_value\n",
    "```\n",
    "\n",
    "It has the same behavior as the following `if`-`else` block:\n",
    "\n",
    "```\n",
    "if condition:\n",
    "    x = true_value\n",
    "else:\n",
    "    x = false_value\n",
    "```\n",
    "\n",
    "Let's try it out for the example above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "parity = 'even' if a_number % 2 == 0 else 'odd'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 13 is odd.\n"
     ]
    }
   ],
   "source": [
    "print('The number {} is {}.'.format(a_number, parity))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Statements and Expressions\n",
    "\n",
    "The conditional expression highlights an essential distinction between *statements* and *expressions* in Python. \n",
    "\n",
    "> **Statements**: A statement is an instruction that can be executed. Every line of code we have written so far is a statement e.g. assigning a variable, calling a function, conditional statements using `if`, `else`, and `elif`, loops using `for` and `while` etc.\n",
    "\n",
    "> **Expressions**: An expression is some code that evaluates to a value. Examples include values of different data types, arithmetic expressions, conditions, variables, function calls, conditional expressions, etc. \n",
    "\n",
    "\n",
    "Most expressions can be executed as statements, but not all statements are expressions. For example, the regular `if` statement is not an expression since it does not evaluate to a value. It merely performs some branching in the code. Similarly, loops and function definitions are not expressions (we'll learn more about these in later sections).\n",
    "\n",
    "As a rule of thumb, an expression is anything that can appear on the right side of the assignment operator `=`. You can use this as a test for checking whether something is an expression or not. You'll get a syntax error if you try to assign something that is not an expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-34-f24978c5423e>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-34-f24978c5423e>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    result = if a_number % 2 == 0:\u001b[0m\n\u001b[1;37m             ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# if statement\n",
    "result = if a_number % 2 == 0: \n",
    "    'even'\n",
    "else:\n",
    "    'odd'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if expression\n",
    "result = 'even' if a_number % 2 == 0 else 'odd'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `pass` statement\n",
    "\n",
    "`if` statements cannot be empty, there must be at least one statement in every `if` and `elif` block. You can use the `pass` statement to do nothing and avoid getting an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_number = 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-38-2dee0af4bccb>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-38-2dee0af4bccb>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    elif a_number % 3 == 0:\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "if a_number % 2 == 0:\n",
    "    elif a_number % 3 == 0:\n",
    "        print('{} is divisible by 3 but not divisible by 2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 is divisible by 3 but not divisible by 2\n"
     ]
    }
   ],
   "source": [
    "if a_number % 2 == 0:\n",
    "    pass\n",
    "elif a_number % 3 == 0:\n",
    "    print('{} is divisible by 3 but not divisible by 2'.format(a_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save and upload your notebook\n",
    "\n",
    "Whether you're running this Jupyter notebook online or on your computer, it's essential to save your work from time to time. You can continue working on a saved notebook later or share it with friends and colleagues to let them execute your code. [Jovian](https://www.jovian.ai) offers an easy way of saving and sharing your Jupyter notebooks online."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install jovian --upgrade --quiet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import jovian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'jovian' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-40-a322f04e3a27>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mjovian\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcommit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mproject\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'python-branching-and-loops'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'jovian' is not defined"
     ]
    }
   ],
   "source": [
    "jovian.commit(project='python-branching-and-loops')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first time you run `jovian.commit`, you may be asked to provide an API Key to securely upload the notebook to your Jovian account. You can get the API key from your [Jovian profile page](https://jovian.ai) after logging in / signing up.\n",
    "\n",
    "\n",
    "`jovian.commit` uploads the notebook to your Jovian account, captures the Python environment, and creates a shareable link for your notebook, as shown above. You can use this link to share your work and let anyone (including you) run your notebooks and reproduce your work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration with `while` loops\n",
    "\n",
    "Another powerful feature of programming languages, closely related to branching, is running one or more statements multiple times. This feature is often referred to as *iteration* on *looping*, and there are two ways to do this in Python: using `while` loops and `for` loops. \n",
    "\n",
    "`while` loops have the following syntax:\n",
    "\n",
    "```\n",
    "while condition:\n",
    "    statement(s)\n",
    "```\n",
    "\n",
    "Statements in the code block under `while` are executed repeatedly as long as the `condition` evaluates to `True`. Generally, one of the statements under `while` makes some change to a variable that causes the condition to evaluate to `False` after a certain number of iterations.\n",
    "\n",
    "Let's try to calculate the factorial of `100` using a `while` loop. The factorial of a number `n` is the product (multiplication) of all the numbers from `1` to `n`, i.e., `1*2*3*...*(n-2)*(n-1)*n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The factorial of 100 is: 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "result = 1\n",
    "i = 1\n",
    "\n",
    "while i <= 100:\n",
    "    result = result * i\n",
    "    i = i+1\n",
    "\n",
    "print('The factorial of 100 is: {}'.format(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's how the above code works:\n",
    "\n",
    "* We initialize two variables, `result` and, `i`. `result` will contain the final outcome. And `i` is used to keep track of the next number to be multiplied with `result`. Both are initialized to 1 (can you explain why?)\n",
    "\n",
    "* The condition `i <= 100` holds true (since `i` is initially `1`), so the `while` block is executed.\n",
    "\n",
    "* The `result` is updated to `result * i`, `i` is increased by `1` and it now has the value `2`.\n",
    "\n",
    "* At this point, the condition `i <= 100` is evaluated again. Since it continues to hold true, `result` is again updated to `result * i`, and `i` is increased to `3`.\n",
    "\n",
    "* This process is repeated till the condition becomes false, which happens when `i` holds the value `101`. Once the condition evaluates to `False`, the execution of the loop ends, and the `print` statement below it is executed. \n",
    "\n",
    "Can you see why `result` contains the value of the factorial of 100 at the end? If not, try adding `print` statements inside the `while` block to print `result` and `i` in each iteration.\n",
    "\n",
    "\n",
    "> Iteration is a powerful technique because it gives computers a massive advantage over human beings in performing thousands or even millions of repetitive operations really fast. With just 4-5 lines of code, we were able to multiply 100 numbers almost instantly. The same code can be used to multiply a thousand numbers (just change the condition to `i <= 1000`) in a few seconds.\n",
    "\n",
    "You can check how long a cell takes to execute by adding the *magic* command `%%time` at the top of a cell. Try checking how long it takes to compute the factorial of `100`, `1000`, `10000`, `100000`, etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n",
      "Wall time: 1.99 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "result = 1\n",
    "i = 1\n",
    "\n",
    "while i <= 1000:\n",
    "    result *= i # same as result = result * i\n",
    "    i += 1 # same as i = i+1\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's another example that uses two `while` loops to create an interesting pattern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*\n",
      "**\n",
      "***\n",
      "****\n",
      "*****\n",
      "******\n",
      "*******\n",
      "********\n",
      "*********\n",
      "**********\n",
      "***********\n",
      "**********\n",
      "*********\n",
      "********\n",
      "*******\n",
      "******\n",
      "*****\n",
      "****\n",
      "***\n",
      "**\n",
      "*\n"
     ]
    }
   ],
   "source": [
    "line = '*'\n",
    "max_length = 10\n",
    "\n",
    "while len(line) <= max_length:\n",
    "    print(line)\n",
    "    line += \"*\"\n",
    "    \n",
    "while len(line) > 0:\n",
    "    print(line)\n",
    "    line = line[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you see how the above example works? As an exercise, try printing the following pattern using a while loop (Hint: use string concatenation):\n",
    "\n",
    "```\n",
    "          *\n",
    "         **\n",
    "        ***\n",
    "       ****\n",
    "      *****\n",
    "     ******\n",
    "      *****\n",
    "       ****\n",
    "        ***\n",
    "         **\n",
    "          *\n",
    "```\n",
    "\n",
    "Here's another one, putting the two together:\n",
    "\n",
    "\n",
    "```\n",
    "          *\n",
    "         ***\n",
    "        *****\n",
    "       *******\n",
    "      *********\n",
    "     ***********\n",
    "      *********\n",
    "       *******\n",
    "        *****\n",
    "         ***\n",
    "          *\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Infinite Loops\n",
    "\n",
    "Suppose the condition in a `while` loop always holds true. In that case, Python repeatedly executes the code within the loop forever, and the execution of the code never completes. This situation is called an infinite loop. It generally indicates that you've made a mistake in your code. For example, you may have provided the wrong condition or forgotten to update a variable within the loop, eventually falsifying the condition.\n",
    "\n",
    "If your code is *stuck* in an infinite loop during execution, just press the \"Stop\" button on the toolbar (next to \"Run\") or select \"Kernel > Interrupt\" from the menu bar. This will *interrupt* the execution of the code. The following two cells both lead to infinite loops and need to be interrupted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# INFINITE LOOP - INTERRUPT THIS CELL\n",
    "\n",
    "result = 1\n",
    "i = 1\n",
    "\n",
    "while i <= 100:\n",
    "    result = result * i\n",
    "    # forgot to increment i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# INFINITE LOOP - INTERRUPT THIS CELL\n",
    "\n",
    "result = 1\n",
    "i = 1\n",
    "\n",
    "while i > 0 : # wrong condition\n",
    "    result *= i\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `break` and `continue` statements\n",
    "\n",
    "You can use the `break` statement within the loop's body to immediately stop the execution and *break* out of the loop (even if the condition provided to `while` still holds true)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "result = 1\n",
    "\n",
    "while i <= 100:\n",
    "    result *= i\n",
    "    if i == 42:\n",
    "        print('Magic number 42 reached! Stopping execution..')\n",
    "        break\n",
    "    i += 1\n",
    "    \n",
    "print('i:', i)\n",
    "print('result:', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see above, the value of `i` at the end of execution is 42. This example also shows how you can use an `if` statement within a `while` loop.\n",
    "\n",
    "Sometimes you may not want to end the loop entirely, but simply skip the remaining statements in the loop and *continue* to the next loop. You can do this using the `continue` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "result = 1\n",
    "\n",
    "while i < 20:\n",
    "    i += 1\n",
    "    if i % 2 == 0:\n",
    "        print('Skipping {}'.format(i))\n",
    "        continue\n",
    "    print('Multiplying with {}'.format(i))\n",
    "    result = result * i\n",
    "    \n",
    "print('i:', i)\n",
    "print('result:', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, the statement `result = result * i` inside the loop is skipped when `i` is even, as indicated by the messages printed during execution.\n",
    "\n",
    "> **Logging**: The process of adding `print` statements at different points in the code (often within loops and conditional statements) for inspecting the values of variables at various stages of execution is called logging. As our programs get larger, they naturally become prone to human errors. Logging can help in verifying the program is working as expected. In many cases, `print` statements are added while writing & testing some code and are removed later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us record a snapshot of our work before continuing using `jovian.commit`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "window.require && require([\"base/js/namespace\"],function(Jupyter){Jupyter.notebook.save_checkpoint()})"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[jovian] Attempting to save notebook..\u001b[0m\n",
      "[jovian] Updating notebook \"aakashns/python-branching-and-loops\" on https://jovian.ai/\u001b[0m\n",
      "[jovian] Uploading notebook..\u001b[0m\n",
      "[jovian] Capturing environment..\u001b[0m\n",
      "[jovian] Committed successfully! https://jovian.ai/aakashns/python-branching-and-loops\u001b[0m\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'https://jovian.ai/aakashns/python-branching-and-loops'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "jovian.commit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration with `for` loops\n",
    "\n",
    "A `for` loop is used for iterating or looping over sequences, i.e., lists, tuples, dictionaries, strings, and *ranges*. For loops have the following syntax:\n",
    "\n",
    "```\n",
    "for value in sequence:\n",
    "    statement(s)\n",
    "```\n",
    "\n",
    "The statements within the loop are executed once for each element in `sequence`. Here's an example that prints all the element of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']\n",
    "\n",
    "for day in days:\n",
    "    print(day)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try using `for` loops with some other data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Looping over a string\n",
    "for char in 'Monday':\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Looping over a tuple\n",
    "for fruit in ['Apple', 'Banana', 'Guava']:\n",
    "    print(\"Here's a fruit:\", fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Looping over a dictionary\n",
    "person = {\n",
    "    'name': 'John Doe',\n",
    "    'sex': 'Male',\n",
    "    'age': 32,\n",
    "    'married': True\n",
    "}\n",
    "\n",
    "for key in person:\n",
    "    print(\"Key:\", key, \",\", \"Value:\", person[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that while using a dictionary with a `for` loop, the iteration happens over the dictionary's keys. The key can be used within the loop to access the value. You can also iterate directly over the values using the `.values` method or over key-value pairs using the `.items` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for value in person.values():\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key_value_pair in person.items():\n",
    "    print(key_value_pair)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since a key-value pair is a tuple, we can also extract the key & value into separate variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key, value in person.items():\n",
    "    print(\"Key:\", key, \",\", \"Value:\", value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating using `range` and `enumerate`\n",
    "\n",
    "The `range` function is used to create a sequence of numbers that can be iterated over using a `for` loop. It can be used in 3 ways:\n",
    " \n",
    "* `range(n)` - Creates a sequence of numbers from `0` to `n-1`\n",
    "* `range(a, b)` - Creates a sequence of numbers from `a` to `b-1`\n",
    "* `range(a, b, step)` - Creates a sequence of numbers from `a` to `b-1` with increments of `step`\n",
    "\n",
    "Let's try it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(7):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3, 10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3, 14, 4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ranges are used for iterating over lists when you need to track the index of elements while iterating."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']\n",
    "\n",
    "for i in range(len(a_list)):\n",
    "    print('The value at position {} is {}.'.format(i, a_list[i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to achieve the same result is by using the `enumerate` function with `a_list` as an input, which returns a tuple containing the index and the corresponding element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, val in enumerate(a_list):\n",
    "    print('The value at position {} is {}.'.format(i, val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `break`, `continue` and `pass` statements\n",
    "\n",
    "Similar to `while` loops, `for` loops also support the `break` and `continue` statements. `break` is used for breaking out of the loop and `continue` is used for skipping ahead to the next iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for day in weekdays:\n",
    "    print('Today is {}'.format(day))\n",
    "    if (day == 'Wednesday'):\n",
    "        print(\"I don't work beyond Wednesday!\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for day in weekdays:\n",
    "    if (day == 'Wednesday'):\n",
    "        print(\"I don't work on Wednesday!\")\n",
    "        continue\n",
    "    print('Today is {}'.format(day))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like `if` statements, `for` loops cannot be empty, so you can use a `pass` statement if you don't want to execute any statements inside the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for day in weekdays:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested `for` and `while` loops\n",
    "\n",
    "Similar to conditional statements, loops can be nested inside other loops. This is useful for looping lists of lists, dictionaries etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "persons = [{'name': 'John', 'sex': 'Male'}, {'name': 'Jane', 'sex': 'Female'}]\n",
    "\n",
    "for person in persons:\n",
    "    for key in person:\n",
    "        print(key, \":\", person[key])\n",
    "    print(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "days = ['Monday', 'Tuesday', 'Wednesday']\n",
    "fruits = ['apple', 'banana', 'guava']\n",
    "\n",
    "for day in days:\n",
    "    for fruit in fruits:\n",
    "        print(day, fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this, we conclude our discussion of branching and loops in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further Reading and References\n",
    "\n",
    "We've covered a lot of ground in just 3 tutorials. Practice your skills by working this assignment: https://jovian.ml/aakashns/python-practice-assignment\n",
    "\n",
    "Following are some resources to learn about more about conditional statements and loops in Python:\n",
    "\n",
    "* Python Tutorial at W3Schools: https://www.w3schools.com/python/\n",
    "* Practical Python Programming: https://dabeaz-course.github.io/practical-python/Notes/Contents.html\n",
    "* Python official documentation: https://docs.python.org/3/tutorial/index.html\n",
    "\n",
    "You are now ready to move on to the next tutorial: [Writing Reusable Code Using Functions in Python](https://jovian.ai/aakashns/python-functions-and-scope)\n",
    "\n",
    "Let's save a snapshot of our notebook one final time using `jovian.commit`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jovian.commit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questions for Revision\n",
    "\n",
    "Try answering the following questions to test your understanding of the topics covered in this notebook:\n",
    "\n",
    "1. What is branching in programming languages?\n",
    "2. What is the purpose of the `if` statement in Python?\n",
    "3. What is the syntax of the `if` statement? Give an example.\n",
    "4. What is indentation? Why is it used?\n",
    "5. What is an indented block of statements?\n",
    "6. How do you perform indentation in Python?\n",
    "7. What happens if some code is not indented correctly?\n",
    "8. What happens when the condition within the `if` statement evaluates to `True`? What happens if the condition evaluates for `false`?\n",
    "9. How do you check if a number is even?\n",
    "10. What is the purpose of the `else` statement in Python?\n",
    "11. What is the syntax of the `else` statement? Give an example.\n",
    "12. Write a program that prints different messages based on whether a number is positive or negative.\n",
    "13. Can the `else` statement be used without an `if` statement?\n",
    "14. What is the purpose of the `elif` statement in Python?\n",
    "15. What is the syntax of the `elif` statement? Give an example.\n",
    "16. Write a program that prints different messages for different months of the year.\n",
    "17. Write a program that uses `if`, `elif`, and `else` statements together.\n",
    "18. Can the `elif` statement be used without an `if` statement?\n",
    "19. Can the `elif` statement be used without an `else` statement?\n",
    "20. What is the difference between a chain of `if`, `elif`, `elif`… statements and a chain of `if`, `if`, `if`… statements? Give an example.\n",
    "21. Can non-boolean conditions be used with `if` statements? Give some examples.\n",
    "22. What are nested conditional statements? How are they useful?\n",
    "23. Give an example of nested conditional statements.\n",
    "24. Why is it advisable to avoid nested conditional statements?\n",
    "25. What is the shorthand `if` conditional expression? \n",
    "26. What is the syntax of the shorthand `if` conditional expression? Give an example.\n",
    "27. What is the difference between the shorthand `if` expression and the regular `if` statement?\n",
    "28. What is a statement in Python?\n",
    "29. What is an expression in Python?\n",
    "30. What is the difference between statements and expressions?\n",
    "31. Is every statement an expression? Give an example or counterexample.\n",
    "32. Is every expression a statement? Give an example or counterexample.\n",
    "33. What is the purpose of the pass statement in `if` blocks?\n",
    "34. What is iteration or looping in programming languages? Why is it useful?\n",
    "35. What are the two ways for performing iteration in Python?\n",
    "36. What is the purpose of the `while` statement in Python?\n",
    "37. What is the syntax of the `white` statement in Python? Give an example.\n",
    "38. Write a program to compute the sum of the numbers 1 to 100 using a while loop. \n",
    "39. Repeat the above program for numbers up to 1000, 10000, and 100000. How long does it take each loop to complete?\n",
    "40. What is an infinite loop?\n",
    "41. What causes a program to enter an infinite loop?\n",
    "42. How do you interrupt an infinite loop within Jupyter?\n",
    "43. What is the purpose of the `break` statement in Python? \n",
    "44. Give an example of using a `break` statement within a while loop.\n",
    "45. What is the purpose of the `continue` statement in Python?\n",
    "46. Give an example of using the `continue` statement within a while loop.\n",
    "47. What is logging? How is it useful?\n",
    "48. What is the purpose of the `for` statement in Python?\n",
    "49. What is the syntax of `for` loops? Give an example.\n",
    "50. How are for loops and while loops different?\n",
    "51. How do you loop over a string? Give an example.\n",
    "52. How do you loop over a list? Give an example.\n",
    "53. How do you loop over a tuple? Give an example.\n",
    "54. How do you loop over a dictionary? Give an example.\n",
    "55. What is the purpose of the `range` statement? Give an example.\n",
    "56. What is the purpose of the `enumerate` statement? Give an example.\n",
    "57. How are the `break`, `continue`, and `pass` statements used in for loops? Give examples.\n",
    "58. Can loops be nested within other loops? How is nesting useful?\n",
    "59. Give an example of a for loop nested within another for loop.\n",
    "60. Give an example of a while loop nested within another while loop.\n",
    "61. Give an example of a for loop nested within a while loop.\n",
    "62. Give an example of a while loop nested within a for loop.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}