data-types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6f03b2df-1516-4e52-92af-f415e1460406",
   "metadata": {},
   "source": [
    "# Python supports many types of data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe8b0991-1012-4696-9cec-3dfde091eef9",
   "metadata": {},
   "source": [
    "Some data types are **mutable**, which means their values can be changed. On the other hand, the values of  **immutable** data types cannot be chagned."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56ae728d-a674-489b-8a63-ecef2d07082d",
   "metadata": {},
   "source": [
    "|Name|Data type|Mutable|Example|\n",
    "|-----|------|------|------|\n",
    "|Boolean|bool|no|True, False|\n",
    "|Integer|int|no|25, 3400, 25_000|\n",
    "|Floating point|float|no|3.14, 2.7e5|\n",
    "|Complex|complex|no|3j, 5+9j|\n",
    "|Text string|str|no|'alert', \"attack\", '''a verse attack'''|\n",
    "|List|list|yes|['Wind', 'Ball', 'Beer']|\n",
    "|Tuple|tuple|no|(3,4,5)|\n",
    "|Bytes|bytes|no|b'ab\\xff'|\n",
    "|ByteArray|bytearray|yes|bytearray(...)|\n",
    "|Set|set|yes|{3,5,7}|\n",
    "|Frozen set|frozenset|no|frozenset(['Elza', 'Otto'])|\n",
    "|Dictionary|dict|yes|{'a': 34, 'b': 56}|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2beb3a3a-62b1-4694-95ff-576ef23af20b",
   "metadata": {},
   "source": [
    "To learn about a type of the data, try this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "47fed1a9-8304-4008-8a34-31aa1f04cc13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f42658fe-dc2f-419e-94ba-b7425b7bce5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(7_400_500)  # this is also a valid integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "13e838f5-66c0-4267-85ad-d5f42e0b1047",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1_2_3_4)  # _(s) are ignored by Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0e98ad28-599d-48ec-8ece-3b4ce323f562",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(7.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b52872ac-206a-4b38-8f12-02f084e7951d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(5 + 9j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cd03165b-3872-42af-8969-09060d59d2d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type([3,4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "557966a3-24cb-41c7-aa2c-5d53dae401fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(4.59, float)  # check if the value is of type float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f3052fff-7972-4264-a8cc-51f011347140",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(5, int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "126ec9db-53b4-44f9-be93-b1a49a37c792",
   "metadata": {},
   "source": [
    "### Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5824d304-6003-4a49-97f7-19371e659282",
   "metadata": {},
   "source": [
    "The name of a variable can only contains:\n",
    "\n",
    "* Lowercase letters (a through z)\n",
    "* Uppercase letters (A through Z)\n",
    "* Digits (0 through 9)\n",
    "* Underscore ('_')\n",
    "\n",
    "They are case sensitive. thing, Thing and THING are not the same.\n",
    "\n",
    "They must begins with characters or an underscore, not digits.\n",
    "\n",
    "Names that begin with underscores are treated specially.\n",
    "\n",
    "They cannot be one of the Python's reserved words."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cc95a95-5af7-4126-980a-02521375847f",
   "metadata": {},
   "source": [
    "### Reserved words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8b1cc0c2-37bc-4d39-8532-ab48e1ad77fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Here is a list of the Python keywords.  Enter any keyword to get more help.\n",
      "\n",
      "False               break               for                 not\n",
      "None                class               from                or\n",
      "True                continue            global              pass\n",
      "__peg_parser__      def                 if                  raise\n",
      "and                 del                 import              return\n",
      "as                  elif                in                  try\n",
      "assert              else                is                  while\n",
      "async               except              lambda              with\n",
      "await               finally             nonlocal            yield\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(\"keywords\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bfb888d-35fb-47f5-b16c-f3723a1f52ee",
   "metadata": {},
   "source": [
    "The value can be assigned to a variable using an equal sign. The value on the right side of the equal sign is always assigned to the variable on the left side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2e75e62c-2bb7-404b-9722-203e09011903",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 20.0\n",
    "b = 'hello, world'\n",
    "d = {'balloon': 34, 'house': 5}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb286bbf-8eb7-4bf2-8a4a-794c746bbc4d",
   "metadata": {},
   "source": [
    "Operations performed on the variable will affect the value in it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6d4d942c-f737-4d2b-8897-520642647bd6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a00a169d-2aff-4fe6-991c-8a1003b71a73",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO, WORLD'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.upper()  # upper method is a function that convert letters to uppercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "53bc34c6-9a28-4bfc-a803-b4ae2ba37b27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.pop('balloon')  # pop method in a dictionary removes an item with a given key and returns its value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68314245-1013-4faa-9bd9-4c7795fedcf8",
   "metadata": {},
   "source": [
    "The value can be assigned to multiple names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2e5ed0b8-3292-4af6-9e44-47a78ad20bc0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 30 30\n"
     ]
    }
   ],
   "source": [
    "x = y = z = 30\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "21331781-deb1-475b-b9a0-d9cbe004f383",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34 24 35\n"
     ]
    }
   ],
   "source": [
    "x, y, z = 34, 24, 35  # this is a technique called unpacking\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b7646827-e47f-4b42-a37a-dd5d9931665b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50 40\n"
     ]
    }
   ],
   "source": [
    "x = 40\n",
    "y = 50\n",
    "\n",
    "x, y = y, x\n",
    "\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42a2f332-6bbe-4b55-a87b-fc8646314f9b",
   "metadata": {},
   "source": [
    "You can use Python's string formatting to print out values of the variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f19c9152-e68c-4a41-89cb-631889b03cc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y=60, x=500\n"
     ]
    }
   ],
   "source": [
    "x = 500; y = 60\n",
    "\n",
    "print(f'y={y}, x={x}')  # this is something called f string formatting, more on this later."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90f69447-3ec7-4973-b196-77ed4daad060",
   "metadata": {},
   "source": [
    "## Gotchas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab007ab0-2048-46be-9c17-3c18a310b217",
   "metadata": {},
   "source": [
    "In Python, a variable of non-primitive data types is just a name, not a place. The variable just points to a place in a memory that stores the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "07c85625-d235-470d-9c84-b55d6b8b537f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 5\n"
     ]
    }
   ],
   "source": [
    "a = 5  # int is primitive data type\n",
    "b = a  # b is now has a value 5, another set of data\n",
    "a += 1  # 1 is added to a, only the value in a is incremented\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "65753389-a56f-4809-b7eb-12209a0625a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "b = a  # b now points to a place that stores a list for a list is not a primitive data type.\n",
    "a.pop()  # when the value that a points to changes, the value in b changes as well\n",
    "print(b)  # since b points to the same data location, the last item is also removed (popped) in b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce49750e-d84a-4db5-88bd-472b7c2656ce",
   "metadata": {},
   "source": [
    "## Advanced concept"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6da6fe85-601e-4b31-8fbf-fe1723da6479",
   "metadata": {},
   "source": [
    "Python is a **strongly typed** language. The data type cannot be changed and operation between two different types is usually not supported. However, operators may function differently when applied to different data types. This is called **operator overloading**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a317aafb-5446-4e61-9a7d-1e76c161ea31",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_30560/3264992788.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m1\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m'1'\u001b[0m  \u001b[1;31m# ADDITION OF THE INTEGER AND STRING IS NOT ALLOWED\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "1 + '1'  # ADDITION OF THE INTEGER AND STRING IS NOT ALLOWED"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "67b712d7-a6b7-44e9-a24e-b8f997f42942",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_30560/2758765718.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;34m'a'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m1\u001b[0m  \u001b[1;31m# addition of string and integer is also not allowed.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "'a' + 1  # addition of string and integer is also not allowed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "47379280-3f19-4bf6-a99c-9f97a5202277",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ab'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' + 'b'  # however, a plus operator, when applied to strings, it will concatenate them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3d669c70-35b0-44bc-9ac0-bb8dbeaf5972",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aaaaa'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' * 5  # a multiply operator interpreted as multiple concatenation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5c217e0-d00d-49f0-bece-6f38ed5b59d0",
   "metadata": {},
   "source": [
    "### Fizzbuzz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c29d1736-528b-4a8e-b3fd-a3c71c8515a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 = fizz\n",
      "5 = buzz\n",
      "6 = fizz\n",
      "9 = fizz\n",
      "10 = buzz\n",
      "12 = fizz\n",
      "15 = fizz buzz\n",
      "18 = fizz\n",
      "20 = buzz\n",
      "21 = fizz\n",
      "24 = fizz\n",
      "25 = buzz\n",
      "27 = fizz\n",
      "30 = fizz buzz\n",
      "33 = fizz\n",
      "35 = buzz\n",
      "36 = fizz\n",
      "39 = fizz\n",
      "40 = buzz\n",
      "42 = fizz\n",
      "45 = fizz buzz\n",
      "48 = fizz\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "while n < 50:\n",
    "    if n % 15 == 0:\n",
    "        print(f'{n} = fizz buzz')\n",
    "    elif n % 5 == 0:\n",
    "        print(f'{n} = buzz')\n",
    "    elif n % 3 == 0:\n",
    "        print(f'{n} = fizz')\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ade05c73-da22-4f1b-88d8-6e80f9cf8a80",
   "metadata": {},
   "source": [
    "## An Array of Sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06cc7551-7dea-4c17-b7c5-4954651d9d14",
   "metadata": {},
   "source": [
    "## Built-in Sequence Types\n",
    "\n",
    "* **Container sequences** contains different types of data or a nested container: **list, tuple**\n",
    "* **Flat sequences** can only contains a simple data type: **string, bytes**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adb3d0fa-2bbb-449c-9f3a-d46387d1fc06",
   "metadata": {},
   "source": [
    "## Mutable vs Immutable Sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6a22774-c195-4a43-bd85-7113bff1beb0",
   "metadata": {},
   "source": [
    "* **mutable sequences** such as **list**\n",
    "* **immutable sequences** such as **tuple, str, bytes**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b1d1a98-6fe1-4ba5-817c-2ee3cb068c92",
   "metadata": {},
   "source": [
    "### Introduction to List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fccfde82-e3b7-4d0b-93d1-25511b959be3",
   "metadata": {},
   "outputs": [],
   "source": [
    "computer_languages = ['Java', 'Python', 'Ruby', 'Perl', 'PHP', 'JavaScript', 'Rust', 'Kotlin']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e81e2e86-e21e-4d4a-a37c-ebaa2297e9c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(computer_languages)  # get a number of members of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3b5b110b-8ca9-4dab-9ffb-ca4f6e6fd61b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Java'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_languages[0]  # use an index 0 to access the first item and so on.\n",
    "                        # note that the index starts at 0 not 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "18de8902-da29-4e80-b0b8-13e049953db0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_languages[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f91acb8c-8b12-4dbc-a0e6-7e7406a2891b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Kotlin'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_languages[-1] # use a negative index to access the item from the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0f83b675-f851-41ca-8087-1608098d19f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Rust'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_languages[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8f8689a6-dce9-429f-baf8-099d5f340358",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Python', 'Ruby', 'Perl']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_languages[1:4]  # a list can be sliced"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "de320433-fc76-44bf-924e-fd452031759c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['PHP', 'JavaScript']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_languages[-4:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0b1e2ac0-a099-4e4d-bf1c-d902133e0be6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Python', 'Perl', 'JavaScript']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_languages[1:6:2]  # the last parameter is a step"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1087f40f-f788-478c-a21d-66b307f34430",
   "metadata": {},
   "source": [
    "A list can be iterated (accessed) by a **for** keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0e4c44a6-6636-486e-aca9-4ef819c4a744",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Java\n",
      "Python\n",
      "Ruby\n",
      "Perl\n",
      "PHP\n",
      "JavaScript\n",
      "Rust\n",
      "Kotlin\n"
     ]
    }
   ],
   "source": [
    "for lang in computer_languages:\n",
    "    print(lang)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a97b5e0-7006-4c90-8e36-20787d660cb8",
   "metadata": {},
   "source": [
    "### Mutate values in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f4e3d2c2-e7db-4a64-9cca-ba9cf08e51e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "computer_languages[4] = 'Elixir'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bd924c00-6ce3-4e61-98e1-440b764fce83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Java', 'Python', 'Ruby', 'Perl', 'Elixir', 'JavaScript', 'Rust', 'Kotlin']\n"
     ]
    }
   ],
   "source": [
    "print(computer_languages)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa4f73ad-eb1a-4ade-b21b-89c5d43e9d50",
   "metadata": {},
   "source": [
    "### Expanding a List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b493b10a-8eb2-45b0-b93f-55e2d0245c44",
   "metadata": {},
   "source": [
    "Append method adds a new item to the end of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2b7b5967-f5b6-4077-838e-278e5464e9e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Java', 'Python', 'Ruby', 'Perl', 'Elixir', 'JavaScript', 'Rust', 'Kotlin', 'C++']\n"
     ]
    }
   ],
   "source": [
    "computer_languages.append('C++')\n",
    "print(computer_languages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a8cbe956-b760-4f28-965b-af24571455fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "computer_languages.insert(0, 'Smalltalk')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "781aef59-30b0-4130-ba26-447e173d7ab6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Smalltalk', 'Java', 'Python', 'Ruby', 'Perl', 'Elixir', 'JavaScript', 'Rust', 'Kotlin', 'C++']\n"
     ]
    }
   ],
   "source": [
    "print(computer_languages)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27a51c79-d58a-4c59-846b-22b65b5c4ae9",
   "metadata": {},
   "source": [
    "A plus operator combined lists together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c50a3e8b-9f6a-465e-95cc-091f3938e9c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Smalltalk',\n",
       " 'Java',\n",
       " 'Python',\n",
       " 'Ruby',\n",
       " 'Perl',\n",
       " 'Elixir',\n",
       " 'JavaScript',\n",
       " 'Rust',\n",
       " 'Kotlin',\n",
       " 'C++',\n",
       " 'C',\n",
       " 'LISP',\n",
       " 'BASIC']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_languages + ['C', 'LISP', 'BASIC']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8ae3b31d-fc42-4426-b8c9-8886a0c1102c",
   "metadata": {},
   "outputs": [],
   "source": [
    "computer_languages += ['C', 'LISP', 'BASIC']  # this will expand the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "be99218e-f81b-43ba-9b7c-c375eec0954f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Smalltalk', 'Java', 'Python', 'Ruby', 'Perl', 'Elixir', 'JavaScript', 'Rust', 'Kotlin', 'C++', 'C', 'LISP', 'BASIC']\n"
     ]
    }
   ],
   "source": [
    "print(computer_languages)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06daf02a-1b57-437a-bc35-426c3d587d62",
   "metadata": {},
   "source": [
    "### Shortening a List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3402bf8-1888-45c2-9fac-fa3259633419",
   "metadata": {},
   "source": [
    "computer_languages.pop()  # removes the last item and return it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "223059d1-393b-4514-8017-2905488d36cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BASIC'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_languages.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ffdd8dc4-227e-451c-9fa7-ba5554060186",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LISP has been removed from the list\n"
     ]
    }
   ],
   "source": [
    "lang = computer_languages.pop()\n",
    "print(f'{lang} has been removed from the list')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2c0ff48c-a5b9-4468-9283-f8c2d7798980",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Smalltalk\n"
     ]
    }
   ],
   "source": [
    "lang = computer_languages.pop(0)\n",
    "print(lang)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5d94dc2f-91c0-4b7a-bf09-be4521713089",
   "metadata": {},
   "outputs": [],
   "source": [
    "computer_languages.remove('Elixir')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c0e0c4a0-729a-4dd8-b8ea-696250daadce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Java', 'Python', 'Ruby', 'Perl', 'JavaScript', 'Rust', 'Kotlin', 'C++', 'C']\n"
     ]
    }
   ],
   "source": [
    "print(computer_languages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "888f3571-9d76-4648-8a6b-b565779b6771",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "list.remove(x): x not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_3140/4104278522.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mcomputer_languages\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Dart'\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# if the value is not in the list, ValueError is raised\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: list.remove(x): x not in list"
     ]
    }
   ],
   "source": [
    "computer_languages.remove('Dart')  # if the value is not in the list, ValueError is raised"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8c7188fe-c0c0-4341-8f16-02c9e60caf5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "del computer_languages[4]  # delete the fifth item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b98dd2cf-e16f-4956-b184-e73cd00e6494",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Java', 'Python', 'Ruby', 'Perl', 'Rust', 'Kotlin', 'C++', 'C']\n"
     ]
    }
   ],
   "source": [
    "print(computer_languages)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be86f0be-bae1-484b-b6f5-556e50a24861",
   "metadata": {},
   "source": [
    "### Finding an item in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "1cecb67d-0d9c-4d70-8351-aed445269bbf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "computer_languages.index('Perl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "832c1fbe-9f65-4c6f-a52b-a3e66d1b9d4c",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "'Dart' is not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_3140/3222620052.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mcomputer_languages\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Dart'\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# ValueError is raised if the value is not in a list\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: 'Dart' is not in list"
     ]
    }
   ],
   "source": [
    "computer_languages.index('Dart')  # ValueError is raised if the value is not in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f9632d57-d2fa-4dec-9a00-6867f6cef9d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Perl' in computer_languages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "eaf2e4c0-e944-4b81-858f-ec6730803186",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Dart' not in computer_languages"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0627cf3-4a58-4f52-afa4-2f46ec707808",
   "metadata": {},
   "source": [
    "#### Try it yourself\n",
    "Store the names of a few of your friends in a list called _names_. Print each person's name by accessing each element in the list, one at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "c75b69db-c645-490d-9c2e-0a4d83ee3121",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Veto is a friend of mine\n",
      "Michael is a friend of mine\n",
      "Sunny is a friend of mine\n",
      "Fredo is a friend of mine\n",
      "Connie is a friend of mine\n"
     ]
    }
   ],
   "source": [
    "names = ['Veto', 'Michael', 'Sunny', 'Fredo', 'Connie']\n",
    "for name in names:\n",
    "    print(f'{name} is a friend of mine')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "82e812ec-e112-4764-a2a7-e942d940c895",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter an item you want to buy:  soap\n",
      "Please enter an item you want to buy:  shampoo\n",
      "Please enter an item you want to buy:  pants\n",
      "Please enter an item you want to buy:  tea\n",
      "Please enter an item you want to buy:  bread\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "These are all item you want to by: ['soap', 'shampoo', 'pants', 'tea', 'bread']\n"
     ]
    }
   ],
   "source": [
    "cart = []\n",
    "while len(cart) < 5:\n",
    "    item = input('Please enter an item you want to buy: ')\n",
    "    cart.append(item)\n",
    "    \n",
    "print(f'These are all item you want to by: {cart}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4e41aea-3408-4a98-8aa5-ec066f28cc1e",
   "metadata": {},
   "source": [
    "## List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50943e49-fde2-4eaa-a8e1-b8a21cbceca4",
   "metadata": {},
   "source": [
    "Oftentimes we need to create a list from another list. We can starts from an empty list and then loop over the original list to get a value and append it to the empty list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efe97750-3ab2-4478-972b-ecb94dbcb449",
   "metadata": {},
   "outputs": [],
   "source": [
    "work_hours = [3, 5, 2, 3, 6]\n",
    "HOURLY_WAGE = 4.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7bfa11d1-4ecd-46c1-b2f2-64df25320c2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "payments = []\n",
    "for h in work_hours:\n",
    "    payments.append(h * HOURLY_WAGE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4db2e801-d8ad-437f-95ff-e7462a54c411",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'Total payment is {sum(payments)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "890c2d9f-49e6-4663-b77a-c3a3ccb9ecd0",
   "metadata": {},
   "source": [
    "A better solution of the above is to use a list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec3b4183-1905-438d-aa23-c6cb5b01d630",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum([h*HOURLY_WAGE for h in work_hours])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb882f1f-f98c-4dd3-ba74-86419feb994a",
   "metadata": {},
   "source": [
    "### Try it yourself"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4de4360d-df88-48b9-9a66-a6d781e866b7",
   "metadata": {},
   "source": [
    "Select only a computer language that starts with 'P'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f77782c2-8907-4244-8c91-e0fc906b952f",
   "metadata": {},
   "outputs": [],
   "source": [
    "[lang for lang in computer_languages if lang.startswith('P')]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b80f4bf-2f9e-4b1d-b7a3-b43afe8da2d1",
   "metadata": {},
   "source": [
    "## Introducing Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae40d254-aa1d-4de1-995d-aa6ad09772de",
   "metadata": {},
   "source": [
    "**Tuple** is very mush like List but it is **immutable**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59e81d23-e704-4351-9eca-dd5502a05f59",
   "metadata": {},
   "outputs": [],
   "source": [
    "languages = ('Chinese', 'Thai', 'English', 'Spanish', 'French')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf23183b-5158-427e-9162-abf7eebdb027",
   "metadata": {},
   "outputs": [],
   "source": [
    "languages[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05b46a7f-caba-412c-b0aa-7098eb28c42e",
   "metadata": {},
   "outputs": [],
   "source": [
    "languages[2:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98fa4ca2-cae8-4fd7-a9f3-5a919a6bf616",
   "metadata": {},
   "source": [
    "However, it is not possible to change its value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "761352d4-8140-4e35-a9e0-48297403db16",
   "metadata": {},
   "outputs": [],
   "source": [
    "languages[2] = 'Korean'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a666e68-4380-4b9d-9e2e-9a22ba93db92",
   "metadata": {},
   "outputs": [],
   "source": [
    "del languages[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a38dab1-453d-4d7c-882c-64e6157b70db",
   "metadata": {},
   "source": [
    "There is no tuple comprehension, but a list can be created from a tuple with list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca413ab2-c20b-468e-81c1-f8e9f0282908",
   "metadata": {},
   "outputs": [],
   "source": [
    "[lang for lang in languages if lang.endswith('h')]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad8485b4-d4ef-4fc1-90c7-11a558b47648",
   "metadata": {},
   "source": [
    "A tuple is so common in Python. It can be created literally using a comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46c50d3b-ae6a-42bc-b229-cce7afac3f37",
   "metadata": {},
   "outputs": [],
   "source": [
    "days = 'Sat', 'Sun', 'Mon'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6575a8f-56f4-4d2f-9190-cb907c9a60c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(days)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5db56643-550b-480e-84db-a2b42d8d317b",
   "metadata": {},
   "outputs": [],
   "source": [
    "profile = 'Likit', 'Preeyanon', 1985"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed9f2bdb-3cbf-4e54-ba37-ecd6c5e02e38",
   "metadata": {},
   "source": [
    "If a tuple is assigned to variables, each value will be assign to a matching variable. This is called **unpacking** of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a027ef0d-867a-4eaa-beba-ddc7d47dc317",
   "metadata": {},
   "outputs": [],
   "source": [
    "firstname, lastname, born = profile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20db3002-1a54-44d6-a9a9-dd59ff32e4eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'{firstname} {lastname} was born in {born}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52803135-f7fa-4764-91e7-1fddd9d1e59d",
   "metadata": {},
   "outputs": [],
   "source": [
    "firstname, lastname = profile  # ValueError is raised if the variables do not match the values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a784e9ab-a594-4671-ab18-b4fbd87f7b59",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Try it yourself"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d02e20a-1f4b-4bf7-96ec-7c7060ecb14e",
   "metadata": {},
   "source": [
    "Write a program that take a list of tests from a customer and calculate the total payment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0247feb-c1cb-40e5-a59f-7004b1a2f590",
   "metadata": {},
   "outputs": [],
   "source": [
    "tests = (('LDL', 300), ('HDL', 150), ('Glucose', 40), ('Triglyceride', 300))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6a6a944-b50a-46f0-87f3-4680002d0b80",
   "metadata": {},
   "outputs": [],
   "source": [
    "orders = []\n",
    "while len(orders) < 4:\n",
    "    test = input('Please enter a test: ')\n",
    "    if test != '':\n",
    "        orders.append(test)\n",
    "    else:\n",
    "        break\n",
    "    \n",
    "payment = 0\n",
    "\n",
    "for test, price in tests:  # implicit unpacking\n",
    "    if test in orders:\n",
    "        payment += price\n",
    "        \n",
    "print(f'You have to pay {payment}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d328fe5-46fe-4a33-b7f0-05d7713a3ca6",
   "metadata": {},
   "source": [
    "### Try it yourself"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc2e6756-dae6-437c-83ad-2757c583c46b",
   "metadata": {},
   "source": [
    "Write a program that lets a user guess a number between 1-100. The program will help tell a user whether his/her guess is too big or too small. The programs stops if the user has attempted more than 10 times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "44d37db9-dc92-467a-b79b-c738cb098864",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "64a2cbda-2f87-4344-a1dc-8fe92289f363",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  50\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is too big.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  25\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is too small.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  30\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Congratulations! You win!\n"
     ]
    }
   ],
   "source": [
    "answer = random.randint(1, 100)\n",
    "attempts = []\n",
    "while len(attempts) < 5:\n",
    "    guess = input('Enter a number: ')\n",
    "    attempts.append(guess)\n",
    "    if int(guess) == answer:\n",
    "        print('Congratulations! You win!')\n",
    "        break\n",
    "    elif int(guess) < answer:\n",
    "        print('The number is too small.')\n",
    "    else:\n",
    "        print('The number is too big.')\n",
    "        \n",
    "if len(attempts) == 5:\n",
    "    print(f'The answer is {answer}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58373116-27e5-43cd-8fc5-2edf60a1e65f",
   "metadata": {},
   "source": [
    "## Real World Example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad6700f1-a159-4d44-bab4-ed48160745f6",
   "metadata": {},
   "source": [
    "Do you know what is in the We Mahidol App QR Code?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "9a177ce5-2a85-41e4-87ac-0479b1a01ead",
   "metadata": {},
   "outputs": [],
   "source": [
    "content = 'kx8iuklscq8qifhj4u|13.790515|100.548422|02:06:37|05/09/2022||ผศ. ดร.|ลิขิต ปรียานนท์||ผศ. ดร.|Likit Preeyanon|คณะเทคนิคการแพทย์|FACULTY OF MEDICAL TECHNOLOGY|||N|fpa|||UNI_MQR'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "5d80eeec-6298-48be-976a-3967cedb3bf0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kx8iuklscq8qifhj4u|13.790515|100.548422|02:06:37|05/09/2022||ผศ. ดร.|ลิขิต ปรียานนท์||ผศ. ดร.|Likit Preeyanon|คณะเทคนิคการแพทย์|FACULTY OF MEDICAL TECHNOLOGY|||N|fpa|||UNI_MQR\n"
     ]
    }
   ],
   "source": [
    "print(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "098db44a-4743-4f4c-a9b3-ad3649797cf4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['kx8iuklscq8qifhj4u',\n",
       " '13.790515',\n",
       " '100.548422',\n",
       " '02:06:37',\n",
       " '05/09/2022',\n",
       " '',\n",
       " 'ผศ. ดร.',\n",
       " 'ลิขิต ปรียานนท์',\n",
       " '',\n",
       " 'ผศ. ดร.',\n",
       " 'Likit Preeyanon',\n",
       " 'คณะเทคนิคการแพทย์',\n",
       " 'FACULTY OF MEDICAL TECHNOLOGY',\n",
       " '',\n",
       " '',\n",
       " 'N',\n",
       " 'fpa',\n",
       " '',\n",
       " '',\n",
       " 'UNI_MQR']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "content.split('|')  # split text using a pipe as a delimiter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "59507d9b-aa1a-4642-9818-b1fc92a93d01",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = content.split('|')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "b0253c6c-1086-4e1f-859b-2d010dad4636",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('13.790515', '100.548422')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1], data[2]  # lat, long"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "fb73773c-60cb-4315-a6e0-6d8a3b27dce1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome ผศ. ดร. ลิขิต ปรียานนท์\n"
     ]
    }
   ],
   "source": [
    "print(f'Welcome {data[6]} {data[7]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c180830-3ddc-4e3f-9545-6bc4d5cefe8a",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}