Control flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "421091a5",
   "metadata": {},
   "source": [
    "# Control flow\n",
    "\n",
    "***\n",
    "* ## Conditional structures\n",
    "***\n",
    "\n",
    "Conditional constructs (also known as if statements) provide a way to execute a chosen block of code based on the run-time evaluation of one or more Boolean expressions. In Python, the most general form of a conditional is written as follows:\n",
    "\n",
    "```python \n",
    "if first condition:\n",
    "    first body\n",
    "elif second condition:\n",
    "    second body\n",
    "elif third condition:\n",
    "    third body\n",
    "else:\n",
    "    fourth body\n",
    "```\n",
    "\n",
    "Each condition is a Boolean expression, and each body contains one or more commands that are to be executed conditionally. If the first condition succeeds, the first body will be executed; no other conditions or bodies are evaluated in that case.\n",
    "If the first condition fails, then the process continues in similar manner with the evaluation of the second condition. The execution of this overall construct will cause precisely one of the bodies to be executed. There may be any number of elif clauses (including zero), and the final else clause is optional. As described in previous section, nonboolean types may be evaluated as Booleans with intuitive meanings.\n",
    "\n",
    "\n",
    "<div>\n",
    "<img src=\"https://www.tutorialscampus.com/sap-abap/img/decision-control3.png\" width=\"800\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c9c625a",
   "metadata": {},
   "source": [
    "* ## Introduction to the ```if``` Statement\n",
    "\n",
    "We’ll start by looking at the most basic type of if statement. In its simplest form, it looks like this:\n",
    "\n",
    "```python\n",
    "if <expr>:\n",
    "    <statement>\n",
    "```\n",
    "\n",
    "In the form shown above:\n",
    "\n",
    "* ```<expr>``` is an expression evaluated in a Boolean context, as discussed in the section on Logical Operators in the Operators and Expressions in Python tutorial.\n",
    "\n",
    "* ```<statement>``` is a valid Python statement, which must be indented.\n",
    "\n",
    "If ```<expr>``` is true (evaluates to a value that is “truthy”), then <statement> is executed. If ```<expr>``` is false, then ```<statement>``` is skipped over and not executed.\n",
    "\n",
    "Note that the colon ```:``` following ```<expr>``` is required. Some programming languages require ```<expr>``` to be enclosed in parentheses, but Python does not.\n",
    "\n",
    "Here are several examples of this type of ```if``` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5571f26f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is greater than a\n"
     ]
    }
   ],
   "source": [
    "a = 33\n",
    "b = 200\n",
    "if b > a:\n",
    "    print(\"b is greater than a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cef34444",
   "metadata": {},
   "source": [
    "* ## The ```else``` and ```elif``` Clauses\n",
    "\n",
    "* #### ```else``` clause:\n",
    "\n",
    "Now you know how to use an ```if``` statement to conditionally execute a single statement or a block of several statements. It’s time to find out what else you can do.\n",
    "\n",
    "Sometimes, you want to evaluate a condition and take one path if it is true but specify an alternative path if it is not. This is accomplished with an ```else``` clause:\n",
    "\n",
    "```python\n",
    "if <expr>:\n",
    "    <statement(s)>\n",
    "else:\n",
    "    <statement(s)>\n",
    "```\n",
    "\n",
    "If ```<expr>``` is true, the first suite is executed, and the second is skipped. If ```<expr>``` is false, the first suite is skipped and the second is executed. Either way, execution then resumes after the second suite. Both suites are defined by indentation, as described above.\n",
    "\n",
    "In this example, x is less than 50, so the first suite (lines 4 to 5) are executed, and the second suite (lines 7 to 8) are skipped:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fe584b99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(second suite)\n",
      "x is large\n"
     ]
    }
   ],
   "source": [
    "x = 200\n",
    "if x < 50:\n",
    "    print('(first suite)')\n",
    "    print('x is small')\n",
    "else:\n",
    "    print('(second suite)')\n",
    "    print('x is large')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95bb21ef",
   "metadata": {},
   "source": [
    "* ### ```elif``` clause:\n",
    "\n",
    "There is also syntax for branching execution based on several alternatives. For this, use one or more ```elif``` (short for else if) clauses. Python evaluates each ```<expr>``` in turn and executes the suite corresponding to the first that is true. If none of the expressions are true, and an ```else``` clause is specified, then its suite is executed:\n",
    "\n",
    "```python\n",
    "if <expr>:\n",
    "    <statement(s)>\n",
    "elif <expr>:\n",
    "    <statement(s)>\n",
    "elif <expr>:\n",
    "    <statement(s)>\n",
    "    ...\n",
    "else:\n",
    "    <statement(s)>\n",
    "```\n",
    "        \n",
    "An arbitrary number of elif clauses can be specified. The ```else``` clause is optional. If it is present, there can be only one, and it must be specified last:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d7bc6b46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I don't know who you are!\n"
     ]
    }
   ],
   "source": [
    "name = 'joe'\n",
    "if name == 'Fred':\n",
    "    print('Hello Fred')\n",
    "elif name == 'Xander':\n",
    "    print('Hello Xander')\n",
    "elif name == 'Joe':\n",
    "    print('Hello Joe')\n",
    "elif name == 'Arnold':\n",
    "    print('Hello Arnold')\n",
    "else:\n",
    "    print(\"I don't know who you are!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d345530b",
   "metadata": {},
   "source": [
    "* ## a much more illustrative example of if and eliff differences: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "00fd6efb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "divisible by 2\n"
     ]
    }
   ],
   "source": [
    "n = 6\n",
    "if n % 2 == 0:\n",
    "  print('divisible by 2')\n",
    "elif n % 3 == 0:\n",
    "  print('divisible by 3')\n",
    "else:\n",
    "  print('not divisible by two or three')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3070daf2",
   "metadata": {},
   "source": [
    "* what happens if we replace ```elif``` by ```if```?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "397ca6ac",
   "metadata": {},
   "source": [
    "***\n",
    "* ## loops\n",
    "***\n",
    "\n",
    "Python offers two distinct looping constructs. A while loop allows general repetition based upon the repeated testing of a Boolean condition. A for loop provides convenient iteration of values from a defined series (such as characters of a string,\n",
    "elements of a list, or numbers within a given range). We discuss both forms in this section.\n",
    "\n",
    "* ### ```while``` loop\n",
    "\n",
    "The syntax for a while loop in Python is as follows:\n",
    "\n",
    "```python \n",
    "while condition:\n",
    "    body\n",
    "```\n",
    "\n",
    "As with an if statement, condition can be an arbitrary Boolean expression, and body can be an arbitrary block of code (including nested control structures). The execution of a while loop begins with a test of the Boolean condition. If that condition evaluates to True, the body of the loop is performed. After each execution of the body, the loop condition is retested, and if it evaluates to True, another iteration of the body is performed. When the conditional test evaluates to False (assuming it ever does), the loop is exited and the flow of control continues just beyond the body of the loop.\n",
    "\n",
    "As an example, here is a loop that advances an index through a sequence of characters until finding an entry with value ```\"x\"``` or reaching the end of the sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d57e4daf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the counter value is:  4\n"
     ]
    }
   ],
   "source": [
    "j = 0\n",
    "data = [\"a\", \"p\", \"r\", \"o\", \"x\"]\n",
    "while j < len(data) and data[j] != \"x\" :\n",
    "    j += 1\n",
    "print(\"the counter value is: \", j)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47312be9",
   "metadata": {},
   "source": [
    "* ### Infinite Loops\n",
    "\n",
    "Suppose you write a ```while``` loop that theoretically never ends. Sounds weird, right?\n",
    "\n",
    "we use ```while True:``` expression for such conditions.\n",
    "\n",
    "Clearly, ```True``` will never be false, or we’re all in very big trouble. Thus, ```while True:``` initiates an infinite loop that will theoretically run forever.\n",
    "\n",
    "Maybe that doesn’t sound like something you’d want to do, but this pattern is actually quite common. For example, you might write code for a service that starts up and runs forever accepting service requests. “Forever” in this context means until you shut it down, or until the heat death of the universe, whichever comes first.\n",
    "\n",
    "More prosaically, remember that loops can be broken out of with the break statement. It may be more straightforward to terminate a loop based on conditions recognized within the loop body, rather than on a condition evaluated at the top.\n",
    "\n",
    "Here’s an example that successively removes items from a list using ```.pop()``` until it is empty:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ff92626e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "baz\n",
      "bar\n",
      "foo\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "a = ['foo', 'bar', 'baz']\n",
    "while True:\n",
    "    if len(a) == 0:\n",
    "        break\n",
    "    print(a.pop(-1))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "112110e2",
   "metadata": {},
   "source": [
    "* When a becomes empty, ```not a``` becomes true, and the ```break``` statement exits the loop.\n",
    "\n",
    "You can also specify multiple ```break``` statements in a loop:\n",
    "\n",
    "```python\n",
    "while True:\n",
    "    if <expr1>:  # One condition for loop termination\n",
    "        break\n",
    "    ...\n",
    "    if <expr2>:  # Another termination condition\n",
    "        break\n",
    "    ...\n",
    "    if <expr3>:  # Yet another\n",
    "        break\n",
    "```\n",
    "\n",
    "In cases like this, where there are multiple reasons to end the loop, it is often cleaner to break out from several different locations, rather than try to specify all the termination conditions in the loop header.\n",
    "\n",
    "Infinite loops can be very useful. <mark>Just remember that you must ensure the loop gets broken out of at some point, so it doesn’t truly become infinite.</mark>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7eb40064",
   "metadata": {},
   "source": [
    "* ### Nested ```while``` Loops\n",
    "\n",
    "In general, Python control structures can be nested within one another. For example, ```if/elif/else``` conditional statements can be nested:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "020311ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "son\n"
     ]
    }
   ],
   "source": [
    "age = 13\n",
    "gender = \"M\"\n",
    "\n",
    "if age < 18:\n",
    "    if gender == 'M':\n",
    "        print('son')\n",
    "    else:\n",
    "        print('daughter')\n",
    "elif age >= 18 and age < 65:\n",
    "    if gender == 'M':\n",
    "        print('father')\n",
    "    else:\n",
    "        print('mother')\n",
    "else:\n",
    "    if gender == 'M':\n",
    "        print('grandfather')\n",
    "    else:\n",
    "        print('grandmother')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75f60e20",
   "metadata": {},
   "source": [
    "* Similarly, a while loop can be contained within another while loop, as shown here:\n",
    "\n",
    "```python\n",
    "while <expr1>:\n",
    "    statement\n",
    "    statement\n",
    "\n",
    "    while <expr2>:\n",
    "        statement\n",
    "        statement\n",
    "        break  # Applies to while <expr2>: loop\n",
    "\n",
    "    break  # Applies to while <expr1>: loop\n",
    "```\n",
    "\n",
    "* **Note:** A ```break``` or ```continue``` statement found within nested loops applies to the nearest enclosing loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a504b4eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo\n",
      "> baz\n",
      "> qux\n",
      "bar\n",
      "> baz\n",
      "> qux\n"
     ]
    }
   ],
   "source": [
    "a = ['foo', 'bar']\n",
    "while len(a):\n",
    "    print(a.pop(0))\n",
    "    b = ['baz', 'qux']\n",
    "    while len(b):\n",
    "        print('>', b.pop(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92a0eef8",
   "metadata": {},
   "source": [
    "* Additionally, ```while``` loops can be nested inside ```if/elif/else``` statements, and vice versa:\n",
    "\n",
    "```python\n",
    "if <expr>:\n",
    "    statement\n",
    "    while <expr>:\n",
    "        statement\n",
    "        statement\n",
    "else:\n",
    "    while <expr>:\n",
    "        statement\n",
    "        statement\n",
    "    statement\n",
    "```\n",
    "\n",
    "Or\n",
    "\n",
    "```python\n",
    "while <expr>:\n",
    "    if <expr>:\n",
    "        statement\n",
    "    elif <expr>:\n",
    "        statement\n",
    "    else:\n",
    "        statement\n",
    "\n",
    "    if <expr>:\n",
    "        statement\n",
    "```\n",
    "\n",
    "In fact, all the Python control structures can be intermingled with one another to whatever extent you need. That is as it should be. Imagine how frustrating it would be if there were unexpected restrictions like “A while loop can’t be contained within an if statement” or “while loops can only be nested inside one another at most four deep.” You’d have a very difficult time remembering them all."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "494969c1",
   "metadata": {},
   "source": [
    "* ### ```for``` loop\n",
    "\n",
    "Python’s ```for``` loop syntax is a more convenient alternative to a ```while``` loop when **iterating through a series of elements**. The for-loop syntax can be used on any type of iterable structure, such as a list, tuple str, set, dict, or file. Its general syntax appears as follows.\n",
    "\n",
    "```python\n",
    "for element in iterable:\n",
    "    body # body may refer to element as an identifier\n",
    "```\n",
    "\n",
    "As an instructive example of such a loop, we consider the task of computing the sum of a list of numbers. (Admittedly, Python has a built-in function, ```sum()```, for this purpose.) We perform the calculation with a ```for``` loop as follows, assuming that data identifies the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "84d31a4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum of all elements in the list is:  15\n"
     ]
    }
   ],
   "source": [
    "summation = 0\n",
    "data = [1, 2, 3, 4, 5]\n",
    "for value in data:\n",
    "    summation += value  # note use of the loop variable, value\n",
    "print(\"sum of all elements in the list is: \", summation)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d9b04dd",
   "metadata": {},
   "source": [
    "The loop body executes once for each element of the data sequence, with the identifier, ```value```, from the for-loop syntax assigned at the beginning of each pass to a respective element. It is worth noting that ```value``` is treated as a standard identifier.\n",
    "\n",
    "If the element of the original data happens to be mutable, ```the value``` identifier can be used to invoke its methods. But a reassignment of identifier val to a new value has no affect on the original data, nor on the next iteration of the loop.\n",
    "\n",
    "As a second classic example, we consider the task of finding the maximum value in a list of elements (again, admitting that Python’s built-in ```max()``` function already provides this support). If we can assume that the list, data, has at least one\n",
    "element, we could implement this task as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "013e2bdc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum element in the list is:  24\n"
     ]
    }
   ],
   "source": [
    "data = [10, 8, 7, 12, 24, 9, 18]\n",
    "biggest = data[0] # as we assume nonempty list\n",
    "for value in data:\n",
    "    if value > biggest:\n",
    "        biggest = value\n",
    "print(\"maximum element in the list is: \", biggest)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "180e866e",
   "metadata": {},
   "source": [
    "Although we could accomplish both of the above tasks with a ```while``` loop, the ```for``` loop syntax had an advantage of simplicity, as there is no need to manage an explicit index into the list nor to author a Boolean loop condition.\n",
    "\n",
    "* <mark> Furthermore, we can use a for loop in cases for which a while loop does not apply, such as when iterating through a collection, such as a set, that does not support any direct form of indexing.</mark>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d081fe0",
   "metadata": {},
   "source": [
    "* **Index-Based ```For``` Loops**\n",
    "\n",
    "The simplicity of a standard ```for``` loop over the elements of a list is wonderful; however, one limitation of that form is that we do not know where an element resides within the sequence. In some applications, we need knowledge of the index of an\n",
    "element within the sequence. For example, suppose that we want to know where the maximum element in a list resides.\n",
    "\n",
    "Rather than directly looping over the elements of the list in that case, we prefer to loop over all possible indices of the list. For this purpose, Python provides a built-in class named ```range``` that generates integer sequences.\n",
    "\n",
    "In simplest form, the syntax ```range(n)``` generates the series of ```n``` values from ```0``` to ```n − 1```. Conveniently, these are precisely the series of valid indices into a sequence of length ```n```. Therefore, a standard Python idiom for looping through the series of indices of a data sequence uses a syntax of form:\n",
    "\n",
    "```python\n",
    "for j in range(len(data)):  # data is a name of an iterable variable\n",
    "```\n",
    "\n",
    "In this case, identifier ```j``` is not an element of the data it is an integer. But the expression ```data[j]``` can be used to retrieve the respective element. For example, we can find the index of the maximum element of a list as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1b7f9e88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum element's index in the list is:  4\n"
     ]
    }
   ],
   "source": [
    "data = [10, 8, 7, 12, 24, 9, 18]\n",
    "max_index = 0\n",
    "for j in range(len(data)):\n",
    "    if data[j] > data[max_index]:\n",
    "        max_index = j\n",
    "print(\"maximum element's index in the list is: \", max_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2eaa9a9",
   "metadata": {},
   "source": [
    "* ### The Python ```break``` and ```continue``` and ```pass``` Statements\n",
    "\n",
    "In each example you have seen so far, the entire body of the while loop is executed on each iteration. Python provides two keywords that terminate a loop iteration prematurely:\n",
    "\n",
    "* **```break```**\n",
    "\n",
    "The Python ```break``` statement immediately terminates a loop entirely. Program execution proceeds to the first statement following the loop body.\n",
    "\n",
    "* **```continue```**\n",
    "\n",
    "The Python ```continue``` statement immediately terminates the current loop iteration. Execution jumps to the top of the loop, and the controlling expression is re-evaluated to determine whether the loop will execute again or terminate.\n",
    "\n",
    "The distinction between ```break``` and ```continue``` is demonstrated in the following diagram:\n",
    "\n",
    "\n",
    "<div>\n",
    "<img src=\"https://files.realpython.com/media/t.899f357dd948.png\" width=\"300\"/>\n",
    "</div>\n",
    "\n",
    "\n",
    "Here’s a script that demonstrates the ```break``` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2a910a67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "Loop ended.\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "while n > 0:\n",
    "    n -= 1\n",
    "    if n == 2:\n",
    "        break\n",
    "    print(n)\n",
    "print('Loop ended.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "463d4606",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "1\n",
      "0\n",
      "Loop ended.\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "while n > 0:\n",
    "    n -= 1\n",
    "    if n == 2:\n",
    "        continue\n",
    "    print(n)\n",
    "print('Loop ended.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90dbd39b",
   "metadata": {},
   "source": [
    "The next script is identical except for a ```continue``` statement in place of the ```break```:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3751b2c8",
   "metadata": {},
   "source": [
    "* ### How to do nothing in python?\n",
    "\n",
    "the answer is simple, we use ```pass```.\n",
    "\n",
    "In Python, the ```pass``` keyword is an entire statement in itself. This statement doesn’t do anything: it’s discarded during the byte-compile phase. But for a statement that does nothing, the Python pass statement is surprisingly useful.\n",
    "\n",
    "Sometimes ```pass``` is useful in the final code that runs in production. More often, pass is useful as scaffolding while developing code. In specific cases, there are better alternatives to doing nothing.\n",
    "\n",
    "The next script is identical to the above examples except for a ```pass``` statement in place of the ```continue``` or ```break```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2eb1bcb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n",
      "Loop ended.\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "while n > 0:\n",
    "    n -= 1\n",
    "    if n == 2:\n",
    "        pass\n",
    "    print(n)\n",
    "print('Loop ended.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10409d96",
   "metadata": {},
   "source": [
    "* ### The else Clause\n",
    "\n",
    "Python allows an optional ```else``` clause at the end of a ```while``` loop. This is a unique feature of Python, not found in most other programming languages. The syntax is shown below:\n",
    "\n",
    "```python\n",
    "while <expr>:\n",
    "    <statement(s)>\n",
    "else:\n",
    "    <additional_statement(s)>\n",
    "```\n",
    "\n",
    "The ```<additional_statement(s)>``` specified in the else clause will be executed when the ```while``` loop **terminates***.\n",
    "\n",
    "<div>\n",
    "<img src=\"https://files.realpython.com/media/t.a370f09e82c4.png\" width=\"200\"/>\n",
    "</div>\n",
    "\n",
    "About now, you may be thinking, “How is that useful?” You could accomplish the same thing by putting those statements immediately after the while loop, without the else:\n",
    "\n",
    "```python\n",
    "while <expr>:\n",
    "    <statement(s)>\n",
    "<additional_statement(s)>\n",
    "```\n",
    "\n",
    "What’s the difference?\n",
    "\n",
    "In the latter case, without the ```else``` clause, ```<additional_statement(s)>``` will be executed after the ```while``` loop terminates, no matter what.\n",
    "\n",
    "When ```<additional_statement(s)>``` are placed in an else clause, they will be executed **only if the loop terminates “by exhaustion”** that is; if the loop iterates until the controlling condition becomes false. If the loop is exited by a break statement, the else clause won’t be executed.\n",
    "\n",
    "consider the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a44e7655",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n",
      "Loop done.\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "while n > 0:\n",
    "    n -= 1\n",
    "    print(n)\n",
    "else:\n",
    "    print('Loop done.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f85d474",
   "metadata": {},
   "source": [
    "In this case, the loop repeated until the condition was exhausted: ```n``` became ```0```, so ```n > 0``` became false. Because the loop lived out its natural life, so to speak, the else clause was executed.\n",
    "\n",
    "Now observe the difference here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7c5b1d2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "while n > 0:\n",
    "    n -= 1\n",
    "    print(n)\n",
    "    if n == 2:\n",
    "        break\n",
    "else:\n",
    "    print('Loop done.')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}