PyLecture11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Data Type & Built-in Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(bool, int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = True          # Data Type "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "b2 = bool(False)   # Built-in Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(False, bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Keywords "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "True, False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(keyword.iskeyword('True'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(keyword.iskeyword('False'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Logical Operators as Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import and_, or_, not_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "operator.and_(1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "operator.and_(5, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "operator.or_(1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "operator.or_(5, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "operator.not_(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "operator.not_(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "operator.not_(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "not, and, or"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Boolean NOT</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It returns the opposite of the following statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not 'xyz'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Boolean AND</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluates to the second argument if and only if both of the arguments are truthy. Otherwise evaluates to the first falsey argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False False False True\n"
     ]
    }
   ],
   "source": [
    "print(False and False, False and True, True and False, True and True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0 1\n"
     ]
    }
   ],
   "source": [
    "print(0 and 0, 0 and 1, 1 and 0, 1 and 1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None [] 0 Python\n"
     ]
    }
   ],
   "source": [
    "print(None and False, [] and 5, 'xyz' and 0, 'python' and 'Python') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc' and ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3.141"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.14 < x < 3.142"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.14 < x and x < 3.142"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is near pi\n"
     ]
    }
   ],
   "source": [
    "if 3.14 < x < 3.142:\n",
    "    print(\"x is near pi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you use <code>and</code>, it will return its first value if it's false, else it returns the last value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def and_(a, b):\n",
    "    if not a:\n",
    "        return a\n",
    "    else:\n",
    "        return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "and_(5, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "and_(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "and_(10, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Boolean OR</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluates to the first truthy argument if either one of the arguments is truthy. If both arguments are falsey, evaluates to the second argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False True True True\n"
     ]
    }
   ],
   "source": [
    "print(False or False, False or True, True or False, True or True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 1\n"
     ]
    }
   ],
   "source": [
    "print(0 or 0, 0 or 1, 1 or 0, 1 or 1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False 5 xyz python\n"
     ]
    }
   ],
   "source": [
    "print(None or False, [] or 5, 'xyz' or 0, 'python' or 'Python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'xyz'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'xyz' or ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you use <code>or</code>, it will either return the first value in the expression if it's true, else it will blindly return the second value. I.e. or is equivalent to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def or_(a, b):\n",
    "    if a:\n",
    "        return a\n",
    "    else:\n",
    "        return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "or_(5, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "or_(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "or_(10, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Short-circuit Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def true_func():\n",
    "    print('true_func')\n",
    "    return True "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def false_func():\n",
    "    print('false_func')\n",
    "    return False "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true_func\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "true_func() or false_func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false_func\n",
      "true_func\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "false_func() or true_func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true_func\n",
      "false_func\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "true_func() and false_func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false_func\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "false_func() and false_func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean Operations "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following values are considered falsey, in that they evaluate to <code>False</code> when applied to a boolean operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- <code>None</code>\n",
    "- <code>False</code>\n",
    "- 0, or any numerical value equivalent to zero, for example 0.0, 0j\n",
    "- Empty sequences: '', \"\", (), []\n",
    "- Empty mappings: {}\n",
    "- User-defined functions where the return 0 or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All other values in Python evaluate to <code>True</code>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Boolean Logic Expressions</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n"
     ]
    }
   ],
   "source": [
    "if a and b > 2:\n",
    "    print('yes')\n",
    "else:\n",
    "    print('no')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no\n"
     ]
    }
   ],
   "source": [
    "if a > 2 and b > 2:\n",
    "    print('yes')\n",
    "else:\n",
    "    print('no')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "if a == 3 or 4 or 6:\n",
    "    print('yes')\n",
    "else:\n",
    "    print('no')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no\n"
     ]
    }
   ],
   "source": [
    "if a == 3 or a == 4 or a == 6:\n",
    "    print('yes')\n",
    "else:\n",
    "    print('no')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is true!\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print(\"It is true!\")\n",
    "else:\n",
    "    print(\"This won't get printed..\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I know math!\n"
     ]
    }
   ],
   "source": [
    "if 2 + 2 == 4:\n",
    "    print(\"I know math!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_me():\n",
    "    print('I am here!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 and print_me()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am here!\n"
     ]
    }
   ],
   "source": [
    "1 and print_me()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Loops / Iteration Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Loops</b> are used in programming to repeat a specific block of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As one of the most basic functions in programming, loops are an important piece to nearly every programming language. Loops enable developers to set certain portions of their code to repeat through a number of loops which are referred to as iterations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Iteration</b> means executing the same block of code over and over, potentially many times. A programming structure that implements iteration is called a <b>loop</b>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repetitive execution of the same block of code over and over is referred to as <b>iteration</b>.\n",
    "\n",
    "There are two types of iteration:\n",
    "- <b>Definite Iteration</b>, the number of times the designated block will be executed is specified explicitly at the time the loop starts.\n",
    "- <b>Indefinite Iteration</b>, the number of times the loop is executed isn’t specified explicitly in advance. Rather, the designated block is executed repeatedly as long as some condition is met."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The <code>while</code> statement\n",
    "    - pass, break, continue, else\n",
    "- The <code>for</code> statement\n",
    "    - pass, break, continue, else\n",
    "    - The <code>range()</code> function \n",
    "- Nested Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python <code>while</code> Loop "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python <code>while</code> Loop Syntax:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    while <test_expr>:\n",
    "        <statement(s)>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    <test_expr> is an expression evaluated in Boolean context.\n",
    "    <statement(s)> represents the block to be repeatedly executed, often referred to as the body of the loop. This is denoted with indentation, just as in an \"if\" statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a <code>while</code> loop is encountered, <b>test_expr</b> is first evaluated in Boolean context. If it is true, the loop body is executed. Then <b>test_expr</b> is checked again, and if still true, the body is executed again. This continues until <b>test_expr</b> becomes false, at which point program execution proceeds to the first statement beyond the loop body."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "while n < 5:\n",
    "    print(n)\n",
    "    n = n + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here’s what’s happening in this example:\n",
    "- <code>n</code> is initially <code>0</code>. The expression in the <code>while</code> statement header on line 2 is n < 5, which is true, so the loop body executes. Inside the loop body on line 3, <code>n</code> is printed, and then incremented by 1 to 4.\n",
    "\n",
    "- When the body of the loop has finished, program execution returns to the top of the loop at line 2, and the expression is evaluated again. It is still true, so the body executes again, and 1 is printed.\n",
    "\n",
    "- This continues until <code>n</code> becomes 5. At that point, when the expression is tested, it is false, and the loop terminates. Execution would resume at the first statement following the loop body, but there isn’t one in this case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the controlling expression of the <code>while</code> loop is tested first, before anything else happens. If it’s false to start with, the loop body will never be executed at all:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5\n",
    "while n < 5:\n",
    "    print(n)\n",
    "    n = n + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, when the loop is encountered, n is 5. The controlling expression n > 5 is already false, so the loop body never executes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "while n > 0:\n",
    "    n = n - 1\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python\n",
      "python\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "while n < 5:\n",
    "    print('python')\n",
    "    n = n + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 10 "
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "while n <= 10:\n",
    "    print(n, end=' ')\n",
    "    n = n + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 5 7 9 "
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "while n <= 10:\n",
    "    print(n, end=' ')\n",
    "    n = n + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4 9 16 25 36 49 64 81 100 "
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i <= 10:\n",
    "    print(i ** 2, end=' ')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "course_name = 'python programming'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p y t h o n   p r o g r a m m i n g "
     ]
    }
   ],
   "source": [
    "c = 0\n",
    "while c < len(course_name):\n",
    "    print(course_name[c], end=' ')\n",
    "    c += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g n i m m a r g o r p   n o h t y p "
     ]
    }
   ],
   "source": [
    "i = len(course_name) - 1\n",
    "while i >= 0 :\n",
    "    print(course_name[i], end=' ')\n",
    "    i -= 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python programming'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "course_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "course_name length: 18\n"
     ]
    }
   ],
   "source": [
    "clen = 0\n",
    "while course_name[clen:]:\n",
    "    clen += 1\n",
    "    \n",
    "print(f'course_name length: {clen}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "value = 548423897\n",
    "\n",
    "length = 0\n",
    "while value > 0:\n",
    "    value = value // 10\n",
    "    length += 1\n",
    "    \n",
    "print(length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "value = 548423897\n",
    "\n",
    "length = 0\n",
    "while value != 0:\n",
    "    value = value // 10\n",
    "    length += 1\n",
    "    \n",
    "print(length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):    \n",
    "    \"\"\"Print a Fibonacci series up to n.\"\"\"\n",
    "    a, b = 0, 1\n",
    "    while a < n:\n",
    "        print(a, end=' ')\n",
    "        a, b = b, a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 "
     ]
    }
   ],
   "source": [
    "# Now call the function \n",
    "fib(2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum is:  55\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "\n",
    "# initialize sum and counter\n",
    "s = 0\n",
    "i = 1\n",
    "\n",
    "while i <= n:\n",
    "    s += i\n",
    "    i += 1    # update counter\n",
    "\n",
    "# print the sum\n",
    "print(\"The sum is: \", s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python <code>while</code> Loop with <code>continue</code> and <code>break</code> Keywords"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides two keywords that terminate a loop iteration prematurely:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The Python <code>break</code> statement immediately terminates a loop entirely. Program execution proceeds to the first statement following the loop body.\n",
    "- The Python <code>continue</code> statement immediately terminates the current loop iteration. Execution jumps to the top of the loop, and the controlling expression is re-evaluated to determine whether the loop will execute again or terminate."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note</b>: <code>break</code> and <code>continue</code> only operate on a single level of loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, <code>break</code> and <code>continue</code> statements can alter the flow of a normal loop.\n",
    "\n",
    "Loops iterate over a block of code until test expression is false, but sometimes we wish to terminate the current iteration or even the whole loop without checking test expression.\n",
    "\n",
    "The <code>break</code> and <code>continue</code> statements are used in these cases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <code>continue</code> <b>keyword with</b> <code>while</code> <b>loop</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>continue statement</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A <code>continue</code> statement will skip to the next iteration of the loop bypassing the rest of the current block but continuing the loop. As with <code>continue</code>, <code>break</code> can only appear inside loops."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <code>continue</code> statement is used to skip the rest of the code inside a loop for the current iteration only. Loop does not terminate but continues on with the next iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 8 7 6 4 3 2 1 0 \n",
      "Loop ended.\n"
     ]
    }
   ],
   "source": [
    "n = 10                    \n",
    "while n > 0:              \n",
    "    n -= 1\n",
    "    if n == 5:\n",
    "        continue\n",
    "    print(n, end=' ')\n",
    "print('\\nLoop ended.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <code>break</code> <b>keyword with</b> <code>while</code> <b>loop</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>break statement</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a <code>break</code> statement executes inside a loop, control flow \"breaks\" out of the loop immediately."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If <code>break</code> statement is inside a nested loop (loop inside another loop), <code>break</code> will terminate the innermost loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Breaking from loop!\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    if i == 5:\n",
    "        print(\"Breaking from loop!\")\n",
    "        break\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The loop conditional will not be evaluated after the <code>break</code> statement is executed. Note that <code>break</code> statements are only allowed <i>inside loops</i>, syntactically. A <code>break</code> statement inside a function cannot be used to terminate loops that called that function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 8 7 6 \n",
      "Loop ended.\n"
     ]
    }
   ],
   "source": [
    "n = 10                    \n",
    "while n > 0:              \n",
    "    n -= 1\n",
    "    if n == 5:\n",
    "        break\n",
    "    print(n, end=' ')\n",
    "print('\\nLoop ended.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "number = 548423897\n",
    "\n",
    "n_len = 0\n",
    "while True:\n",
    "    number = number // 10\n",
    "    n_len += 1\n",
    "    if number == 0:\n",
    "        break\n",
    "        \n",
    "print(n_len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python <code>while</code> Loop with <code>else</code> Clause"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python allows an optional <code>else</code> clause at the end of a <code>while</code> loop. This is a unique feature of Python, not found in most other programming languages. The syntax is shown below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    while <test_expr>:\n",
    "        <statement(s)>\n",
    "    else:\n",
    "        <additional_statement(s)>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <code>else</code> part is executed if the condition in the while loop evaluates to <code>False</code>.\n",
    "\n",
    "The while loop can be terminated with a <code>break</code> statement. In such case, the <code>else</code> part is ignored. Hence, a <code>while</code> loop's <code>else</code> part runs if no <code>break</code> occurs and the condition is false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "Loop ended.\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 5:\n",
    "    print(i)\n",
    "    i += 1\n",
    "else:\n",
    "    print(\"Loop ended.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 5:\n",
    "    if i == 3:\n",
    "        break\n",
    "    print(i)\n",
    "    i += 1\n",
    "else:\n",
    "    print(\"Loop ended.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <code>pass</code>, <code>break</code>, <code>continue</code>, <code>else</code> <b>keywords with</b> <code>while</code> <b>loop</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>pass statement</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>pass</code> is a null statement for when a statement is required by Python syntax (such as within the body of a <code>while</code> or <code>for</code> loop), but no action is required or desired by the programmer. This can be useful as a placeholder for code that is yet to be written."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python programming, <code>pass</code> is a null statement. The difference between a <i>comment</i> and <code>pass</code> statement in Python is that, while the interpreter ignores a <i>comment</i> entirely, <code>pass</code> is not ignored.\n",
    "\n",
    "However, nothing happens when pass is executed. It results into no operation (NOP)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "while False:\n",
    "    pass \n",
    "    # don't want to do anything, or are not ready to do anything here, so we'll pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some action statements\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    print('some action statements')\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "some action statements\n",
      "0\n",
      "some else statements\n"
     ]
    }
   ],
   "source": [
    "i = 4\n",
    "while i > 0:  \n",
    "    i -= 1\n",
    "    if i == 1:\n",
    "        print('some action statements')\n",
    "        continue\n",
    "    print(i)\n",
    "else:\n",
    "    print('some else statements')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some else statements\n"
     ]
    }
   ],
   "source": [
    "while False:\n",
    "    pass\n",
    "else:\n",
    "    print('some else statements')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some action statements\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    print('some action statements')\n",
    "    break\n",
    "else:\n",
    "    print('some else statements')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note</b>: If a loop has an <code>else</code> clause, it does not execute when the loop is terminated through a <code>break</code> statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "cn = 'python-programming'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python-programming"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < len(cn):\n",
    "    if cn[i] == '-':\n",
    "        pass\n",
    "    print(cn[i], end='')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python-programming\n",
      "some else statements\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < len(cn):\n",
    "    if cn[i] == '-':\n",
    "        pass\n",
    "    print(cn[i], end='')\n",
    "    i += 1\n",
    "else:\n",
    "    print('\\nsome else statements')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "# i = 0\n",
    "# while i < len(cn):\n",
    "#     if cn[i] == '-':\n",
    "#         i = len(cn)\n",
    "#     print(cn[i], end='')\n",
    "#     i += 1\n",
    "\n",
    "# IndexError: string index out of range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < len(cn):\n",
    "    if cn[i] == '-':\n",
    "        i = len(cn)\n",
    "        continue\n",
    "    print(cn[i], end='')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python\n",
      "some else statements\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < len(cn):\n",
    "    if cn[i] == '-':\n",
    "        i = len(cn)\n",
    "        continue\n",
    "    print(cn[i], end='')\n",
    "    i += 1\n",
    "else:\n",
    "    print('\\nsome else statements')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < len(cn):\n",
    "    if cn[i] == '-':\n",
    "        break\n",
    "    print(cn[i], end='')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < len(cn):\n",
    "    if cn[i] == '-':\n",
    "        break\n",
    "    print(cn[i], end='')\n",
    "    i += 1\n",
    "else:\n",
    "    print('\\nsome else statements')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "space not found in the string.\n"
     ]
    }
   ],
   "source": [
    "cn = 'python-programming'\n",
    "\n",
    "i = 0\n",
    "while i < len(cn):\n",
    "    if cn[i] == ' ':\n",
    "        print('space found in the string.')\n",
    "        break\n",
    "    i += 1\n",
    "else:\n",
    "    # If space not found \n",
    "    print('space not found in the string.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "space not found in the string.\n"
     ]
    }
   ],
   "source": [
    "cn = 'python-programming'\n",
    "\n",
    "if ' ' in cn:\n",
    "    print('space found in the string.')\n",
    "else:\n",
    "    print('space not found in the string.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Infinite Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "# while True:\n",
    "#     print('loop')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>break</code> and <code>continue</code> only operate on a single level of loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "# while True:\n",
    "#     for i in range(1,5):\n",
    "#         if i == 2:\n",
    "#             break      # Will only break out of the inner loop!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also specify multiple <code>break</code> statements in a loop:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    while True:\n",
    "        if <test_expr1>:  # One condition for loop termination\n",
    "            break\n",
    "        ...\n",
    "        if <test_expr2>:  # Another termination condition\n",
    "            break\n",
    "        ...\n",
    "        if <test_expr3>:  # Yet another\n",
    "            break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Nested <code>while</code> Loop "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, Python control structures can be nested within one another."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>while</code> loop can be contained within another <code>while</code> loop, as shown here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 , 5\n",
      "1 , 6\n",
      "1 , 7\n",
      "complete inner loop: 1\n",
      "2 , 5\n",
      "2 , 6\n",
      "2 , 7\n",
      "complete inner loop: 2\n",
      "3 , 5\n",
      "3 , 6\n",
      "3 , 7\n",
      "complete inner loop: 3\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 4:\n",
    "    j = 5\n",
    "    while j < 8:\n",
    "        print(f'{i} , {j}')\n",
    "        j += 1\n",
    "    print(f'complete inner loop: {i}')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 , 5\n",
      "2 , 6\n",
      "3 , 7\n"
     ]
    }
   ],
   "source": [
    "i, j = 1, 5\n",
    "while i < 4:\n",
    "    while j < 8:\n",
    "        print(f'{i} , {j}')\n",
    "        j += 1\n",
    "        i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****\n",
      "*****\n",
      "*****\n",
      "*****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i <= 5:\n",
    "    j = 1\n",
    "    while j <= 5:\n",
    "        print('*', end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****\n",
      "*   *\n",
      "*   *\n",
      "*   *\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i <= 5:\n",
    "    j = 1\n",
    "    while j <= 5:\n",
    "        if i == 1 or j == 1 or i == 5 or j == 5:\n",
    "            print('*', end='')\n",
    "        else:\n",
    "             print(' ', end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*\n",
      "**\n",
      "***\n",
      "****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i <= 5:\n",
    "    j = 1\n",
    "    while j <= i:\n",
    "        print('*', end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****\n",
      "****\n",
      "***\n",
      "**\n",
      "*\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i <= 5:\n",
    "    j = i\n",
    "    while j <= 5: print('*', end=''); j += 1\n",
    "    print()\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    *\n",
      "   **\n",
      "  ***\n",
      " ****\n",
      "*****\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i <= 5:\n",
    "    j = 1\n",
    "    while j <= 5 - i:\n",
    "        print(' ', end='')\n",
    "        j += 1\n",
    "    k = 1\n",
    "    while k <= i:\n",
    "        print('*', end='')\n",
    "        k += 1\n",
    "    print()\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****\n",
      " ****\n",
      "  ***\n",
      "   **\n",
      "    *\n"
     ]
    }
   ],
   "source": [
    "i = 5\n",
    "while i >= 1:\n",
    "    j = 1\n",
    "    while j <= 5 - i: print(' ', end=''); j += 1\n",
    "    k = 1\n",
    "    while k <= i: print('*', end=''); k += 1\n",
    "    print()\n",
    "    i -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2, is a prime number\n",
      "3, is a prime number\n",
      "4 equals 2 * 2\n",
      "5, is a prime number\n",
      "6 equals 2 * 3\n",
      "7, is a prime number\n",
      "8 equals 2 * 4\n",
      "9 equals 3 * 3\n",
      "10 equals 2 * 5\n",
      "11, is a prime number\n",
      "12 equals 2 * 6\n",
      "13, is a prime number\n",
      "14 equals 2 * 7\n",
      "15 equals 3 * 5\n"
     ]
    }
   ],
   "source": [
    "i = 2\n",
    "while i <= 15: \n",
    "    j = 2\n",
    "    while j <= (i / j):\n",
    "        if not (i % j): print(f'{i} equals {j} * {i // j}'); break\n",
    "        j += 1\n",
    "    if j > (i / j): print(f'{i}, is a prime number')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A <code>break</code> or <code>continue</code> statement found within nested loops applies to the nearest enclosing loop:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    while <test_expr1>:\n",
    "        statement\n",
    "        statement\n",
    "        \n",
    "        while <test_expr2>:\n",
    "            statement\n",
    "            statement\n",
    "            \n",
    "            break      # Applies to while <test_expr2>: loop\n",
    "\n",
    "        break          # Applies to while <test_expr1>: loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, <code>while</code> loops can be nested inside <code>if/elif/else</code> statements, and vice versa:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    if <test_expr>:\n",
    "        statement\n",
    "        while <test_expr>:\n",
    "            statement\n",
    "            statement\n",
    "    else:\n",
    "        while <test_expr>:\n",
    "            statement\n",
    "            statement\n",
    "        statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    while <test_expr>:\n",
    "        if <test_expr>:\n",
    "            statement\n",
    "        elif <test_expr>:\n",
    "            statement\n",
    "        else:\n",
    "            statement\n",
    "\n",
    "        if <test_expr>:\n",
    "            statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "from getpass import getpass\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~ Welcome Rizwan ~~\n"
     ]
    }
   ],
   "source": [
    "c = 3\n",
    "while True:\n",
    "    username = input(\"Enter username : \")\n",
    "    password = getpass(\"Enter password : \")\n",
    "    \n",
    "    if username.lower() == 'rizwan' and password == \"123\":\n",
    "        clear_output()\n",
    "        while True:\n",
    "            print('Loading ...')\n",
    "            time.sleep(5)\n",
    "            \n",
    "            clear_output()\n",
    "            print(f'~~ Welcome {username.title()} ~~')\n",
    "            \n",
    "            # some actions here ...\n",
    "            break\n",
    "            \n",
    "        break\n",
    "    else:\n",
    "        if c == 0: print(f'Invalid... No attempt left!'); break\n",
    "        else: \n",
    "            print(f'Invalid! {c} attempt left...')\n",
    "        c -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python one-line <code>while</code> Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with an <code>if</code> statement, a <code>while</code> loop can be specified on one line. If there are multiple statements in the block that makes up the loop body, they can be separated by semicolons (;)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 5: print(i); i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The \"half loop\" do-while"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike other languages, Python doesn't have a do-until or a do-while construct (this will allow code to be executed once before the condition is tested). However, you can combine a <code>while True</code> with a <code>break</code> to achieve the same purpose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "while True:\n",
    "    print(a)\n",
    "    a = a - 1\n",
    "    if a < 7:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 1  \n",
    "while True:  \n",
    "    print(i)  \n",
    "    i = i + 1  \n",
    "    if i > 5:  \n",
    "        break "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Self Task "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Problem: Simple Email Parsing</b> - <code>rizwan.datahub@gmail.com</code>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Expected Output: \n",
    "<code>\n",
    "Before @ Email: rizwan.datahub\n",
    "After @ Email: gmail.com\n",
    "After . Emial: com\n",
    "</code>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Skills Required: \n",
    "<code>\n",
    "Python Input & Output\n",
    "Operators \n",
    "String Handling\n",
    "Conditional Statements\n",
    "While Loop\n",
    "User-defined Functions \n",
    "Python Modules \n",
    "</code>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note</b>: Build custom logic ... <code>str.split</code>, <code>in</code>, slicing etc. not used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from custom_email_parsing import email_parser\n",
    "\n",
    "# # accept valid email \n",
    "# email_parser(email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Happy Learning 😊"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}