Day4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dbd5aa33",
   "metadata": {},
   "source": [
    "<h1 align=\"center\" >Python-Tuples and Control Structures </h1>\n",
    "\n",
    "\n",
    "#### [Click me to learn more about Python Tuples](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0c364f5-af0a-45f6-9fa0-dd1abaf351c0",
   "metadata": {},
   "source": [
    "<img align=\"center\" width=\"800\" height=\"800\"  src=\"images/datatypes1.png\"> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9717d7f2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "72ee7d3a-1068-4da7-a3e7-07c5af4c665e",
   "metadata": {},
   "source": [
    "> **A Tuple is a numerically ordered sequence of elements that can store elements of heterogeneous types, is iterable, immutable and allows duplicate elements.**\n",
    "\n",
    "<img src=\"images/tuple-1.png\" height=1000px width=1000px>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9fde379-376f-4649-8bc2-d3289bd97a38",
   "metadata": {},
   "source": [
    "- Like Lists, a Tuple in Python is also an ordered collection of values.\n",
    "- Like Lists, a Tuple is created by placing comma separated values, but in parenthesis rather square brackets. \n",
    "- Like List, a Tuple also allows us to store elements of different data types in one container.\n",
    "- Unlike List, it is not possible to add, remove, or modify values in a Tuple, so you can think of tuples as immutable Lists.\n",
    "- Apart from this, every operation that we can perform on Lists that do not modify them, can be performed on Tuples as well.\n",
    "- To be honest, Tuples are not used as often as Lists in programming, but are used when immutability is necessary.\n",
    "- When to prefer Tuples over Lists?\n",
    "    - While passing an object to a function, if you want to make sure that the object does not get changed, then Tuple become your solution. So Tuples provides a convenient source of data integrity.\n",
    "    - Similarly, since functions can return only one value, if you want a function to return more than one value, you pack your result in a tuple and return it\n",
    "    - Manipulating elements of a Tuple is far more efficient than manipulating elements of a List.\n",
    "    - Tuples being immutable are used in Dictionaries as keys (which are immutable)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69d7d4f5-78a9-4cb8-956f-ec9c49e29803",
   "metadata": {},
   "source": [
    "## Explore These by Yourself\n",
    "1. How to create Tuples?\n",
    "2. Proof of concepts: Tuples are heterogeneous, ordered, nested, immutable, and allow duplicate elements\n",
    "3. Different ways to access elements of a Tuple?\n",
    "4. Slicing a Tuple\n",
    "5. Tuple concatenation and repetition\n",
    "6. Being immutable, you cannot add elements to a Tuple\n",
    "7. Being immutable, you cannot remove elemenst from a Tuple\n",
    "8. Converting string object to Tuple and vice-versa (using type casting, `split()` and `join()`)\n",
    "9. Tuple methods\n",
    "10. Sorting a Tuple using built-in `sorted()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "77d6fb8e-1811-4ed0-a618-5faeeaf43ac1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# - Python(applications, features, libraries)\n",
    "# - IDEs(Jupyter)\n",
    "# - Variables (define, data-types, operators)\n",
    "# - Comments , indentation\n",
    "# - Numbers(int, float, complex, boolean)\n",
    "# - string(methods, indexing)\n",
    "# - list(index, duplicate, heter, iterable , mutable)\n",
    "# - dictionary(key:value pairs, sorting)\n",
    "# - if , if-else, if-elif, else, pass, "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22f54aa8",
   "metadata": {},
   "source": [
    "<h1 align=\"center\"> If-elif-else </h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef46a265",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "85ce601a",
   "metadata": {},
   "source": [
    "## Learning agenda of this notebook\n",
    "There are scenarios in programming, where we need to make a decision and based on that decision we want the flow of execution to move to one block of code or the other. In Python this decision making is done using `if...else` statements.\n",
    "1. Branching with `if`, `else`, and `elif`\n",
    "    - `if` statement\n",
    "    - `if...else` statement\n",
    "    - Ternary operator\n",
    "    - Nested `if...else` statement\n",
    "    - Ladder of `if...elif...else`\n",
    "2. The `pass` statement\n",
    "\n",
    "There are scenarios in programming, where we need to repeat a set of instructions a specified number of times or until a condition is met. This is called iteration. A programming structure that implements iteration is called a loop. In programming there are two types of iteration:\n",
    "1. Indefinite Iteration, implemented using a `while` loop\n",
    "    - Basic `while` loop examples\n",
    "    - Use of `break`,  `continue` and `else` in `while` loop   \n",
    "    - Nested `while` loop <br><br>\n",
    "3. Definite Iteration, implemented using a `for` loop\n",
    "    - Iterables and Iterators\n",
    "    - Basic `for` loop examples\n",
    "    - The `range()` and `enumerate()` functions\n",
    "    - Use of `break`, `continue` and `else` in `for` loop\n",
    "    - Nested `for` loop <br><br>\n",
    "4. **List Comprehension** \n",
    "5. **Dictionary Comprehension**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c06c9b8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 9 + 6 # this is a statement(One line of code), right side value is called a expression, here `a` is a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fac9bf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70276de2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e755077",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1e3f55a7-f269-4b4a-bcba-743a61b070de",
   "metadata": {},
   "source": [
    "### Recap of Indentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "411afb08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True Statement\n"
     ]
    }
   ],
   "source": [
    "if (2 == 1):\n",
    "    print(\"Hello!\")\n",
    "    \n",
    "print('True Statement')  # Not doing an indentation also flags an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3e6be172",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True Statement\n"
     ]
    }
   ],
   "source": [
    "print('True Statement')  # Not doing an indentation also flags an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cb9f7cd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3a39551f",
   "metadata": {},
   "source": [
    "## 2. Branching with `if`, `else` and `elif`\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8aefd78",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5f2e034e",
   "metadata": {},
   "source": [
    "### a. `if` Statement\n",
    "<img align=\"right\" width=\"300\" height=\"300\"  src=\"images/if1.png\" > \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",
    "statement(s)\n",
    "```\n",
    "\n",
    "- The `condition` can be a value, variable or expression. \n",
    "- If the condition evaluates to `True`, then the statements within the *`if` block* are executed. \n",
    "- Notice the four spaces before `statement1`, and `statement2`, which inform Python interpreter that these statements are associated with the `if` statement above. \n",
    "- This technique of structuring code by adding spaces is called *indentation*.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "63b134c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The \"if\" statement\n",
      "******************\n",
      "\n",
      "The \"if\" statement is used for conditional execution:\n",
      "\n",
      "   if_stmt ::= \"if\" assignment_expression \":\" suite\n",
      "               (\"elif\" assignment_expression \":\" suite)*\n",
      "               [\"else\" \":\" suite]\n",
      "\n",
      "It selects exactly one of the suites by evaluating the expressions one\n",
      "by one until one is found to be true (see section Boolean operations\n",
      "for the definition of true and false); then that suite is executed\n",
      "(and no other part of the \"if\" statement is executed or evaluated).\n",
      "If all expressions are false, the suite of the \"else\" clause, if\n",
      "present, is executed.\n",
      "\n",
      "Related help topics: TRUTHVALUE\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('if')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecdea0c7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8c3cb597",
   "metadata": {},
   "source": [
    "In Python the following values evaluate to `False` (they are often called *falsy* values):\n",
    "1. The value `False` itself\n",
    "2. The integer `0`\n",
    "3. The float `0.0`\n",
    "4. The empty value `None` \n",
    "5. The empty text `\"\"`\n",
    "6. The empty list `[]`\n",
    "7. The empty tuple `()`\n",
    "8. The empty dictionary `{}`\n",
    "9. The empty set `set()`\n",
    "10. The empty range `range(0)`\n",
    "\n",
    "Everything else evaluates to `True` (a value that evaluates to `True` is often called a *truthy* value).\n",
    "\n",
    "The **None** type includes a single value `None`, used to indicate the absence of a value. `None` has the type `NoneType`. It is often used to declare a variable whose value may be assigned later or as a return value of functions that do not return a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58a6a3a7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f75afdf8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False False False False\n"
     ]
    }
   ],
   "source": [
    "a = False\n",
    "b = bool(0)\n",
    "c = bool(0.0)\n",
    "d = bool(None)\n",
    "print(a, b,c, d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6ab704d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "print(type(None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc951f51",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "839e0850",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "print(x==2) # comaparing content 2==1\n",
    "print(x==3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d727491",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3a5c1e7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This will execute, only if the condition is true\n",
      "I'm in if block!\n",
      "\n",
      "\n",
      "\n",
      "I'm not in if block\n",
      "Hello\n",
      "This will always execute\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "x = 2\n",
    "if (x == 2): # you can put parenthesis around condition, but it is OK if you dont\n",
    "    print('This will execute, only if the condition is true')\n",
    "    print(\"I'm in if block!\")\n",
    "    \n",
    "print(\"\\n\\n\\nI'm not in if block\")\n",
    "print(\"Hello\")    \n",
    "print('This will always execute')\n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ae60c6c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ec30cffd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "I'm not in if block\n",
      "Hello\n",
      "This will always execute\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "x = 2\n",
    "if (x == 3): # you can put parenthesis around condition, but it is OK if you dont\n",
    "    print('This will execute, only if the condition is true')\n",
    "    print(\"I'm in if block!\")\n",
    "    \n",
    "print(\"\\n\\n\\nI'm not in if block\")\n",
    "print(\"Hello\")    \n",
    "print('This will always execute')\n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93a3e46e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e6886853",
   "metadata": {},
   "outputs": [],
   "source": [
    "# int(\"12AB\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "2e49c278",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age :  17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done!\n"
     ]
    }
   ],
   "source": [
    "# Example , take age of user and tell her/him , about his/her age status\n",
    "age = int(input(\"Enter your age : \"))\n",
    "if age >= 18:\n",
    "    print(\"You are a young person!\")\n",
    "    \n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d18eb069",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a23aa911",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9561a5c4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "59bdac9b",
   "metadata": {},
   "source": [
    "### b. `if...else` statement\n",
    "<img align=\"right\" width=\"400\" height=\"300\"  src=\"images/ifelse.png\" > \n",
    "\n",
    "- The simple `if` statement shown above tells us that if a condition is True it will execute a block of statements and if the condition is False it won’t. \n",
    "- But what if we want to do something else if the condition is false. \n",
    "- Here comes the `else` statement. We can use the `else` statement with `if` statement to execute a block of code when the condition is False. It is written as follows:\n",
    "\n",
    "```\n",
    "if condition:\n",
    "    statement1\n",
    "    statement2\n",
    "else:\n",
    "    statement3\n",
    "    statement4\n",
    "remaining statement(s)\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": 19,
   "id": "e4469b9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age :  14\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your are a teenager!\n",
      "I'm in the else block\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "# Example , take age of user and tell her/him , about his/her age status\n",
    "age = int(input(\"Enter your age : \"))\n",
    "\n",
    "\n",
    "if age>=18:\n",
    "    print(\"You are a young person!\")\n",
    "    print(\"I'm in the if Block\")\n",
    "    \n",
    "else:\n",
    "    print(\"Your are a teenager!\")\n",
    "    print(\"I'm in the else block\")\n",
    "\n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4621e3a0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3771980a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number :  23\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23 is odd number!\n",
      "I'm in else block\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "# Example : Take input from user by using the input function and decide if the number is even or odd\n",
    "number = int(input(\"Enter a number : \"))\n",
    "\n",
    "if number%2 == 0:\n",
    "    print(f\"{number} is even number!\")\n",
    "    print(\"I'm in if block\")\n",
    "    \n",
    "else:\n",
    "    print(f\"{number} is odd number!\")\n",
    "    print(\"I'm in else block\")\n",
    "\n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de70eb8c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de994e5c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7eaf078a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8226e32c",
   "metadata": {},
   "source": [
    "> The `input()` function allows a user to insert a value into a program. It returns a string value, which can be casted to any data type as per the requirement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70421ded",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c8198dab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is greater than a.\n",
      "i'm in if Block\n",
      "i'm neither in the if-block, nor in the else-block\n"
     ]
    }
   ],
   "source": [
    "#Example 2:\n",
    "a = 5\n",
    "b = 10\n",
    "if (a < b):\n",
    "    print('b is greater than a.')\n",
    "    print (\"i'm in if Block\")\n",
    "\n",
    "else:\n",
    "    print('a is smaller than b.')\n",
    "    print (\"i'm in else Block\")\n",
    "\n",
    "print (\"i'm neither in the if-block, nor in the else-block\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d5cbd91",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ba3af49",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c42be9c2",
   "metadata": {},
   "source": [
    "### c. Python Ternary Opertor\n",
    "- The Python ternary operator is a type of conditional expression that evaluates a statement. \n",
    "- This is different from the `if..else` structure mentioned above, because it is not a control structure that directs the flow of program execution. It rather acts more like an operator that defines an expression.\n",
    "```\n",
    "rv = <expr1> if <condition> else <expr2>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "09b6ffdd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number :  23\n"
     ]
    }
   ],
   "source": [
    "number = int(input(\"Enter a number : \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "81057bea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is Odd!\n"
     ]
    }
   ],
   "source": [
    "# Example: Let us assign a specific value to variable parity (even or odd), depending on a condition\n",
    "a = \"Number is even!\" if number%2==0 else \"Number is Odd!\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4abd5740",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f09cad0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "029e6291",
   "metadata": {},
   "source": [
    "### d. Nested `if...else` Statement\n",
    "Python allows us to nest `if` statements within `if` statements. i.e, we can place an if statement inside another if statement.\n",
    "<img align=\"center\" width=\"400\" height=\"300\"  src=\"images/nestedif.png\" > "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29d45c29",
   "metadata": {},
   "source": [
    "> The `input()` function allows a user to insert a value into a program. It returns a string value, which can be casted to any data type as per the requirement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "fbb5681e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age :  12\n"
     ]
    }
   ],
   "source": [
    "age = input(\"Enter your age : \")\n",
    "age = int(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4d1982df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are too young for Vote!\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "if age>=18:\n",
    "    rv = input(\"Do you have CNIC ? Y/N : \")\n",
    "    if (rv=='Y') or (rv=='y'):\n",
    "        print(\"Welcome , you can vote!\")\n",
    "    else:\n",
    "        print(\"You can vote until a CNIC!\")\n",
    "else:\n",
    "    print(\"You are too young for Vote!\")\n",
    "\n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a9faf7f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0e3a37bb",
   "metadata": {},
   "source": [
    "> 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": "code",
   "execution_count": null,
   "id": "053d4447",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ae03be7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5e1ebc20",
   "metadata": {},
   "source": [
    "<img align=\"right\" width=\"400\" height=\"300\"  src=\"images/ifladder.png\" >\n",
    "\n",
    "### e. Ladder of `if`...`elif`...`else` Statements\n",
    "\n",
    "- Python also provides an `elif` statement (short for \"else if\") to chain a series of conditional blocks. \n",
    "- The conditions are evaluated one by one from top to bottom. \n",
    "- For the first condition that evaluates to `True`, its associated block of statements is executed. \n",
    "- The remaining conditions and statements are not evaluated at all. \n",
    "- 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": null,
   "id": "cece0316",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "11c0c83b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your subject marks:  78\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "y = input(\"Enter your subject marks: \")\n",
    "\n",
    "# by default the type is string, so we need to convert the type first\n",
    "\n",
    "y = int(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "5b7deacb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Letter Grade B+\n"
     ]
    }
   ],
   "source": [
    "if  (y >= 85):\n",
    "    print(\"Letter Grade A\")\n",
    "\n",
    "elif((y >= 80) and (y<85)):\n",
    "    print(\"Letter Grade A-\")\n",
    "\n",
    "elif((y >= 77) and (y<80)):\n",
    "    print(\"Letter Grade B+\")\n",
    "\n",
    "elif((y >= 73) and (y<77)):\n",
    "    print(\"Letter Grade B\")\n",
    "\n",
    "else:\n",
    "    print(\"Bad Grade\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f8fb0d8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "476d5ee8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 is divisible by 3\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Remember in an if-elif ladder at most one block of statements is executed\n",
    "a_number = 15\n",
    "\n",
    "if (a_number % 2 == 0):\n",
    "    print('{} is divisible by 2'.format(a_number))\n",
    "\n",
    "elif a_number % 3 == 0:\n",
    "    print('{} is divisible by 3'.format(a_number))\n",
    "\n",
    "elif a_number % 5 == 0:\n",
    "    print('{} is divisible by 5'.format(a_number))\n",
    "\n",
    "elif a_number % 7 == 0:\n",
    "    print('{} is divisible by 7'.format(a_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a27f3521",
   "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`. \n",
    ">- 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.\n",
    ">- This is shown below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97bd9e5a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "835ccec2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c875074",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "834db89a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "6d11c2f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All checks failed!\n",
      "73 is not divisible by 2, 3 or 5\n"
     ]
    }
   ],
   "source": [
    "# Example : You can also include an `else` statement at the end of a chain of `if`, `elif`... statements. \n",
    "# This code within the `else` block is evaluated, when none of the conditions hold true.\n",
    "\n",
    "a_number = 73\n",
    "\n",
    "if a_number % 2 == 0:\n",
    "    print('{} is divisible by 2'.format(a_number))\n",
    "\n",
    "elif a_number % 3 == 0:\n",
    "    print('{} is divisible by 3'.format(a_number))\n",
    "\n",
    "elif a_number % 5 == 0:\n",
    "    print('{} is divisible by 5'.format(a_number))\n",
    "\n",
    "else:\n",
    "    print('All checks failed!')\n",
    "    print('{} is not divisible by 2, 3 or 5'.format(a_number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbbbfd87",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "106a9f37",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "10b0fbff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 12 is not divisible by 5\n"
     ]
    }
   ],
   "source": [
    "# Example : Conditions can also be combined using the logical operators `and`, `or` and `not`. \n",
    "a_number = 12\n",
    "\n",
    "if a_number % 3 == 0 and a_number % 5 == 0:\n",
    "    print(\"The number {} is divisible by 3 and 5\".format(a_number))\n",
    "\n",
    "elif not a_number % 5 == 0:\n",
    "    print(\"The number {} is not divisible by 5\".format(a_number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3046ad20",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db84f951",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5aa7fd27",
   "metadata": {},
   "source": [
    "## 3. The `pass` statement (Do nothing)\n",
    "The `pass` statement is generally used as a placeholder i.e. when the user does not know what code to write. So user simply places pass at that line. So user can simply place pass where empty code is not allowed, like in loops, function definitions, class definitions, or in if statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "21fb029f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The \"pass\" statement\n",
      "********************\n",
      "\n",
      "   pass_stmt ::= \"pass\"\n",
      "\n",
      "\"pass\" is a null operation — when it is executed, nothing happens. It\n",
      "is useful as a placeholder when a statement is required syntactically,\n",
      "but no code needs to be executed, for example:\n",
      "\n",
      "   def f(arg): pass    # a function that does nothing (yet)\n",
      "\n",
      "   class C: pass       # a class with no methods (yet)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('pass')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "3a631e5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I will place code when the condition is true, later :)\n"
     ]
    }
   ],
   "source": [
    "# A simple example of pass:\n",
    "x = 6\n",
    "\n",
    "if x < 0:\n",
    "    pass\n",
    "\n",
    "print(\"I will place code when the condition is true, later :)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "8c58ef44",
   "metadata": {},
   "outputs": [],
   "source": [
    "def func():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b11427b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bdf1f44",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "541aaafb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cd9bf0ba",
   "metadata": {},
   "source": [
    "<h1 align=\"center\" style=\"color:red\"> Loops </h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "399e15ac",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fa7840eb",
   "metadata": {},
   "source": [
    "## Learning agenda of this notebook\n",
    "There are scenarios in programming, where we need to repeat a set of instructions a specified number of times or until a condition is met. This is called iteration. A programming structure that implements iteration is called a loop. In programming there are two types of iteration:\n",
    "1. Indefinite Iteration, implemented using a `while` loop\n",
    "    - Basic `while` loop examples\n",
    "    - Use of `break`,  `continue` and `else` in `while` loop   \n",
    "    - Nested `while` loop <br><br>\n",
    "3. Definite Iteration, implemented using a `for` loop\n",
    "    - Iterables and Iterators\n",
    "    - Basic `for` loop examples\n",
    "    - The `range()` and `enumerate()` functions\n",
    "    - Use of `break`, `continue` and `else` in `for` loop\n",
    "    - Nested `for` loop <br><br>\n",
    "4. List Comprehension <br><br>\n",
    "5. Dictionary Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c63e3c8c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1eb695a0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "efe70ed5",
   "metadata": {},
   "source": [
    "<img align=\"right\" width=\"400\" height=\"300\"  src=\"images/while.png\" > \n",
    "\n",
    "## 1. The `while` Loop\n",
    "```\n",
    "initialize loop variable\n",
    "while (condition is true):\n",
    "    statement(s)\n",
    "    update loop variable\n",
    "statement(s)\n",
    "```\n",
    "- The indented block of code, often refered to as body of the loop will be executed repeatedly until the condition/expression evaluates to False.\n",
    "- The condition or controlling expression, typically involves on or more variables that are initialized prior to starting the loop and then modified somewhere in the loop body.\n",
    "- While loop is generally used, when we don't know the number of times to iterate beforehand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae577c15",
   "metadata": {},
   "outputs": [],
   "source": [
    "# "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "681def34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The \"while\" statement\n",
      "*********************\n",
      "\n",
      "The \"while\" statement is used for repeated execution as long as an\n",
      "expression is true:\n",
      "\n",
      "   while_stmt ::= \"while\" assignment_expression \":\" suite\n",
      "                  [\"else\" \":\" suite]\n",
      "\n",
      "This repeatedly tests the expression and, if it is true, executes the\n",
      "first suite; if the expression is false (which may be the first time\n",
      "it is tested) the suite of the \"else\" clause, if present, is executed\n",
      "and the loop terminates.\n",
      "\n",
      "A \"break\" statement executed in the first suite terminates the loop\n",
      "without executing the \"else\" clause’s suite.  A \"continue\" statement\n",
      "executed in the first suite skips the rest of the suite and goes back\n",
      "to testing the expression.\n",
      "\n",
      "Related help topics: break, continue, if, TRUTHVALUE\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('while')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "629f773e",
   "metadata": {},
   "source": [
    "### a. Basics of While Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "7d1a532b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "Bye-Bye\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Print numbers\n",
    "# initialize loop variable - check condition - update loop variable\n",
    "number = 2\n",
    "while number < 7:\n",
    "    print(number)\n",
    "    number = number + 1\n",
    "    \n",
    "\n",
    "print(\"Bye-Bye\")\n",
    "# 2, 3, 4, 5, 6, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83605395",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "634acfc8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0e45b01",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "champion-small",
   "metadata": {},
   "source": [
    "### Example: Program to print 1 to 10 using while loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "cheap-natural",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# initialize while loop variable\n",
    "i = 1\n",
    "# condition of while loop\n",
    "while i<=10:\n",
    "    print(i)\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "changed-cooperative",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "animated-dimension",
   "metadata": {},
   "source": [
    "### Example: Program to print table of given numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "partial-whale",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number :  8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 * 8 = 8\n",
      "2 * 8 = 16\n",
      "3 * 8 = 24\n",
      "4 * 8 = 32\n",
      "5 * 8 = 40\n",
      "6 * 8 = 48\n",
      "7 * 8 = 56\n",
      "8 * 8 = 64\n",
      "9 * 8 = 72\n",
      "10 * 8 = 80\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "# Take input from user using input() function\n",
    "number = int(input(\"Enter a number : \"))\n",
    "\n",
    "# initialize while loop variable\n",
    "i = 1\n",
    "\n",
    "#condition of while loop\n",
    "while i<=10:\n",
    "    print(f\"{i} * {number} = {i*number}\")\n",
    "    i += 1\n",
    "    \n",
    "print(\"Done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "chronic-justice",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "forward-share",
   "metadata": {},
   "source": [
    "## Example: Program to print sum of all the numbers in list12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "elegant-clause",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "\n",
      "\n",
      "6\n",
      "2\n",
      "\n",
      "\n",
      "11\n",
      "3\n",
      "\n",
      "\n",
      "17\n",
      "4\n",
      "\n",
      "\n",
      "24\n",
      "5\n",
      "\n",
      "\n",
      "32\n",
      "6\n",
      "\n",
      "\n",
      "41\n",
      "7\n",
      "\n",
      "\n",
      "41\n"
     ]
    }
   ],
   "source": [
    "list1 =  [2,4,5,6,7,8,9]\n",
    "\n",
    "i = 0\n",
    "Sum = 0\n",
    "\n",
    "while i < len(list1):\n",
    "    Sum = Sum + list1[i]\n",
    "    print(Sum)\n",
    "    i = i+1\n",
    "    print(i)\n",
    "    print(\"\\n\")\n",
    "print(Sum)\n",
    "\n",
    "# Try, it into Python Tutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "finnish-growth",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "41"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8032dfc7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "01b355c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter number:  100\n"
     ]
    }
   ],
   "source": [
    "# Example : Input number from user and compute the sum 1+2+3+4+....+n\n",
    "\n",
    "n = int(input(\"Enter number: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "edd4a13e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum is 5050\n"
     ]
    }
   ],
   "source": [
    "Sum = 0\n",
    "i = 1\n",
    "while (i <= n):\n",
    "    Sum = Sum + i\n",
    "    i = i+1   # update counter\n",
    "print(\"The sum is\", Sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e70e164f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "20b80627",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter count of fibonacci numbers you want to print:  5\n"
     ]
    }
   ],
   "source": [
    "# Example: Print Fibonacci series\n",
    "n = int(input(\"Enter count of fibonacci numbers you want to print: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "31b8e875",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Required Fibonacci series:  [0, 1, 1, 1, 2, 2]\n"
     ]
    }
   ],
   "source": [
    "i = 1  # loop variable \n",
    "\n",
    "if n<1:\n",
    "    fib = []       # In case user enter <0, the list is empty\n",
    "elif n==1:\n",
    "    fib = [0]      # If user enters 1, the list has the first fibonacci number\n",
    "elif n==2:\n",
    "    fib = [0, 1]   # If user enters 2, the list has the first two fibonacci numbers\n",
    "elif n > 2:\n",
    "    fib = [0, 1]   # if n>2, then we need to enter in while loop to compute the rest of the fibonacci numbers\n",
    "    while (i < n):\n",
    "        fib.append(fib[i-1] + fib[i-2])\n",
    "        i += 1\n",
    "print(\"Required Fibonacci series: \", fib)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38817caf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "unexpected-camera",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fib.append(fib[i-1] + fib[i-2])\n",
    "#Fn = Fn-1 + Fn-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ef674be",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "878b1038",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "532a3dcb",
   "metadata": {},
   "source": [
    "### b. Nested While Loops\n",
    "- A while loop can have other control structures such as `if` statements or other `while` loops nested under them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "bf5e0252",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 * 1 = 1\n",
      "1 * 2 = 2\n",
      "1 * 3 = 3\n",
      "1 * 4 = 4\n",
      "1 * 5 = 5\n",
      "1 * 6 = 6\n",
      "1 * 7 = 7\n",
      "1 * 8 = 8\n",
      "1 * 9 = 9\n",
      "1 * 10 = 10\n",
      "\n",
      "\n",
      "2 * 1 = 2\n",
      "2 * 2 = 4\n",
      "2 * 3 = 6\n",
      "2 * 4 = 8\n",
      "2 * 5 = 10\n",
      "2 * 6 = 12\n",
      "2 * 7 = 14\n",
      "2 * 8 = 16\n",
      "2 * 9 = 18\n",
      "2 * 10 = 20\n",
      "\n",
      "\n",
      "3 * 1 = 3\n",
      "3 * 2 = 6\n",
      "3 * 3 = 9\n",
      "3 * 4 = 12\n",
      "3 * 5 = 15\n",
      "3 * 6 = 18\n",
      "3 * 7 = 21\n",
      "3 * 8 = 24\n",
      "3 * 9 = 27\n",
      "3 * 10 = 30\n",
      "\n",
      "\n",
      "4 * 1 = 4\n",
      "4 * 2 = 8\n",
      "4 * 3 = 12\n",
      "4 * 4 = 16\n",
      "4 * 5 = 20\n",
      "4 * 6 = 24\n",
      "4 * 7 = 28\n",
      "4 * 8 = 32\n",
      "4 * 9 = 36\n",
      "4 * 10 = 40\n",
      "\n",
      "\n",
      "5 * 1 = 5\n",
      "5 * 2 = 10\n",
      "5 * 3 = 15\n",
      "5 * 4 = 20\n",
      "5 * 5 = 25\n",
      "5 * 6 = 30\n",
      "5 * 7 = 35\n",
      "5 * 8 = 40\n",
      "5 * 9 = 45\n",
      "5 * 10 = 50\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i<=5:\n",
    "    j = 1\n",
    "    while j<=10:\n",
    "        print(i,'*',j,'=',i*j)\n",
    "        j=j+1\n",
    "    print(\"\\n\")\n",
    "    i = i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb2b2887",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "406b22a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outer:  5\n",
      "\t Inner:  Ali\n",
      "\t Inner:  Ehtisham\n",
      "Outer:  4\n",
      "\t Inner:  Ali\n",
      "\t Inner:  Ehtisham\n",
      "Outer:  3\n",
      "\t Inner:  Ali\n",
      "\t Inner:  Ehtisham\n",
      "Outer:  2\n",
      "\t Inner:  Ali\n",
      "\t Inner:  Ehtisham\n",
      "Outer:  1\n",
      "\t Inner:  Ali\n",
      "\t Inner:  Ehtisham\n",
      "After both the loops end\n",
      "a=  []\n",
      "b=  []\n"
     ]
    }
   ],
   "source": [
    "# Example 1: A while loop nested inside another while loop\n",
    "# Note the inner while loop works on a list that is declared again and again inside the outer loop\n",
    "a = [1,2,3,4,5]\n",
    "while (a):\n",
    "    print(\"Outer: \", a.pop())\n",
    "    b = ['Ehtisham', 'Ali']\n",
    "    while (b):\n",
    "        print(\"\\t Inner: \", b.pop())\n",
    "\n",
    "print(\"After both the loops end\")\n",
    "print(\"a= \", a)\n",
    "print(\"b= \", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a974d8aa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "733d6719",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8eb739a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2e74edb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d0607bb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "566a05d1",
   "metadata": {},
   "source": [
    "## 2. Jump Statements in Python (`break` and `continue`)\n",
    "\n",
    "<img align=\"left\" width=\"300\" height=\"300\"  src=\"images/break.png\" > \n",
    "\n",
    "<img align=\"right\" width=\"300\" height=\"300\"  src=\"images/continue.png\" > \n",
    "\n",
    "In the above examples, we have seen that the entire body of the while loop is executed on each iteration. Python provides two keywords that terminate a loop iteration prematurely:\n",
    "- Python **`break`** statement immediately terminates a loop entirely. Program execution proceeds to the first statement after the loop body.<br><br>\n",
    "- Python **`continue`** statement immediately terminates the current loop iteration. Program execution jumps to the top of the loop, and the loop condition is re-evaluated to determine whether the loop will execute again or terminate\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73c2c76b",
   "metadata": {},
   "source": [
    "### a. Infinite loop and break statement: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4fe24e36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The \"break\" statement\n",
      "*********************\n",
      "\n",
      "   break_stmt ::= \"break\"\n",
      "\n",
      "\"break\" may only occur syntactically nested in a \"for\" or \"while\"\n",
      "loop, but not nested in a function or class definition within that\n",
      "loop.\n",
      "\n",
      "It terminates the nearest enclosing loop, skipping the optional \"else\"\n",
      "clause if the loop has one.\n",
      "\n",
      "If a \"for\" loop is terminated by \"break\", the loop control target\n",
      "keeps its current value.\n",
      "\n",
      "When \"break\" passes control out of a \"try\" statement with a \"finally\"\n",
      "clause, that \"finally\" clause is executed before really leaving the\n",
      "loop.\n",
      "\n",
      "Related help topics: while, for\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('break')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f4957e8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  2  3  4  5  6  7  8  9  \n",
      "Outside loop\n"
     ]
    }
   ],
   "source": [
    "#Example 1: Breaking an infinite while loop on a certain condition\n",
    "n = 0\n",
    "while (True):\n",
    "    n = n + 1\n",
    "    if (n == 10):\n",
    "        break\n",
    "    print(n, end=\"  \")\n",
    "    \n",
    "    \n",
    "print(\"\\nOutside loop\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de092cb7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "27079c95",
   "metadata": {},
   "source": [
    "### b. The `continue` statement: \n",
    "- Python **continue** statement immediately terminates the current loop iteration. Program execution jumps to the top of the loop, and the loop condition is re-evaluated to determine whether the loop will execute again or terminate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3dbe280d",
   "metadata": {},
   "outputs": [],
   "source": [
    "help('continue')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7fe06b75",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "8\n",
      "6\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "#Example 1: Use of continue\n",
    "n = 10\n",
    "while n > 0:\n",
    "    n = n - 1\n",
    "    if (n == 5 or n == 7):\n",
    "        continue\n",
    "    print(n)\n",
    "    \n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a68692a6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "414415b3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e35ee7fa",
   "metadata": {},
   "source": [
    "### c. The `while` loop with `else` statement: \n",
    "- On normal termination of loop, i.e., when the loop condition becomes False, the `else` clause will execute. \n",
    "- However, if the loop is terminated prematurely by either a break or return statement, the `else` clause won’t execute at all."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "454fd344",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "1\n",
      "0\n",
      "Loop is finished\n",
      "outside loop\n"
     ]
    }
   ],
   "source": [
    "# Example: The `else` block will execute only when the loop condition becomes false\n",
    "\n",
    "n = 5\n",
    "while n > 0:\n",
    "    n = n - 1\n",
    "    if (n==2):\n",
    "        continue\n",
    "        # break\n",
    "    print(n)\n",
    "else:\n",
    "    print(\"Loop is finished\")\n",
    "    \n",
    "    \n",
    "print(\"outside loop\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c91bacff",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "34c87a59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n",
      "Loop is finished\n",
      "outside loop\n"
     ]
    }
   ],
   "source": [
    "# Example: The `else` block will execute only when the loop condition becomes false\n",
    "n = 5\n",
    "while n > 0:\n",
    "    n = n - 1\n",
    "    print(n)\n",
    "else:\n",
    "    print(\"Loop is finished\")\n",
    "print(\"outside loop\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c30a79e8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e0aa81c0",
   "metadata": {},
   "source": [
    "<img align=\"right\" width=\"300\" height=\"300\"  src=\"images/for.png\" > \n",
    "\n",
    "## 3. The `for` Loop\n",
    "- We use `for` loop when we want to run a block of code for known set of items in an iterable.\n",
    "- In the context of most data science work, Python `for` loops are used to loop through an iterable object (like a list, tuple, set, dictionary) and perform the same action for each entry. \n",
    "- For example, a for loop would allow us to iterate through a list, performing the same action on each item in the list.\n",
    "```\n",
    "for variable in <iterable>:\n",
    "    <statement(s)>\n",
    "```\n",
    "- Before we see a basic example of a Python `for` loop, let us first understand the concept of **Iterables** and **Iterators**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dbe1e2e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf0c730d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "702a0369",
   "metadata": {},
   "source": [
    "### a. Iterables and Iterators\n",
    "- An `Iterable` in Python is an object that is capable of returning its members one at a time, and therefore, can be used in an iteration. Lists, Tuples, Sets and Dictionaries are iterables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bb80e250",
   "metadata": {},
   "outputs": [],
   "source": [
    "# iter(), next()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd6bcfbc",
   "metadata": {},
   "source": [
    "### b. Basic For Loop Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4a7feeee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ehtisham\n",
      "Ali\n",
      "Ayesha\n",
      "Adeen\n",
      "Dua\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "# Example 1\n",
    "mylist = ['Ehtisham', 'Ali', 'Ayesha', 'Adeen' ,'Dua']\n",
    "\n",
    "for i in mylist:\n",
    "    print(i)\n",
    "    \n",
    "print(\"Done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02d986f3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "24f52411",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B e   H a p p y "
     ]
    }
   ],
   "source": [
    "\n",
    "# Example 2: Loop through the letters in a string\n",
    "string = \"Be Happy\"\n",
    "for i in string:\n",
    "    print(i , end= \" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbfba52a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8cef87e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ehtisham\n",
      "Ali\n",
      "Ayesha\n",
      "Dua\n",
      "Adeen\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Iterate a tuple using for loop\n",
    "friends = ('Ehtisham', 'Ali', 'Ayesha', 'Dua', 'Adeen')\n",
    "\n",
    "for friend in friends:\n",
    "    print(friend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "098e9361",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1c882526",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# Example 4: Iterate a string using for loop and count the count of a specific character\n",
    "word = \"Learning Practical Data Science and Machine Learning\"\n",
    "\n",
    "count = 0\n",
    "for character in word:\n",
    "    if character == 'c':\n",
    "        count = count+1\n",
    "        \n",
    "print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c3bcad1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e3a1de2d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Name': 'Ehtisham',\n",
       " 'Gender': 'Male',\n",
       " 'Age': 22,\n",
       " 'Height': 5.7,\n",
       " 'Occupation': 'ML Engineer'}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 5:  Iterating through a dictionary keys\n",
    "d1 = {\n",
    "    'Name': 'Ehtisham', \n",
    "    'Gender': 'Male', \n",
    "    'Age': 22, \n",
    "    'Height': 5.7, \n",
    "    'Occupation': 'ML Engineer'\n",
    "}\n",
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "92e4d719",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iterating through dictionary keys:\n",
      "Name\n",
      "Gender\n",
      "Age\n",
      "Height\n",
      "Occupation\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Iterating through dictionary keys:\")\n",
    "\n",
    "for i in d1:\n",
    "    print(i)\n",
    "print(\"\\n\\n\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60f33367",
   "metadata": {},
   "outputs": [],
   "source": [
    "d1.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "17cf8bc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Another way of iterating through dictionary keys:\n",
      "Name\n",
      "Gender\n",
      "Age\n",
      "Height\n",
      "Occupation\n"
     ]
    }
   ],
   "source": [
    "print(\"Another way of iterating through dictionary keys:\")\n",
    "for i in d1.keys():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "afdbfab8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Another way of iterating through dictionary values:\n",
      "Ehtisham\n",
      "Male\n",
      "22\n",
      "5.7\n",
      "ML Engineer\n"
     ]
    }
   ],
   "source": [
    "print(\"Another way of iterating through dictionary values:\")\n",
    "for i in d1.values():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "690b5910",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7613efba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Iterating through a dictionary key:value pairs:\n",
      "\n",
      "('Name', 'Ehtisham')\n",
      "('Gender', 'Male')\n",
      "('Age', 22)\n",
      "('Height', 5.7)\n",
      "('Occupation', 'ML Engineer')\n"
     ]
    }
   ],
   "source": [
    "# Example 7: Iterating through the key-value pairs\n",
    "d1 = {\n",
    "    'Name': 'Ehtisham', \n",
    "    'Gender': 'Male', \n",
    "    'Age': 22, \n",
    "    'Height': 5.7, \n",
    "    'Occupation': 'ML Engineer'\n",
    "}\n",
    "\n",
    "\n",
    "print(\"\\nIterating through a dictionary key:value pairs:\\n\")\n",
    "for i in d1.items():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "959ce9e8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bfea8b4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fabae812",
   "metadata": {},
   "source": [
    "#### The `pass` statement in a `for` loop\n",
    "- The `pass` statement is generally used as a placeholder i.e. when the user does not know what code to write. \n",
    "- So user can simply write `pass` statement, where empty code is not allowed, like in loops, function definitions, class definitions, or in if statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8cfc949",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6a4716ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The \"pass\" statement\n",
      "********************\n",
      "\n",
      "   pass_stmt ::= \"pass\"\n",
      "\n",
      "\"pass\" is a null operation — when it is executed, nothing happens. It\n",
      "is useful as a placeholder when a statement is required syntactically,\n",
      "but no code needs to be executed, for example:\n",
      "\n",
      "   def f(arg): pass    # a function that does nothing (yet)\n",
      "\n",
      "   class C: pass       # a class with no methods (yet)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('pass')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "55bdd06b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ehtisham\n",
      "ayesha\n",
      "dua\n"
     ]
    }
   ],
   "source": [
    "# Print all elements of list ignoring string \"ali\"\n",
    "list1 =['Ehtisham', 'ali', 'ayesha', 'dua']\n",
    " \n",
    "for i in list1:\n",
    "    if(i =='ali'):\n",
    "        pass    # do nothing \n",
    "    else:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a76272a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ac1cd03d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thisisgreatstuff"
     ]
    }
   ],
   "source": [
    "# Print the string ignoring spaces\n",
    "str1 = \"This is great stuff\"\n",
    "for i in str1:\n",
    "    if(i ==' '):\n",
    "        pass\n",
    "    else:\n",
    "        print(i, end=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3114260d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8376572",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3deb901c",
   "metadata": {},
   "source": [
    "### c. Using `range()` Function in `for` Loops\n",
    "- The `range()` method is used to create a range object, containing sequence of numbers that can be iterated over using a `for` loop.\n",
    "- It can be used in 3 ways:\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 increment/decrement of `step`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca3c3f02",
   "metadata": {},
   "outputs": [],
   "source": [
    "# range(), np.arange(), np.linspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cd4c09ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# help(range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "870b49ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(range(0, 10), range)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Example 1: \n",
    "a = range(10) \n",
    "a, type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f97877ee-e16c-4991-8b9b-30cc4be15933",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# type caste a into list\n",
    "list(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f4393c38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "2cde61b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#Example 2:\n",
    "# a = range(3, 10) \n",
    "for i in range(3, 10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6425ef11",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "7\n",
      "11\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "#Example 3: \n",
    "a = range(3, 16, 4) \n",
    "for i in a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e02c76c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "2cb6749c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value at position 0 is Ehtisham.\n",
      "The value at position 1 is Ali.\n",
      "The value at position 2 is Ayesha.\n",
      "The value at position 3 is Dua.\n",
      "The value at position 4 is Adeen.\n",
      "The value at position 5 is Khubaib.\n"
     ]
    }
   ],
   "source": [
    "# Example 4: Used to iterate over Lists, when you need to track the index of elements while iterating.\n",
    "myfamily = ['Ehtisham','Ali', 'Ayesha', 'Dua', 'Adeen', 'Khubaib']\n",
    "\n",
    "\n",
    "for i in range(len(myfamily)):  # Remember the len() function returns 6 in this scenario\n",
    "    print('The value at position {} is {}.'.format(i, myfamily[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d867e50",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e999b0d7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b094a17d",
   "metadata": {},
   "source": [
    "### d. Using  `enumerate()` Function in `for` Loops\n",
    "- The `enumerate()` method is passed an iterable object and returns an enumerate object containing tuples, each tuple having two values:\n",
    "```\n",
    "(index, data_at_that_index_in_the_iterable)\n",
    "```\n",
    "- It is is useful for obtaining an indexed list:\n",
    "```\n",
    "       (0, seq[0]), (1, seq[1]), (2, seq[2]), ...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "swedish-bradford",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'Ehtisham')\n",
      "(1, 'Ali')\n",
      "(2, 'Ayesha')\n",
      "(3, 'Dua')\n",
      "(4, 'Adeen')\n",
      "(5, 'Khubaib')\n"
     ]
    }
   ],
   "source": [
    "myfamily = ['Ehtisham', 'Ali', 'Ayesha', 'Dua', 'Adeen', 'Khubaib']\n",
    "\n",
    "for value in enumerate(myfamily): \n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d8043e82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value at position 0 is Ehtisham.\n",
      "The value at position 1 is Ali.\n",
      "The value at position 2 is Ayesha.\n",
      "The value at position 3 is Dua.\n",
      "The value at position 4 is Adeen.\n",
      "The value at position 5 is Khubaib.\n"
     ]
    }
   ],
   "source": [
    "myfamily = ['Ehtisham', 'Ali', 'Ayesha', 'Dua', 'Adeen', 'Khubaib']\n",
    "\n",
    "for i, name in enumerate(myfamily): \n",
    "    print('The value at position {} is {}.'.format(i, myfamily[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad16f679",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "96fb967a",
   "metadata": {},
   "source": [
    "### d. Use of `break` and `continue` statement inside a `for` loop\n",
    "- Python **break** statement immediately terminates a loop entirely. Program execution proceeds to the first statement after the loop body.\n",
    "- Python **continue** statement immediately terminates the current loop iteration. Program execution jumps to the top of the loop, and the loop condition is re-evaluated to determine whether the loop will execute again or terminate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "0673d9d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Break the loop when it reaches the element \"cherry\"\n",
    "fruits = [\"apple\", \"banana\", \"cherry\", \"guava\"]\n",
    "for x in fruits:\n",
    "    if x == \"cherry\":\n",
    "        break\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "56645937",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "cherry\n",
      "guava\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Do not print banana from the list\n",
    "fruits = [\"apple\", \"banana\", \"cherry\", \"guava\"]\n",
    "for x in fruits:\n",
    "    if x == \"banana\":\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dbbd8ad",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f71aa58",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "78392ef5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ehtisham': 90,\n",
       " 'ali': 95,\n",
       " 'ayesha': 81,\n",
       " 'dua': 77,\n",
       " 'adeen': 86,\n",
       " 'khubaib': 100}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 4: A for loop with else and break\n",
    "mydict = {\n",
    "          'ehtisham':90, \n",
    "          'ali':95, \n",
    "          'ayesha':81, \n",
    "          'dua':77, \n",
    "          'adeen':86, \n",
    "          'khubaib':100\n",
    "        }\n",
    "\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "97e5a89a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "95"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict['ali']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "384fb778",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "enter name:  ahmad\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No entry with that name found.\n",
      "Outside loop\n"
     ]
    }
   ],
   "source": [
    "student_name = input('enter name: ')\n",
    "\n",
    "for name in mydict.keys():\n",
    "    if name == student_name:\n",
    "        print(mydict[name])\n",
    "        break\n",
    "else:\n",
    "    print('No entry with that name found.')\n",
    "    \n",
    "print(\"Outside loop\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1886a87",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "eb71393a",
   "metadata": {},
   "source": [
    "### e. Nested for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "cf9b091b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outer:  1\n",
      "\t Inner:  Ehtisham\n",
      "\t Inner:  Ali\n",
      "Outer:  2\n",
      "\t Inner:  Ehtisham\n",
      "\t Inner:  Ali\n",
      "Outer:  3\n",
      "\t Inner:  Ehtisham\n",
      "\t Inner:  Ali\n",
      "Outer:  4\n",
      "\t Inner:  Ehtisham\n",
      "\t Inner:  Ali\n",
      "Outside loops\n"
     ]
    }
   ],
   "source": [
    "# Example: A for loop nested inside another for loop\n",
    "# Note the inner for loop works on a list that is declared again and again inside the outer loop\n",
    "list1 = [1,2,3,4]\n",
    "\n",
    "for numb in list1:\n",
    "    print(\"Outer: \", numb)\n",
    "    list2 = ['Ehtisham', 'Ali']\n",
    "    \n",
    "    for name in list2:\n",
    "        print(\"\\t Inner: \", name)\n",
    "\n",
    "print(\"Outside loops\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "a255cd2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Monday apple\n",
      "Monday banana\n",
      "Monday guava\n",
      "Tuesday apple\n",
      "Tuesday banana\n",
      "Tuesday guava\n",
      "Wednesday apple\n",
      "Wednesday banana\n",
      "Wednesday guava\n"
     ]
    }
   ],
   "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": "code",
   "execution_count": null,
   "id": "d051df7e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf69b52d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "27e28f73",
   "metadata": {},
   "source": [
    "## 4. List Comprehension\n",
    "- In Python comprehension is a concise way to create a new sequence based on the values of an existing sequence (which can be a list, dictionary, set or a generator)\n",
    "- Let us understand List comprehension step by step with examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9c3ba8c",
   "metadata": {},
   "source": [
    "**Example 1:** Suppose we have an oldlist containing some random numbers. We want to create a new list that contains square of the numbers of the oldlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "20138c16",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[25, 9, 36, 4]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oldlist = [5, 3, 6, 2]\n",
    "\n",
    "newlist = []\n",
    "\n",
    "for i in oldlist:\n",
    "    newlist.append(i**2)\n",
    "newlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b0f7064",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "28b4708e",
   "metadata": {},
   "source": [
    "**You can perform above task in single line using List Comprehension**\n",
    "\n",
    "```newlist = [expression for item in iterable]```\n",
    "\n",
    "Where,\n",
    "- `expression` is the member itself, a call to a method, or any other valid expression that returns a value. \n",
    "- `item` is the object or value in the list or iterable.\n",
    "- `iterable` is a list, set, sequence, generator, or any other object that can return its elements one at a time.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "f24e5a17",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[25, 9, 36, 4]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oldlist = [5, 3, 6, 2]\n",
    "\n",
    "newlist = [i**2 for i in oldlist]\n",
    "newlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ce952f2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f9c4e549",
   "metadata": {},
   "source": [
    "**Example 2:** Given a list, create a new list that should contain the even numbers in the given list using List Comprehension\n",
    "\n",
    "```newlist = [expression for item in iterable if (condition == True)]```\n",
    "\n",
    "A list comprehension in Python can have four elements:\n",
    "- `expression` is the member itself, a call to a method, or any other valid expression that returns a value. \n",
    "- `item` is the object or value in the list or iterable.\n",
    "- `iterable` is a list, set, sequence, generator, or any other object that can return its elements one at a time.\n",
    "- `if (condition==True)` The item will be placed in the newlist only if the condition evaluates to True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "33343586",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12, 88, 20, 32]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1, 9, 12, 88, 65, 7, 20, 55, 47, 32]\n",
    "\n",
    "new = []\n",
    "\n",
    "for i in list1:\n",
    "    if  i%2==0:\n",
    "        new.append(i)\n",
    "new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "72f27033",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12, 88, 20, 32]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i for i in list1 if i%2==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35ab73b3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "930f03a8",
   "metadata": {},
   "source": [
    "**Example 3:** Suppose we want to create a `newlist` from an existing list of `fruits` such that the new list should contain only those fruits having alphabet **`a`** in their name\n",
    "```newlist = [expression for item in iterable if (condition == True)]```\n",
    "\n",
    "A list comprehension in Python can have four elements:\n",
    "- `expression` is the member itself, a call to a method, or any other valid expression that returns a value. \n",
    "- `item` is the object or value in the list or iterable.\n",
    "- `iterable` is a list, set, sequence, generator, or any other object that can return its elements one at a time.\n",
    "- `if (condition)` The item will be placed in the newlist only if the condition evaluates to true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "944e9c5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'mango']"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"kiwi\", \"mango\"]\n",
    "\n",
    "new2 = []\n",
    "\n",
    "for i in fruits:\n",
    "    if 'a' in i:\n",
    "        new2.append(i)\n",
    "new2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "01a35fc6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'mango']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new3 = [i for i in fruits if 'a' in i]\n",
    "new3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8355fee7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ceabce7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7072faa2",
   "metadata": {},
   "source": [
    "## 4. Dictionary Comprehension\n",
    "- Dictionary comprehension is a concise way to create a new dictionary based on the values of an existing list or dictionary.\n",
    "\n",
    "- Let us understand Dictionary comprehension step by step with examples:\n",
    "```\n",
    "newdict = {key:value for var in iterable if (condition == True)}\n",
    "```\n",
    "- Note for list comprehension we use `[  ]`, while for dictionary comprehension we use `{  }` "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa6e53dd",
   "metadata": {},
   "source": [
    "**Example 1:** Suppose we have a list containing some random numbers. We want to create a dictionary having keys of that list and values as cubes of the list values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "e2c12c94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 8, 3: 27, 4: 64, 5: 125}\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3, 4, 5]\n",
    "\n",
    "dict1 = {}\n",
    "\n",
    "for i in list1:\n",
    "    dict1[i] = i**3\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "1a06df1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 8, 3: 27, 4: 64, 5: 125, 6: 216}\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3, 4, 5,6]\n",
    "\n",
    "dict1 = {key: key**3 for key in list1}\n",
    "\n",
    "print (dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38b8ea13",
   "metadata": {},
   "source": [
    "**Example 2:** Suppose we have a list containing numbers from 1 to 10. We want to create a dictionary having dictionary keys as the values of that list and dictionary values as cubes of the values in the list. However, the dictionary should contain only those key:value pairs, where the dictionary values are divisible by 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "f2b35cec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 2: 8, 4: 64, 6: 216, 8: 512, 10: 1000}"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2 = range(11)\n",
    "\n",
    "dict2 = {}\n",
    "\n",
    "for i in list2:\n",
    "    if i**3%4==0:\n",
    "        dict2[i] = i**3\n",
    "dict2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d5daeb6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4268aaf9",
   "metadata": {},
   "source": [
    "**Example 3:** Suppose we have a dictionary containing some grossary items and their prices. \n",
    "```\n",
    "dict1 = {'milk': 120.0, 'choclate': 45.0, 'bread': 80.0}\n",
    "```\n",
    "Use dictionary comprehension to create a new dictionary with increased prices by 25%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "5d91b2b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'milk': 150.0, 'choclate': 56.25, 'bread': 100.0}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "dict1 = {'milk': 120.0, 'choclate': 45.0, 'bread': 80.0}\n",
    "increase = 1.25\n",
    "\n",
    "dict2 = {key: value*increase for (key, value) in dict1.items()}\n",
    "\n",
    "print(dict2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "703b294b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "65a2430f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The \"pass\" statement\n",
      "********************\n",
      "\n",
      "   pass_stmt ::= \"pass\"\n",
      "\n",
      "\"pass\" is a null operation — when it is executed, nothing happens. It\n",
      "is useful as a placeholder when a statement is required syntactically,\n",
      "but no code needs to be executed, for example:\n",
      "\n",
      "   def f(arg): pass    # a function that does nothing (yet)\n",
      "\n",
      "   class C: pass       # a class with no methods (yet)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help('pass')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcdb0f45",
   "metadata": {},
   "source": [
    "## Check your Concepts\n",
    "\n",
    "Try answering the following questions to test your understanding of the topics covered in this notebook:\n",
    "\n",
    "1. What is iteration or looping in programming languages? Why is it useful?\n",
    "2. What are the two ways for performing iteration in Python?\n",
    "3. What is the purpose of the `while` statement in Python?\n",
    "4. What is the syntax of the `while` statement in Python? Give an example.\n",
    "5. Write a program to compute the sum of the numbers 1 to 100 using a while loop. \n",
    "6. Repeat the above program for numbers up to 1000, 10000, and 100000. How long does it take each loop to complete?\n",
    "7. What is an infinite loop?\n",
    "8. What causes a program to enter an infinite loop?\n",
    "9. How do you interrupt an infinite loop within Jupyter?\n",
    "10. What is the purpose of the `break` statement in Python? \n",
    "11. Give an example of using a `break` statement within a while loop.\n",
    "12. What is the purpose of the `continue` statement in Python?\n",
    "13. Give an example of using the `continue` statement within a while loop.\n",
    "15. What is the purpose of the `for` statement in Python?\n",
    "16. What is the syntax of `for` loops? Give an example.\n",
    "17. How are for loops and while loops different?\n",
    "18. How do you loop over a string? Give an example.\n",
    "19. How do you loop over a list? Give an example.\n",
    "20. How do you loop over a tuple? Give an example.\n",
    "21. How do you loop over a dictionary? Give an example.\n",
    "22. What is the purpose of the `range` statement? Give an example.\n",
    "23. What is the purpose of the `enumerate` statement? Give an example.\n",
    "24. How are the `break`, `continue`, and `pass` statements used in for loops? Give examples.\n",
    "25. Can loops be nested within other loops? How is nesting useful?\n",
    "26. Give an example of a for loop nested within another for loop.\n",
    "27. Give an example of a while loop nested within another while loop.\n",
    "28. Give an example of a for loop nested within a while loop.\n",
    "29. Give an example of a while loop nested within a for loop."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "471fd837-8389-4d67-9fd9-2330c1c3536c",
   "metadata": {},
   "source": [
    "## Check your Concepts\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. Python does not have a switch or case statement. To get around this fact, one can use dictionary mapping. Try to implement code for this task.\n",
    "35. Write an if statement that assigns 0 to x if y is equal to 20.\n",
    "36. Write an if statement that assigns 0.2 to commissionRate if sales is greater thanor equal to 10000.\n",
    "37.  Write an if statement that assigns 20 to the variable y and assigns 40 to the variable z if the variable x is greater than 100.\n",
    "38. How do you test that a string userInput is the empty string?\n",
    "39. Suppose x and y are variables, each of which contains a number. Write a code frag\u0002ment that sets y to x if x is positive and to 0 otherwise. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6be7fb2a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7670e6d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afd64145-5f57-498d-bfb7-55c47ef2232e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44e19f72-9dfa-4dec-9fe4-e1bcd684c401",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1804eb0a-59c1-4de3-b682-01946785c095",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2df2cb1-b161-431f-a237-d430636e2fdd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "af6706e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <style>\n",
       "        body {\n",
       "            background-color: #f2fff2;\n",
       "        }\n",
       "        h1 {\n",
       "            text-align: center;\n",
       "            font-weight: bold;\n",
       "            font-size: 36px;\n",
       "            color: #4295F4;\n",
       "            text-decoration: underline;\n",
       "            padding-top: 15px;\n",
       "        }\n",
       "        \n",
       "        h2 {\n",
       "            text-align: left;\n",
       "            font-weight: bold;\n",
       "            font-size: 30px;\n",
       "            color: #4A000A;\n",
       "            text-decoration: underline;\n",
       "            padding-top: 10px;\n",
       "        }\n",
       "        \n",
       "        h3 {\n",
       "            text-align: left;\n",
       "            font-weight: bold;\n",
       "            font-size: 30px;\n",
       "            color: #f0081e;\n",
       "            text-decoration: underline;\n",
       "            padding-top: 5px;\n",
       "        }\n",
       "\n",
       "        \n",
       "        p {\n",
       "            text-align: center;\n",
       "            font-size: 12 px;\n",
       "            color: #0B9923;\n",
       "        }\n",
       "    </style>\n",
       "\n",
       "<h1>Hello</h1>\n",
       "<p>Hello World</p>\n",
       "<h2> Hello</h2>\n",
       "<h3> World </h3>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "\n",
    "style = \"\"\"\n",
    "    <style>\n",
    "        body {\n",
    "            background-color: #f2fff2;\n",
    "        }\n",
    "        h1 {\n",
    "            text-align: center;\n",
    "            font-weight: bold;\n",
    "            font-size: 36px;\n",
    "            color: #4295F4;\n",
    "            text-decoration: underline;\n",
    "            padding-top: 15px;\n",
    "        }\n",
    "        \n",
    "        h2 {\n",
    "            text-align: left;\n",
    "            font-weight: bold;\n",
    "            font-size: 30px;\n",
    "            color: #4A000A;\n",
    "            text-decoration: underline;\n",
    "            padding-top: 10px;\n",
    "        }\n",
    "        \n",
    "        h3 {\n",
    "            text-align: left;\n",
    "            font-weight: bold;\n",
    "            font-size: 30px;\n",
    "            color: #f0081e;\n",
    "            text-decoration: underline;\n",
    "            padding-top: 5px;\n",
    "        }\n",
    "\n",
    "        \n",
    "        p {\n",
    "            text-align: center;\n",
    "            font-size: 12 px;\n",
    "            color: #0B9923;\n",
    "        }\n",
    "    </style>\n",
    "\"\"\"\n",
    "\n",
    "html_content = \"\"\"\n",
    "<h1>Hello</h1>\n",
    "<p>Hello World</p>\n",
    "<h2> Hello</h2>\n",
    "<h3> World </h3>\n",
    "\"\"\"\n",
    "\n",
    "HTML(style + html_content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e243547-7ed5-41c6-ae5e-b8988865d488",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}