03. Calculations - Module 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dca7f792-bdf1-443d-8a4c-8269308df55c",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Module 3 Calculations in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7424e678-af4b-457f-baf9-6f824eb61801",
   "metadata": {},
   "source": [
    "## Functions and Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9b401a1-a979-4ed4-b6c7-c1920ed03266",
   "metadata": {},
   "source": [
    "Functions can be called only by its name, as it is defined independently. But methods can't be called by its name only, we need to invoke the class by a reference of that class in which it is defined, i.e. method is defined within a class and hence they are dependent on that class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6b4ae3c-411d-4358-9470-f060ff98bb8f",
   "metadata": {},
   "source": [
    "> Methods are functions that are specific to a data type. <br>\n",
    "> For example, you can have an uppercase method for a string but not for an interger. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4255f76-4d4c-4327-836a-648560d8af41",
   "metadata": {},
   "source": [
    "Functions can be visually distinguished by theit syntax.  \n",
    "Just like in excel a function is called with `FUNCTION_NAME(INPUT)`\n",
    "Methods, being associted with a class and data type are written as `INPUT.METHOD_NAME()`.  \n",
    "Notce that both functions and methods have parenthesis to allow for additional arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cc5e482-4e16-4e0a-afe1-5aaa7e624f71",
   "metadata": {},
   "source": [
    "The `dir()` function returns a list of attributes and methods associated with & varible. \n",
    "It can interact with varibles of many types a classes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0faa9441-6c02-42e4-85d9-43122d70932f",
   "metadata": {},
   "source": [
    "Click `SHIFT` + `TAB` while the insertion point is on a function for additional information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4018868c-0928-45ed-a086-7eece13768a2",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'removeprefix',\n",
       " 'removesuffix',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"postmodernism\" # \"postmodernism\" is a string\n",
    "dir(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9eee2863-cf8f-49e9-8c26-1e4e565de51a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a.capitalize())\n",
    "print(a.isupper())\n",
    "print(a.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8228ed9-7151-4951-bda3-68f3c7f1d9c1",
   "metadata": {},
   "source": [
    "The `capitalize` method will work on strings but not floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f6e32a2-086f-418f-99d4-a0dba66f679a",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 2.2 # b is a float\n",
    "#dir(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5234e3bc-e984-4525-a494-9168acff6cfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = [1, 2, 3] # c is a list\n",
    "#dir(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d26bc352-9f81-48e0-a230-baf1a94108e1",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'removeprefix',\n",
       " 'removesuffix',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = \"I love dogs\"\n",
    "\n",
    "dir(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "082d26de-aa00-41c7-9458-d5edc82272e2",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69d0ad70-9545-48eb-8295-727f5e2e2807",
   "metadata": {},
   "source": [
    "A data type is a particular kind of data item, as defined by the values it can take, the programming language used, or the operations that can be performed on it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d74e36d-8799-4619-80c0-0fa2e07bf5e3",
   "metadata": {},
   "source": [
    "There are four basic data types in Python:\n",
    "- Numeric: These can be integers or floats. ...\n",
    "- Boolean: These are True/False values.\n",
    "- String: These are text values composed of a sequence of characters.\n",
    "- Sequence: These are collections of data types that can be the same or different."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "123cb228-efe6-43d0-9980-3ff100ed23b7",
   "metadata": {},
   "source": [
    "## Numeric Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cacdc16b-f081-436a-8ec1-c477d4fe76ee",
   "metadata": {},
   "source": [
    "## Int"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "462725aa-8c02-40c6-afa3-c4a62f602cc8",
   "metadata": {},
   "source": [
    "**Int** - In Python, integers are zero, positive or negative whole numbers without a fractional part and having unlimited precision, e.g. 0, 100, -10. \n",
    "All integers or variables are objects of the int class. Use the `type()` function to get the class name, as shown below.  \n",
    "The followings are valid integers in Python.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fac24993-9c07-48b9-9bb7-d97322740fb9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(0))\n",
    "print(type(3000))\n",
    "print(type(-123456677057575))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c938eb41-2efa-4a95-b67f-15bd379dd8c6",
   "metadata": {},
   "source": [
    "Uncomment to check data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d6d84c7c-3a0f-432b-85b7-2439e3f99c6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2 + 3\n",
    "c = -122323423523 - 2\n",
    "\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47f44518-2ac3-475d-87f1-8c24ab001c56",
   "metadata": {},
   "source": [
    "## **Limitations**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31ad9304-431b-493a-952b-7320b8480cc7",
   "metadata": {},
   "source": [
    "Leading zeros in non-zero integers are not allowed e.g. 000123 is invalid number, 0000 is 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a88756af-76ec-4d17-a27a-44939d6cebcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(000123))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7774b99-c8a6-4383-8aac-6e86fdc452cf",
   "metadata": {},
   "source": [
    "Python does not allow comma as number delimiter. Use underscore _ as a delimiter instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4cdff56-09c6-4afa-85b8-ba9fd9fff253",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 123,000\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bce8cdb5-770e-43b8-a509-228db94ed0d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 123_000\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6b3ef9-cdc0-489d-bc8b-772c0f69565d",
   "metadata": {},
   "source": [
    "Integers must be without a fractional part (decimal point).  \n",
    "If it includes a fractional then it becomes a float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "263e8d90-42fe-463a-8efd-9ecc3f181931",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2\n",
    "b = 2.0\n",
    "\n",
    "print(type(a))\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccdd115f-ee14-456a-af2a-09cd42d8366e",
   "metadata": {},
   "source": [
    "The `int()` function converts a string or float to int."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "abff422e-30e3-40d0-bcb4-0f6bbbca0746",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = 4.0\n",
    "\n",
    "b = int(a)\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f5525ff-4142-4993-b7a5-3a7fa324ad52",
   "metadata": {},
   "source": [
    "[Documentation for the int() function](https://docs.python.org/3/library/functions.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc89b197-37c5-43b4-ab41-611925e4b292",
   "metadata": {},
   "source": [
    "[Full list of built in Python functions](https://docs.python.org/3/library/functions.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f53cefb2-5a35-46cb-8ee1-0d98e90a4e6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(2.0))\n",
    "print(type(int(2.0)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1375e850-f1a3-40a1-8c2a-c766f3d6062a",
   "metadata": {},
   "source": [
    "The `int()` function truncates and **does not** round floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89ec1c98-e7f5-4936-8216-4daf152eff3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = int(2.2)\n",
    "b = int(2.5)\n",
    "c = int(2.8)\n",
    "\n",
    "print(int(a))\n",
    "print(int(b))\n",
    "print(int(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1ed1f2d8-527d-40fb-9108-4287fced091a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2 4 4 6\n"
     ]
    }
   ],
   "source": [
    "a = int(round(2.2))\n",
    "b = int(round(2.5))\n",
    "c = int(round(3.5))\n",
    "d = int(round(4.5))\n",
    "e = int(round(5.5))\n",
    "\n",
    "print(a, b, c, d, e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b69ad4a1-fee0-4f97-bad5-5ef94231c732",
   "metadata": {},
   "source": [
    "The round functions rounds in surprising and seemingly inconmsistent ways.  \n",
    "Click the link to learn more about [Floating Point Arithmetic: Issues and Limitations:](https://docs.python.org/3/tutorial/floatingpoint.html#tut-fp-issues)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae2347f0-b7b8-42f5-94b7-128a30082a53",
   "metadata": {},
   "source": [
    "# Float"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9944767-ceab-432a-96f1-226aca6a3626",
   "metadata": {},
   "source": [
    "**Float** - floating point numbers (float), are positive and negative real numbers with a fractional part denoted by the decimal symbol . or the scientific notation E or e, e.g. 1234.56, 3.142, -1.55, 0.23."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a2e21541-6e22-4554-9d9d-9cbebfebef3d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(1234.56))\n",
    "print(type(-32.54))\n",
    "print(type(2/4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e94f0a80-2542-4490-975e-3062115ee8ff",
   "metadata": {},
   "source": [
    "The maximum size of a float depends on your system. The float beyond its maximum size referred as \"inf\", \"Inf\", \"INFINITY\", or \"infinity\".   \n",
    "Float 2e400 will be considered as infinity for most systems.   \n",
    "e means `X10**N`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40e425c7-37f6-4d94-aab2-390142f7602d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2e400\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aead588e-db97-47be-899d-43ec919cabbd",
   "metadata": {},
   "source": [
    "Scientific notation is used as a short representation to express floats having many digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7325892-3444-4080-a869-5f35b9348969",
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(4e2)\n",
    "#print(10e3)\n",
    "#print(10e-1)\n",
    "#print(3.4556789e2)\n",
    "#print(4.2e9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af1afec5-3f61-48d8-a9f7-e9da8eee4d12",
   "metadata": {},
   "source": [
    "Use the `float()` function to convert an int or a string, to a float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed2fc297-38b7-435e-abd3-e86187be3483",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(float(\"5.5\"))\n",
    "print(type(float(\"5.5\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "229700b1-4f6e-4cb5-b46f-723edef3af68",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(float(5))\n",
    "print(type(float(5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6034eca9-6a35-4f36-9ff6-330d4b4f9f8b",
   "metadata": {},
   "source": [
    "# String"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07349998-e6fb-4e92-9479-4e8d0816fe5c",
   "metadata": {},
   "source": [
    "**String** - a collection of alphabets, words or other characters. It is one of the primitive data structures and are the building blocks for data manipulation. Python has a built-in string class named str . Python strings are \"immutable\" which means they cannot be changed after they are created"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70b6b040-ccd2-42da-a85e-edc2d2b8016f",
   "metadata": {},
   "source": [
    "The followings are valid string literals in Python. \n",
    "Multi-line strings must be embed in triple quotes, as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fed59bd8-8aa4-4edc-b401-dd3fb1b9c715",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type('Hello everybody!'))\n",
    "print(type(\"Hi doctor Nick!\"))\n",
    "\n",
    "\n",
    "#print('''Every night father fill me with dread\n",
    "#         When he sits at the foot of my bed''')\n",
    "#print(\"\"\"I don't mind that he speaks, that he gibbers and squeaks\n",
    "#         But for seventeen years he's been dead\"\"\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f814fc9f-8a30-4764-b388-6435618f68c2",
   "metadata": {},
   "source": [
    "If a string literal required to embed double quotes as part of a string then, it should be put in single quotes. Likewise, if a string includes a single quote as a part of a string then, it should be written in double quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f25ae1b9-5dde-427b-94c8-039e60de4588",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hamlet asked \"To be or not to be?\" while procrastinating a homicide.')\n",
    "print(\"Don't stop believing.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e23fd740-a885-44af-b489-b43e62f6efe4",
   "metadata": {},
   "source": [
    "The escape character is used to invoke an alternative implementation of the subsequent character in a sequence. In Python, backslash \\ is used as an escape character. Use a backslash character followed by the character you want to insert in a string e.g. \\' to include a quote, or \\\" to include a double quotes in a string, as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b264efa1-0118-42f6-b136-607c8009bb25",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Don\\'t stop believing')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5097a36a-0f03-4062-a99a-9beb512be1d8",
   "metadata": {},
   "source": [
    "Use the `str()` function to convert a number to a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e0c6da5-67de-4634-9212-f9a766915059",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5)\n",
    "print(str(5))\n",
    "print(type(str(5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e03b81b9-8dd2-4221-936d-45eea38d66a4",
   "metadata": {},
   "source": [
    "Use the len() function to retrieve the length of a string, as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "642618eb-9e87-4c14-bebf-725478b4f2b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"Ham Sandwich\"\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "691745b3-0262-4741-8789-38a842d28673",
   "metadata": {},
   "source": [
    "# **Indexing Strings**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a421884-9851-4ebd-a275-a4ae7a3721c3",
   "metadata": {},
   "source": [
    "A string is a squence in python, ie an ordered collection of characters.  \n",
    "The sequence uses an index, **starting with zero** to fetch a certain item (a character in case of a string) from it.  \n",
    "You can index a variable using **brackets** to select any segment or slice of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06ac18bb-1e8b-43aa-bebd-f4fe46f0c983",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"Ham Sandwich\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f11f5f83-245e-4cf1-867d-ff6ddc516af5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S\n",
      "Sandwich\n",
      "Sandwich\n",
      "wich\n",
      "HmSnwc\n"
     ]
    }
   ],
   "source": [
    "print(a[4])\n",
    "print(a[4:12])\n",
    "print(a[4:])\n",
    "print(a[-4:])\n",
    "print(a[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aff8b69-9ff6-4438-b125-f55d53716f89",
   "metadata": {},
   "source": [
    "The string is an immutable object.   \n",
    "Hence, it is not possible to modify it.   \n",
    "The attempt to assign different characters at a certain index results in errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d007e750-50f6-4f01-87de-3d3cddf1def1",
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0] = \"B\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e20c0db8-f3f9-4616-aad0-3cee9829594a",
   "metadata": {},
   "source": [
    "**String Operators**  \n",
    "`+` Appends the second string to the first, concat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e73583f-97eb-4d7e-a7cc-4f3e315b85a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"Hello\"\n",
    "b = \"World\"\n",
    "\n",
    "print(a + b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35672e10-61f2-4698-acec-36332b1cc518",
   "metadata": {},
   "source": [
    "`*` Concatenates multiple copies of the same string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43e7fc78-50e4-44d5-8fb8-6921e2c3dc8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b0d0fe6-edbb-4610-9280-3b94cc3c390e",
   "metadata": {},
   "source": [
    "`is` or `==` returns true if both variables are the same object  \n",
    "`is not` or `!=` returns true if both variables are not the same object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "58a82310-b1fd-48c1-a118-5ae29f24e645",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 'Ham'\n",
    "b = 'Cheese'\n",
    "c = 'Bread'\n",
    "d = 'Ham'\n",
    "\n",
    "print(a is a)\n",
    "print(a is d)\n",
    "print(a == a)\n",
    "print(a is not b)\n",
    "print(a is not d)\n",
    "print(a != b)\n",
    "\n",
    "# When using less-than or greather-than on strings, Python will compare the lenght of the strings\n",
    "print(a<b)\n",
    "\n",
    "# As soon as you add an equal sign (<= or >=), now you're asking Python to see if the string is equal to the other string\n",
    "# (cat >= dog) will return false because cat doest not equal dog even though they have the same number of characters.\n",
    "\n",
    "print(a >= b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "423acf92-3ecf-4877-bd55-42bfae24237e",
   "metadata": {},
   "source": [
    "`[]` Returns the character at the given index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "05732373-7e11-49ec-b01a-e68f5425734d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# When using inequalities to compare strings, Python will look at the first character of the strings \n",
    "# and assign it a number based off of the character's position in the alphabet.\n",
    "# Python will use their alphabetical position for the string comparison. \n",
    "\n",
    "a = 'Ham'\n",
    "b = 'Cheese'\n",
    "c = 'Bread'\n",
    "d = 'Ham'\n",
    "e = 'Voice'\n",
    "\n",
    "print( a > b) # It's true because 'H' is the 8th character while 'C' is the 3rd character\n",
    "print( e < c) # It's false because 'V' comes later within the alphabet and has a higher position number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4427f36-ad64-454c-a7cb-14c5219dbbc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bde48664-aab9-4d1d-a714-8a1a8da08003",
   "metadata": {},
   "source": [
    "`in` Returns true if a character exists in the given string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0711ad29-cc9a-45c0-bb25-b681070bfc13",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"x\" in a)\n",
    "print(\"H\" in a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6ccd501-9f04-4357-a209-47b70fd02dc2",
   "metadata": {},
   "source": [
    "`not in` Returns true if a character does not exist in the given string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7f2a4cc-c606-4fc5-8e99-a502fdf20a1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"x\" not in a)\n",
    "print(\"H\" not in a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78f77fba-6f9d-4036-8377-9a1a39f81fa3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#a.upper(a)\n",
    "#a.startswith(\"Delicious\")\n",
    "e = d.replace(\"Ham\",\"Turkey\")\n",
    "e"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdb0de1f-a651-4147-9e77-5fdb2aac66ae",
   "metadata": {},
   "source": [
    "#### 2.2 Indexing Operator, Square brackets [] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f69e9f4f-321d-4742-8d1a-001726978a70",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The indexing operator (Python uses square brackets to enclose the index) \n",
    "# selects a single character from a string. The characters are accessed by their \n",
    "# position or index value. For example, in the string shown below\n",
    "\n",
    "a = \"Delicious Ham Sandwich\"\n",
    "\n",
    "\n",
    "#b = a[3]\n",
    "#b = a[10:13]\n",
    "#b = a[:13]\n",
    "#b = a[10:]\n",
    "b = a[:]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f3bfa14-43b2-46a5-9613-90c7d52e5416",
   "metadata": {},
   "source": [
    "**Bool** - Data composed of two built-in values `True` or `False`.  \n",
    "Notice that 'T' and 'F' are capital.   \n",
    "`true` and `false` are not valid booleans and Python will throw an error for them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6710d638-313c-49b1-8603-afb97ceb0f5c",
   "metadata": {},
   "source": [
    "When you compare two values, the expression is evaluated and Python returns the Boolean answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19e31352-eca0-4093-91e0-e730c870dcef",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5 > 3)\n",
    "print(5 < 3)\n",
    "print(5 == 3)\n",
    "print(5 >= 3)\n",
    "print(5 <= 3)\n",
    "print(5 != 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3fbf458-e1b4-4ac9-ae8e-cefb9e3c801e",
   "metadata": {},
   "source": [
    "The `bool()` function allows you to evaluate any value, and give you True or False in return,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7de725c0-a73d-49fe-90f2-c7594de555b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(bool(15))\n",
    "print(bool(-15))\n",
    "print(bool(0))\n",
    "print(bool(\"Ham\"))\n",
    "print(bool(\"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "540dbeab-74ed-4f7c-8818-70dfbca32b02",
   "metadata": {},
   "source": [
    "The `True` bool evaluates as one and the `False` bool evaluates to zero allowing for some weird math. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a21b2db2-baca-4a4c-be5c-2f9d39b755b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(True * 10 - False)\n",
    "print(True * False + 13)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01dfb4e6-106a-48df-afd1-7eaff7946ead",
   "metadata": {},
   "source": [
    "**None** is returned by functions that don't explicitly return a value.\n",
    "None: The None represents the null object in Python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55d32e40-3978-478a-93b7-9b544c49528d",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1 > None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66ddf3f4-58b0-4f04-a80d-17e4715ad9e8",
   "metadata": {},
   "source": [
    "#### 1.0 Simple Calculations Using integers "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb50ed1b-f3a5-4d71-93c5-3ad55c770f50",
   "metadata": {},
   "source": [
    "The console acts as a simple calculator. You can create expressions as command lines and the console will return the values. Expression syntax includes the operators, numbers, and parentheses that can be used for simple grouping. Grouping numeric data types is done with parentheses ()."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "109b3f96-66cc-4b30-a5bf-43d8698d6c8e",
   "metadata": {},
   "source": [
    "#### 1.1 Basic Calculations and Calculations with Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86a1e671-5365-43a1-9056-660c23457fdb",
   "metadata": {},
   "source": [
    "- Addition + \n",
    "- Subtraction -  \n",
    "- Multiplication  *\n",
    "- Exponent **  \n",
    "- Division /  \n",
    "- Floor Divison //\n",
    "- Modulo Division %"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd27b87c-4357-4f9d-bfec-e57144900836",
   "metadata": {},
   "outputs": [],
   "source": [
    "(2+3002)/5**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4285e21c-e812-40c9-87a5-d5b2d8989f3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "6*5*4*3*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e2f7094-adb5-4f6c-b947-28309dc3c0c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Defining a Variable\n",
    "\n",
    "x=10\n",
    "y=9\n",
    "z=8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd4a9468-4cdf-492c-acf7-0984a01e5b3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Addition\n",
    "print ((x+y)/z+100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e68caa7-1ae4-4cf9-85f6-50fe573a49b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subtraction\n",
    "print (x-y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b733514-9d5b-4d7a-85be-cccbe443b749",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplication\n",
    "print (x*y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a63befb-5d3b-44dd-bb70-25f3415cd50b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Division, always results in float\n",
    "\n",
    "#print (x/y)\n",
    "# type(x/y)\n",
    "\n",
    "a = 9/3\n",
    "a\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2297c59-bede-4091-9523-1692c7d5bc0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Floor Division - a normal division operation except that it returns \n",
    "# the largest possible integer. \n",
    "# This integer is either less than or equal to the normal division result.\n",
    "print (x//y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "827d7fe6-40b5-4ac0-962b-485587458574",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modulo Division \n",
    "# It returns the remainder of dividing the left hand operand by right hand operand. \n",
    "# It's used to get the remainder of a division problem.\n",
    "#print (x%y)\n",
    "\n",
    "print(44%2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "127e5d98-0641-44ed-bc7b-812607fd2a7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exponent\n",
    "print (x**y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8924c061-3971-413d-b514-7e270a39fcd1",
   "metadata": {},
   "source": [
    "#### 1.2 Logic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b07fd7ce-df47-4e73-87ea-0b6e79ae30ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "print (6 >= 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df18b0d2-667f-4b41-a67e-008db1d69d8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print (5 > 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec454c43-6784-4afb-b758-4e15d9a9b65d",
   "metadata": {},
   "outputs": [],
   "source": [
    "print (6=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01738643-5f45-4ed2-9b3e-416a9a388c57",
   "metadata": {},
   "source": [
    "#### 1.3 Type() and Dir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de2d93cf-491d-4c84-b2e1-59ecaf47257a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# What is the data type of the output?\n",
    "print (x*y/z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff05b027-e7b1-441e-abcb-2bb0901a1538",
   "metadata": {},
   "outputs": [],
   "source": [
    "#type(x)\n",
    "#print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e245efdf-75b1-4045-a242-18d75c2ee88b",
   "metadata": {},
   "outputs": [],
   "source": [
    " a = \"Ham\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74a5fea2-a63c-422f-b838-08bbfd99acd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "type (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16eb42a8-5d50-408e-b4c1-85e7fb463962",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 2 +5j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aaac6fcc-a976-4ef8-b108-76ac2eb0cf84",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(b)\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b03dde68-c599-49c7-a59a-da5b722ee52f",
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dd92cb5-beea-4529-a383-540b444dfa9c",
   "metadata": {},
   "source": [
    "# Total Aside, but super cool so you must know"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f12c9834-67b7-42e4-97c4-88cf21d785e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5a63858-38c4-4410-848d-f8c37dbb09b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ce61163-43ee-4612-b940-bc3a3790eefd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f10e7814-e74c-44a6-9efc-2b3843525891",
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(pandas)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e464a49a-8a1a-441b-a645-5d8a1ed0feaa",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8654eae5-4fb7-462d-94b9-f6c558b12537",
   "metadata": {},
   "source": [
    "**Tuples** are used to store multiple items in a single variable.\n",
    "\n",
    "Tuple is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Set, and Dictionary, all with different qualities and usage.\n",
    "\n",
    "A tuple is a collection which is ordered and immutable.\n",
    "\n",
    "A sequence of data surrounded py parenthesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "0c8dceb5-c2af-4675-b0ac-b54ba694151b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tuple, tuple)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (1,3,5,6,9)\n",
    "t2 = (\"Ham\", \"Turkey\", \"Roast Beef\")\n",
    "type(t), type(t2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74c0854d-64a9-4c7a-96f8-3eeb1b669bcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "You can iterate over a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "fddfc6e9-2343-4746-99c0-f49c5c53c28f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "Turkey\n"
     ]
    }
   ],
   "source": [
    "print(t[0])\n",
    "print(t2[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "151fb66a-2da3-4544-a789-16f402beb2e4",
   "metadata": {},
   "source": [
    "You can use the `len()` function to display the number of elements in a tuple. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0360ccb9-d918-4d0b-82de-c14f2ddde504",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(t))\n",
    "print(len(t2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b573030-7dcc-4987-bbcc-2b5ccf9dbec6",
   "metadata": {},
   "source": [
    "Tuples are not associated with a whole lot of methods and are pretty light on the memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dd9d0ee-d9db-4539-8308-052eefc4b13c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#dir(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a577da4-27bc-495d-916e-ce3c177f45c5",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbd6cddf-6521-413a-8f69-8ee89012e8cc",
   "metadata": {},
   "source": [
    "#### 3.1 Intro"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3785d666-4a38-4416-bc96-a65e1dbe8d67",
   "metadata": {},
   "source": [
    "Lists are used to store multiple items in a single variable.\n",
    "\n",
    "Lists are one of 4 built-in data types in Python used to store collections of data, the other 3 are Tuple, Set, and Dictionary, all with different qualities and usage.\n",
    "\n",
    "Lists are created using square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dca3264-cc5c-42b5-b0fd-382053eea375",
   "metadata": {},
   "outputs": [],
   "source": [
    "#lst1 = [\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\"]\n",
    "#lst2 = [a,b,c,d,e,f,g]\n",
    "#lst3 = [1,2,3,4,5,6,7]\n",
    "#lst4 = [1,\"b\",3,\"d\",5,\"f\",7]\n",
    "#lst5 = [\"1\",\"b\",\"3\",\"d\",\"5\",\"f\",\"7\"]\n",
    "#lst6 = [[1,2],[3,4],[5,6,7,8]] \n",
    "#lst7 = [[\"a\",\"b\"],[3,4],[\"e\",\"f\"]]\n",
    "\n",
    "# print(lst7)\n",
    "# print(type(lst3))\n",
    "# print(lst7[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cc270d0-080b-4636-82c3-1b76564848bb",
   "metadata": {},
   "source": [
    "#### 3.2 Split String"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32789f10-95d7-44cc-b4ea-d0c29e370e2b",
   "metadata": {},
   "source": [
    "The split() method splits a string into a list. You can specify the separator, default separator is any whitespace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84cc3780-e048-40b9-b398-f60dc2911c0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"Delicious\"\n",
    "b = \"Ham\"\n",
    "c = \"Sandwich\"\n",
    "d = a + \"&\" + b + \"&\" + c\n",
    "\n",
    "\n",
    "lst = d.split(\"&\")\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef192771-7554-482d-b2b4-334a5a4e4921",
   "metadata": {},
   "source": [
    "#### 3.3 Input String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91954281-f5b9-45d1-8a04-274b6bd45c65",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = input()\n",
    "#a = int(input())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "596eabe2-d45e-4869-b036-c18faf4d1f77",
   "metadata": {},
   "outputs": [],
   "source": [
    "a\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6f33dd3-5d11-43a7-b1ed-9a60f442640b",
   "metadata": {},
   "source": [
    "# 4.0 Problems"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b74effa-106a-4078-9358-4b67c91162c2",
   "metadata": {},
   "source": [
    "1. Write a program that converts degrees Celcius to Degrees Fahrenheit  \n",
    "Hint: (Degrees Celcius × 9/5) + 32 = Degrees Fahrenheit  \n",
    "Degrees Celcius: 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c998946-7cec-4e44-b1a0-88094ba10526",
   "metadata": {},
   "source": [
    "2. Combine the following strings into the quote \"Do or do not. There is no try.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "7162d587-0b34-4bcc-9edf-97e808ef05b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Do or do not. There is no try.\n"
     ]
    }
   ],
   "source": [
    "a = \"is no try.\"\n",
    "b = \"Do or do not.\"\n",
    "c = \"There\"\n",
    "\n",
    "print(b,c,a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8de60798-e222-4bc5-a8d5-e94213d0c293",
   "metadata": {},
   "source": [
    "3. Write a Python program to calculate the area of a triangle  \n",
    "Hint: Area of Triangle = (Base * Height)/2  \n",
    "Height : 5  \n",
    "Base: 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ce6587c1-f634-4150-a4f6-41655326427a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.5\n"
     ]
    }
   ],
   "source": [
    "#3 Answer:\n",
    "\n",
    "height = 5\n",
    "base = 5\n",
    "area_triangle = .5*base*height\n",
    "\n",
    "print(area_triangle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf6fab58-448d-41e8-955e-8392a92b985d",
   "metadata": {},
   "source": [
    "4. Write a program that adds NYC sales tax to a purchase  \n",
    "Hint: NYC Sales Tax = 8.875%  \n",
    "Purchase: $234"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "dac46371-f80a-4765-ac40-5e0bfce9bd65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "254.76749999999998\n"
     ]
    }
   ],
   "source": [
    "#4 Answer: \n",
    "\n",
    "subtotal = 234\n",
    "tax = 8.875\n",
    "total = subtotal + (subtotal * (tax / 100))\n",
    "\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3228f86-6cb0-45df-b6f3-1ef12a53a238",
   "metadata": {},
   "outputs": [],
   "source": [
    "quote1 = \"\"\"In '87, Huey released this, Fore, their most accomplished album. I think their undisputed masterpiece is \"Hip to be Square\", a song so catchy, most people probably don't listen to the lyrics. But they should, because it's not just about the pleasures of conformity, and the importance of trends, it's also a personal statement about the band itself.\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e400a3a8-6336-42e8-a162-ac9c34c4eb0d",
   "metadata": {},
   "source": [
    "5. Using the speech above reurn only the second sentence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57504bc7-ec6a-4c54-8444-f1c1a07cea16",
   "metadata": {},
   "outputs": [],
   "source": [
    "quote2 = \"Any fool can write code that a computer can understand. Good programmers write code that humans can understand.\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "693a5d09-41d1-4d66-b727-02353767bd7f",
   "metadata": {},
   "source": [
    "6. Split the above string into a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15e5ad9e-5f67-4ca8-9e73-1106c5a0c8c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "quote3 = \"Code is like humor. When you have to explain it, it’s bad.\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7824b21b-1949-483d-a6df-c5d266c1b2bf",
   "metadata": {},
   "source": [
    "7. Using the quote above, return every third word in the quote."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "739fa9f8-c51a-4abc-a644-6d43c2fb1f2c",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}