flow-control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "02fdabca-b1ac-4d3c-8198-f6119ba47781",
   "metadata": {},
   "source": [
    "# Flow control"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d8a98ad-0f7d-43b3-a35a-bdb3a59aa860",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c0ecc82-a7b3-45b1-8a8d-46ab3fcf0ef7",
   "metadata": {},
   "source": [
    "We can create a loop to execute a set of command repetitively using **while** or **for** keyword."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0953b3d-450a-4483-9685-c239f2663aca",
   "metadata": {},
   "source": [
    "### while loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5242d871-3100-492b-b447-8d5dfbf79d5d",
   "metadata": {},
   "source": [
    "A set of commands inside a while block runs as long as a condition is True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "db15ee64-426b-4aa4-bea3-2ecb464ea65c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I say hi to you 1 time(s)\n",
      "I say hi to you 2 time(s)\n",
      "I say hi to you 3 time(s)\n",
      "I say hi to you 4 time(s)\n",
      "I say hi to you 5 time(s)\n",
      "I say hi to you 6 time(s)\n",
      "I say hi to you 7 time(s)\n",
      "I say hi to you 8 time(s)\n",
      "I say hi to you 9 time(s)\n",
      "I say hi to you 10 time(s)\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "while n < 10:  # as long as n is less than 10, the code below will keep running again and again\n",
    "    n += 1\n",
    "    print(f'I say hi to you {n} time(s)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94154c80-1e08-45a4-be84-18e4b88cd4d7",
   "metadata": {},
   "source": [
    "To jump to the next round without executing the remainder of the code, use **continue** keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "94b1b9fe-2980-40be-8414-a8cad688098d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I say hi to you 1 time(s)\n",
      "I say hi to you 3 time(s)\n",
      "I say hi to you 5 time(s)\n",
      "I say hi to you 7 time(s)\n",
      "I say hi to you 9 time(s)\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "while n < 10:\n",
    "    n += 1\n",
    "    if n % 2 == 0:\n",
    "        continue\n",
    "    print(f'I say hi to you {n} time(s)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c4cfe7a-2e77-48ff-8a5d-14ce29a20084",
   "metadata": {},
   "source": [
    "To break out of the loop, use **break** keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "eee17758-64d2-4f50-9af7-d4e51ca1e53d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I say hi to you 1 time(s)\n",
      "I say hi to you 3 time(s)\n",
      "I say hi to you 5 time(s)\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "while n < 10:\n",
    "    n += 1\n",
    "    if n % 2 == 0:\n",
    "        continue\n",
    "    if n == 7:\n",
    "        break\n",
    "    print(f'I say hi to you {n} time(s)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4f7e1c0-a28c-4fa5-9683-8ccf72450c39",
   "metadata": {},
   "source": [
    "If you need your code to run infinitively, do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38952717-2bd8-41d8-bce1-ec4bfd4b3742",
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    print('I am running forever.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75dc97a5-8441-4072-bcdf-704e84e63271",
   "metadata": {},
   "source": [
    "### For loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35d4cfaa-4c2a-4a4d-b318-d5386b089bc1",
   "metadata": {},
   "source": [
    "A **for** operator is what you need to loop over values in a collection data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b848d437-b898-4b57-a692-ebf8cb72d2a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "alist = [1,2,3,4,5]\n",
    "\n",
    "for avalue in alist:\n",
    "    print(avalue)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26e53951-c487-43bc-a037-1495e4f71583",
   "metadata": {},
   "source": [
    "Unlike **while**, the for loop stops when the for keyword accesses all values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "399385a7-b3de-45d1-876f-cbd220deb9f9",
   "metadata": {},
   "source": [
    "In fact, **for** loops over an object that are iterable. Many objects such as data types and functions are iterable in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ce8191a4-f806-4085-bc98-77e7d4740229",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "adict = dict([(1, 'a'), (2, 'b'), (3, 'c')])\n",
    "\n",
    "for k in adict:  # a dict act as an iterable that returns a key every time it is accessed by a for keyword\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e3b96064-2b73-491c-b309-50d9d448bac3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1\n",
      "b 2\n",
      "c 3\n"
     ]
    }
   ],
   "source": [
    "for k,v in adict.items():  # items method return a list of values as an iterable\n",
    "    print(v, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e59a8322-1908-45ac-aaf9-9ac9c870956b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "116\n",
      "104\n",
      "105\n",
      "115\n",
      "105\n",
      "115\n",
      "97\n",
      "118\n",
      "101\n",
      "114\n",
      "121\n",
      "108\n",
      "111\n",
      "110\n",
      "103\n"
     ]
    }
   ],
   "source": [
    "for char in 'thisisaverylong':  # a string in Python is also iterable\n",
    "    print(ord(char))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2307b3c3-5d58-4495-93e9-1fccab6cf99f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 20)\n",
      "('b', 30)\n",
      "('c', 40)\n",
      "('d', 50)\n"
     ]
    }
   ],
   "source": [
    "alist = ['a', 'b', 'c', 'd']\n",
    "blist = [20, 30, 40, 50, 60]\n",
    "\n",
    "for apair in zip(alist,blist):  # a zip function returns a pair of value from two lists as a tuple each time it is accessed by a for keyword\n",
    "    print(apair)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3a1307aa-2940-42ef-8c1f-4d0bc3814713",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New York\n",
      "Bangkok\n",
      "London\n",
      "Tokyo\n",
      "Paris\n"
     ]
    }
   ],
   "source": [
    "cities = ['new york', 'bangkok', 'london', 'tokyo', 'paris']\n",
    "\n",
    "titlize = lambda x: x.title()  # lambda is a keyword for creating an anonymous function that can be used to create a short function\n",
    "\n",
    "for c in map(titlize, cities):  # a map function map a function to each value in a list, it returns a value of the function each time it is accessed by a for keyword\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b02ea3d-0c39-48f8-be3a-0cd63fb80422",
   "metadata": {},
   "source": [
    "Oftentimes, you will need to access values in a list. It is an old pattern to use a range and len function like below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0760c4ff-090e-465f-b51e-560d3e478db5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suzuki\n",
      "Mazda\n",
      "Toyota\n",
      "Honda\n"
     ]
    }
   ],
   "source": [
    "cars = ['Suzuki', 'Mazda', 'Toyota', 'Honda']\n",
    "\n",
    "for i in range(len(cars)):\n",
    "    print(cars[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b62fa9a5-a3dd-4015-9000-17f35bcbde0e",
   "metadata": {},
   "source": [
    "Nowadays, it is encouraged to use **enumerate** function which can works with list and other data types as well as iterators where the len function does not apply to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1e6b6a4c-b36c-4155-99c9-a3f8c24dbe3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'Suzuki')\n",
      "(1, 'Mazda')\n",
      "(2, 'Toyota')\n",
      "(3, 'Honda')\n"
     ]
    }
   ],
   "source": [
    "cars = ['Suzuki', 'Mazda', 'Toyota', 'Honda']\n",
    "\n",
    "for items in enumerate(cars):  # enumerate function returns a tuple of index and value from a list\n",
    "    print(items)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ed8968e0-96dc-4437-b4d8-d083ad411ad8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Suzuki\n",
      "2 Toyota\n"
     ]
    }
   ],
   "source": [
    "cars = ['Suzuki', 'Mazda', 'Toyota', 'Honda']\n",
    "\n",
    "for n, value in enumerate(cars):  # using unpacking mechanism, we can easily extract value and index\n",
    "    if n % 2 == 0:\n",
    "        print(n, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f09cb57c-d427-4436-9e13-bc06b9b654ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "T\n",
      "G\n",
      "C\n",
      "A\n",
      "T\n",
      "G\n",
      "C\n",
      "A\n",
      "T\n"
     ]
    }
   ],
   "source": [
    "from itertools import cycle  # cycle generate an iterator that cycles through a set of data forever\n",
    "\n",
    "for n, value in enumerate(cycle('ATGC')):  # unlike len function, enumerate works with itertor\n",
    "    if n == 10:\n",
    "        break\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8379981b-461f-47b6-a611-0a231cafed48",
   "metadata": {},
   "source": [
    "## Condition"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7be69a8-78a2-4191-a6c9-751c3f69bbbf",
   "metadata": {},
   "source": [
    "Python has a boolean data type, which are **True** and **False** for true and false respectively. The boolean operation works as expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "cb38726e-aca8-463f-936e-5887f5ecabac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(True and True)\n",
    "print(True or False)\n",
    "print(True and False)\n",
    "print(True or False and True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfa2513f-4547-4e29-b2b2-a4ec4a8f509d",
   "metadata": {},
   "source": [
    "Although there are only two built-in boolean values, Python considers many other things to be truthy or falsy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9ada23f-c540-4509-a864-8f9545a18557",
   "metadata": {},
   "source": [
    "To evaluate the expression whether it is true or false, we can use the **if** keyword. Code inside the if block will only run if the expression is evaluated to true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "55bb6f0b-441d-48ad-87d7-ac0b788ea175",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "five is greater\n"
     ]
    }
   ],
   "source": [
    "if 5 > 4:\n",
    "    print('five is greater')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "56d49621-cac6-4573-89d5-c93e981caa9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "five is greater or equal to five\n"
     ]
    }
   ],
   "source": [
    "if 5 >= 5:\n",
    "    print('five is greater or equal to five')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "778e82e3-1a0d-47d8-9125-d4dc8b7afe0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is very true\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print('It is very true')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "9cb6b7ff-7dcb-49ee-8eaf-97c2b7d759ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "if False:\n",
    "    print('This is totally false')  # nothing will happen here."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c99d86d-ecbf-4703-992f-f7ae864cdeb0",
   "metadata": {},
   "source": [
    "Let's see if the following values are considered true or false in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "229af706-7901-4ff3-bad2-197c2cfcaf7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "if '':\n",
    "    print('this is an empty string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "912f5916-3974-4473-a2ae-dca781b74b48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a short string\n"
     ]
    }
   ],
   "source": [
    "if 'hello':\n",
    "    print('this is a short string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "d919fd2f-aab8-4f97-8418-fed3d3c5a862",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a single space\n"
     ]
    }
   ],
   "source": [
    "if ' ':\n",
    "    print('this is a single space')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "62ceaeb8-7e9d-4d28-8541-0d0dd0271fbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "if ' ' == '':  # == is used to compare two values and return True if they are equal\n",
    "    print('a space is equal to an empty string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "0413867f-be7d-4ea9-9e41-dc4d210b9b2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a space is not equal to an empty string\n"
     ]
    }
   ],
   "source": [
    "if ' ' != '':  # != is used to compare two values and return True if they are not equal\n",
    "    print('a space is not equal to an empty string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "c983a8d9-ec3a-4691-9c59-c2b63e7ccc13",
   "metadata": {},
   "outputs": [],
   "source": [
    "if None:\n",
    "    print('this is a None data type')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "86a61189-5107-436f-a369-aebed63f637d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a None with a negation\n"
     ]
    }
   ],
   "source": [
    "if not None:  # not is a negation, it converts value from true to false and vice versa.\n",
    "    print('this is a None with a negation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "cfc9d533-95dc-4fad-a670-1ebe2f1b3b87",
   "metadata": {},
   "outputs": [],
   "source": [
    "if 0:\n",
    "    print(\"this is a zero\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "9477f6fc-46c6-442b-b6ee-6ff6e299b534",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a minus twenty\n"
     ]
    }
   ],
   "source": [
    "if -20:\n",
    "    print('this is a minus twenty')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "76778252-7ffa-4804-b8cc-5159f03158ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "if []:\n",
    "    print('this is an empty list')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c20d5664-b61b-48b2-a5f7-784fa5effaf1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a tuple of one value\n"
     ]
    }
   ],
   "source": [
    "if (1,):\n",
    "    print(\"this is a tuple of one value\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "14b9620f-e997-4ea0-969b-5d2af06dc7ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "if {}:\n",
    "    print('this is an empty dictionary')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24901de2-2d58-41f8-92fe-af5c4fe7e126",
   "metadata": {},
   "source": [
    "## Decision Tree"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84e0b089-3439-4c3d-9311-881d74b572a7",
   "metadata": {},
   "source": [
    "To tell Python to make a decision based on a given value, you can construct a decision tree using **if** **elif** and **else** keywords."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "02a365a9-4e4e-44bd-8123-2b6a2d94e451",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You can drink.\n"
     ]
    }
   ],
   "source": [
    "age = 22\n",
    "DRINKING_AGE = 20  # we conventionlly use capital letters for a constant value\n",
    "\n",
    "if age > DRINKING_AGE:\n",
    "    print('You can drink.')\n",
    "else:\n",
    "    print(f'You need to wait for {DRINKING_AGE - age} more years')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "df727c39-1d17-4083-871b-14ba9aefdcb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You need to wait for 2 more years\n"
     ]
    }
   ],
   "source": [
    "age = 18\n",
    "DRINKING_AGE = 20  # we conventionlly use capital letters for a constant value\n",
    "\n",
    "if age > DRINKING_AGE:\n",
    "    print('You can drink.')\n",
    "else:\n",
    "    print(f'You need to wait for {DRINKING_AGE - age} more years')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "cad4ebe3-7c20-45bf-87a9-56e30d48389e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are 23. You can drink.\n",
      "You are only 19. You need to wait for 1 more years\n",
      "You are 24. You can drink.\n",
      "You are only 19. You need to wait for 1 more years\n",
      "You are only 17. You need to wait for 3 more years\n",
      "You are 22. You can drink.\n",
      "You are 22. You can drink.\n",
      "You are only 18. You need to wait for 2 more years\n",
      "You are only 17. You need to wait for 3 more years\n",
      "You are 24. You can drink.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "ages = [random.randint(16,25) for r in range(10)]  # randint generates a number randomly within a specified range\n",
    "\n",
    "DRINKING_AGE = 20  # we conventionlly use capital letters for a constant value\n",
    "\n",
    "for age in ages:\n",
    "    if age > DRINKING_AGE:\n",
    "        print(f'You are {age}. You can drink.')\n",
    "    else:\n",
    "        print(f'You are only {age}. You need to wait for {DRINKING_AGE - age} more years')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "373eb966-56cd-4a95-ad22-d33384289eb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 45\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are 45. You can drink.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 23\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are 23. You can drink.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 19\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are only 19. You need to wait for 1 more years\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: q\n"
     ]
    }
   ],
   "source": [
    "DRINKING_AGE = 20\n",
    "\n",
    "while True:\n",
    "    age = input('Enter your age:')\n",
    "    if age == 'q':\n",
    "        break\n",
    "    age = int(age)  # convert an input to integer\n",
    "    if age > DRINKING_AGE:\n",
    "        print(f'You are {age}. You can drink.')\n",
    "    else:\n",
    "        print(f'You are only {age}. You need to wait for {DRINKING_AGE - age} more years')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "102f9a68-f7e6-4f9e-a220-be64059b0701",
   "metadata": {},
   "source": [
    "**elif** can be used when we need to evaluate more than one condition. If the evaluation is true, the remainder of the code will be ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "7b3711b0-9011-4f6c-af85-acde4b7d46ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: ee\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'ee'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [68]\u001b[0m, in \u001b[0;36m<cell line: 5>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m age \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mq\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m      7\u001b[0m     \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[0;32m----> 8\u001b[0m age \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mage\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# convert an input to integer\u001b[39;00m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m age \u001b[38;5;241m>\u001b[39m ELDER_AGE:\n\u001b[1;32m     10\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mYou are \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mage\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m. You are too old.\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'ee'"
     ]
    }
   ],
   "source": [
    "DRINKING_AGE = 20\n",
    "ELDER_AGE = 60\n",
    "\n",
    "while True:\n",
    "    age = input('Enter your age:')\n",
    "    if age == 'q':\n",
    "        break\n",
    "    age = int(age)  # convert an input to integer\n",
    "    if age > ELDER_AGE:\n",
    "        print(f'You are {age}. You are too old.')\n",
    "    elif age > DRINKING_AGE:\n",
    "        print(f'You are {age}. You can drink.')\n",
    "    else:\n",
    "        print(f'You are only {age}. You need to wait for {DRINKING_AGE - age} more years')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "a31f8a4e-bc2e-41a2-a278-2895b21ecf05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 45\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are 45. You can drink.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: dd\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 23\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are 23. You can drink.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 91\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are 91. You are too old.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are 100. You are too old.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 12\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are only 12. You need to wait for 8 more years\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are only 0. You need to wait for 20 more years\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: q\n"
     ]
    }
   ],
   "source": [
    "DRINKING_AGE = 20\n",
    "ELDER_AGE = 60\n",
    "\n",
    "while True:\n",
    "    age = input('Enter your age:')\n",
    "    if age == 'q':\n",
    "        break\n",
    "    if not age.isdigit():\n",
    "        print('Please enter a number.')\n",
    "        continue\n",
    "    age = int(age)  # convert an input to integer\n",
    "    if age > ELDER_AGE:\n",
    "        print(f'You are {age}. You are too old.')\n",
    "    elif age > DRINKING_AGE:\n",
    "        print(f'You are {age}. You can drink.')\n",
    "    else:\n",
    "        print(f'You are only {age}. You need to wait for {DRINKING_AGE - age} more years')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "a5b7a802-50c5-4744-bb07-64dae4ddb4fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: -30\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 123\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please make sure you enter the number correctly\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 3.4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: 30\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are 30. You can drink.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your age: q\n"
     ]
    }
   ],
   "source": [
    "DRINKING_AGE = 20\n",
    "ELDER_AGE = 60\n",
    "\n",
    "while True:\n",
    "    age = input('Enter your age:')\n",
    "    if age == 'q':\n",
    "        break\n",
    "    if not age.isdigit():\n",
    "        print('Please enter a number.')\n",
    "        continue\n",
    "    age = int(age)  # convert an input to integer\n",
    "    if age > 120:\n",
    "        print('Please make sure you enter the number correctly')\n",
    "    elif age > ELDER_AGE:  # if a person is older than ELDER_AGE, the next elif statement will not be executed\n",
    "        print(f'You are {age}. You are too old.')\n",
    "    elif age > DRINKING_AGE:\n",
    "        print(f'You are {age}. You can drink.')\n",
    "    else:\n",
    "        print(f'You are only {age}. You need to wait for {DRINKING_AGE - age} more years')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f71bbf9-3dd3-4575-9ef9-bd3faaaf218d",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}