Module_0_Basic_Python_Programming/01_Python_Basics_Syntax.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Introduction to Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a general-purpose and high-level object-oriented, interpreted, and interactive programming language. It is consistenly ranked among the top programming languages in the world. In Stackoverflow's 2020 survey, out of **57,378** respondents, Python ranked 4th in the most popular programming languages category.\n",
    "\n",
    "<img width=700 src=\"./img/python ranking.png\" />\n",
    "\n",
    "Python was created and released in 1991 by Guido Van Rossum. The language was designed with readability in mind--the syntax heavily uses English words. In fact, Python's syntax guidelines are encapsulated in the following line in the Zen of Python. \n",
    "> There should be one-- and preferably only one --obvious way to do it  \n",
    "\n",
    "The Zen of Python is a collection of guiding principles when coding in Python.\n",
    "\n",
    "**The Zen of Python**\n",
    "```\n",
    "Beautiful is better than ugly.\n",
    "Explicit is better than implicit.\n",
    "Simple is better than complex.\n",
    "Complex is better than complicated.\n",
    "Flat is better than nested.\n",
    "Sparse is better than dense.\n",
    "Readability counts.\n",
    "Special cases aren't special enough to break the rules.\n",
    "Although practicality beats purity.\n",
    "Errors should never pass silently.\n",
    "Unless explicitly silenced.\n",
    "In the face of ambiguity, refuse the temptation to guess.\n",
    "There should be one-- and preferably only one --obvious way to do it.\n",
    "Although that way may not be obvious at first unless you're Dutch.\n",
    "Now is better than never.\n",
    "Although never is often better than *right* now.\n",
    "If the implementation is hard to explain, it's a bad idea.\n",
    "If the implementation is easy to explain, it may be a good idea.\n",
    "Namespaces are one honking great idea -- let's do more of those!\n",
    "```\n",
    "\n",
    "Python was made for ease of use and has since become an essential tool for different kinds of people: programmers, engineers, researchers, and data scientists across academia and industry. The reason why it's widely used is because of its large ecosystem and the availability of domain-specific libraries that have been built using it. It can do so much that you can practically do almost any computer-related tasks such as creating web applications, desktop applications, video games, robots, and also doing data analysis. \n",
    "\n",
    "Since this is a data science short course, you are probably interested in language's capability of 'making sense' of the dataset that you are working with. Python has libraries for different tasks in this space: automating tasks, scraping datasets, cleaning those datasets, and even modeling using statistical, mathematical, and rule-based methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Basic Python Syntax\n",
    "\n",
    "**Indentation**\n",
    "\n",
    "Unlike other programming languages, Python does not need braces to indicate blocks of code. Instead, they are denoted by indentation (tabs/spaces). An indentation has to have at least 4 spaces or 1 tab. Please ensure that the code in the same block have the same number of tabs/spaces (1 tab = 4 spaces). For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 12 :) \n"
     ]
    }
   ],
   "source": [
    "a = 12\n",
    "if a == 12:\n",
    "    print(\"a is 12 :) \")\n",
    "else:\n",
    "    print(\"a is not 12 :( \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 12 :) \n",
      "hey\n"
     ]
    }
   ],
   "source": [
    "a = 12\n",
    "if a == 12:\n",
    "    print(\"a is 12 :) \") # this uses 4 spaces\n",
    "    print(\"hey\") # this uses a tab, this is possible but not recommended\n",
    "else:\n",
    "    print (\"a is not 12 :( \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we don't follow the rules for indentation, this will happen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-3-403d004eab8c>, line 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-3-403d004eab8c>\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m    print (\"a is not 12 :( \")\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "a = 12\n",
    "if a == 12:\n",
    "    print(\"a is 12 :) \")\n",
    "else:\n",
    "print (\"a is not 12 :( \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-4-5ea561accda9>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-4-5ea561accda9>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    print(\"hey\") # this uses 2 tabs, indentation mismatch\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "a = 12\n",
    "if a == 12:\n",
    "    print(\"a is 12 :) \") # this uses 4 spaces\n",
    "        print(\"hey\") # this uses 2 tabs, indentation mismatch\n",
    "else:\n",
    "    print (\"a is not 12 :( \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Multi-line Statements**\n",
    "\n",
    "Statements in Python usually ends with a new line ( \\n ). However, Python allows the use of the line continuation character ( \\ ) to denote that the line should continue. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "EOL while scanning string literal (<ipython-input-5-c61beeff2813>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-5-c61beeff2813>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    a = \"Hello\u001b[0m\n\u001b[0m               ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m EOL while scanning string literal\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello \n",
    "World\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello \\\n",
    "World\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way of joining statements is by putting the strings or variables within the brackets ( ), { }, [ ] without using the line continuation character. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'threefour', 'five']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = ['one', 'two', 'three'\n",
    "       'four', 'five']\n",
    "num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quotations**\n",
    "\n",
    "Strings are generally created by using single ( ' ) or double quotes ( \" ). This all means the same in Python. If we want a a string to span multiple lines, we use triple ( ''' or \"\"\" ) quotes. Note that the start quote and end quote should be of same type. Consider following examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DSI\n",
      "De La Salle University\n",
      "Lorem ipsum dolor sit amet, consectetur adipiscing elit, \n",
      "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. \n",
      "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris \n",
      "nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in \n",
      "reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. \n",
      "Excepteur sint occaecat cupidatat non proident, sunt in culpa qui \n",
      "officia deserunt mollit anim id est laborum.\n"
     ]
    }
   ],
   "source": [
    "name = 'DSI'\n",
    "school = \"De La Salle University\"\n",
    "text = '''Lorem ipsum dolor sit amet, consectetur adipiscing elit, \n",
    "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. \n",
    "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris \n",
    "nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in \n",
    "reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. \n",
    "Excepteur sint occaecat cupidatat non proident, sunt in culpa qui \n",
    "officia deserunt mollit anim id est laborum.'''\n",
    "\n",
    "print(name)\n",
    "print(school)\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comments**\n",
    "\n",
    "Comments are the statements that are not evaluated by the Python interpreter. It is generally used for readability purposes. You can use this to explain what your code does. Here are 3 ways of doing it:\n",
    "\n",
    "- Block Comments - generally apply to some (or all) code that follows them, and are indented to the same level as that code. Each line of a block comment starts with a # and a single space. Paragraphs inside a block comment are separated by a line containing a single #."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I wont be evaluated\n",
    "a = 12\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Inline Comments - an inline comment is a comment beside a statement. The standard is that inline comments have to be separated by at least two spaces from the statement. Similar to the previous example, the comments should start with a # and a single space. Only use inline comments if they are adding some clarity on the statement and not just stating the obvious."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 100  # Setting x to 100 (this is unnecessary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Docstrings**\n",
    "\n",
    "Docstrings are documentation on what a specific function does.\n",
    "Ideally, a docstring should be made for every function that you write.\n",
    "Docstrings are written between a triple quote (\"\"\" ...< docstring >...\"\"\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func():\n",
    "    \"\"\"\n",
    "    This function will\n",
    "    perform .....\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Fun Fact: docstrings are printed when you type `< function_name >?` *(on a separate UI)* or `< function_name >.__doc__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mmy_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "This function will\n",
       "perform .....\n",
       "\u001b[0;31mFile:\u001b[0m      ~/devel/dlsu/dsi/foundations-of-data-science/Module_0_Basic_Python_Programming/<ipython-input-11-92c0ed9284d1>\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_func?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n    This function will\\n    perform .....\\n    '"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Data Types**\n",
    "\n",
    "Python has following 6 built-in Data-Types:\n",
    "\n",
    "|Type|Description|Example|\n",
    "|---|---|---|\n",
    "|int|Integer values|123|\n",
    "|float|Floating point values|10.12|\n",
    "|complex|Complex values|1 + 3j|\n",
    "|bool|Boolean values|True|\n",
    "|str|String values|\"Hello\"|\n",
    "|NoneType|None value|None|\n",
    "\n",
    "**Data Structures**\n",
    "\n",
    "and 4 data structures:\n",
    "\n",
    "|Type|Description|Example|\n",
    "|---|---|---|\n",
    "|list|Ordered collection of values|[1, 'abc', 3, 1]|\n",
    "|set|Unordered collection of unique values|{1, 'abc', 3}|\n",
    "|tuple|Immutable Ordered collection|(1, 'abc', 3)|\n",
    "|dict|Unordered key. value pairs|{'abc': 1, 'def': 2}|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Variable**\n",
    "\n",
    "A variable is simply something that can store values. The Python interpreter allocates a memory for a variable wherein it stores a value of any data type and it does that on the fly. This is illustrated by the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "53\n",
      "52\n",
      "51\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "a = None\n",
    "print(sys.getsizeof(a))\n",
    "a = \"heyy\"\n",
    "print(sys.getsizeof(a))\n",
    "a = \"hey\"\n",
    "print(sys.getsizeof(a))\n",
    "a = \"hi\"\n",
    "print(sys.getsizeof(a))\n",
    "a = \"0\"\n",
    "print(sys.getsizeof(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As implied by its name, a variable is something that can change. You can see that both the value and the memory allocated to the variable changes. \n",
    "\n",
    "**Naming variables**\n",
    "\n",
    "The start of the character can be an underscore `_` or a capital or lowercase letter. However, it is generally recommended to use all uppercase for global variables and all lower case for local variables. Then, the letters following the first letter can be a digit or a string. Python is a case-sensitive language. Therefore, variable is not equal to VARIABLE or VaRiabLE.\n",
    "\n",
    "```python\n",
    "GLOBAR_VAR = 1\n",
    "local_var = 4\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "**Assigning values to variables**\n",
    "\n",
    "If you have some experience in other programming languages like C, C++ or Java, you might be used to having to explicitly declare the data type of your variable. That's not the case in Python--this is one of the main differences between Python and strongly typed languages like C++ or Java. We may simply name the variable with whatever name we want and its data type will adapt based on the data stored in it as illustrated below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am in DLSU\n"
     ]
    }
   ],
   "source": [
    "var = 'I am in DLSU'\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**var** is a string in the above case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also override the value of the variable with that of another data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = 123\n",
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Reserved keywords**\n",
    "\n",
    "You cannot use the following as variable names in Python as they reserved already:\n",
    "\n",
    "| | | | | |\n",
    "|--------|---------|----------|---------|-----|\n",
    "|and     |del      |from      |not      |while|\n",
    "|as      | elif    |global    |or       |with |\n",
    "|assert  | else    | if       |pass     |yield|\n",
    "|break   | except  | import   |print|\n",
    "|class   | exec    | in       |raise|\n",
    "|continue| finally | is       |return|\n",
    "|def     | for     | lambda   |try|\n",
    "\n",
    "\n",
    "**Multiples**\n",
    "\n",
    "Python also allows the assignment of a single value to several variables simultaneously. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1 1\n",
      "Hello World 1 2\n"
     ]
    }
   ],
   "source": [
    "x = y = z = a = 1\n",
    "print(x,y,z,a)\n",
    "\n",
    "x, y, z, a = 'Hello', 'World', 1, 2\n",
    "print(x,y,z,a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 String\n",
    "\n",
    "To put it simply, string is just text data. Technically, strings are immutable sequence of characters.\n",
    "\n",
    "> Sequences will be futher discussed in Data Structures section later.\n",
    "\n",
    "Python has a built-in string class called `str` that has many useful functionalities in it. When encapsulating a text with either single quotes ( ' ) or double quotes ( \" ), Python automatically knows that it's a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contents of var:  Hello World\n",
      "Type of var:  <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "var = 'Hello World'\n",
    "print(\"Contents of var: \", var)\n",
    "print(\"Type of var: \", type(var))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In strings, the backslash \"\\\" is a special character called the \"escape\" character. It is used to represent certain whitespace characters: \n",
    " - \"\\t\" is a tab, \n",
    " - \"\\n\" is a newline, \n",
    " - and \"\\r\" is a carriage return.\n",
    "\n",
    "If you don't want characters prefaced by \\ to be interpreted as special characters, you can use raw strings by adding an alphabet `r` before the first quote. A very basic example would be something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\n",
      "ame\\of\\dir\n"
     ]
    }
   ],
   "source": [
    "print('''C:\\name\\of\\dir''')  # even using triple quotes won't save you!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\name\\of\\dir\n"
     ]
    }
   ],
   "source": [
    "print(r'C:\\name\\of\\dir')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can perform the following operations on a string in Python:\n",
    "- Concatenation\n",
    "- Indexing\n",
    "- Slicing\n",
    "- Formatting\n",
    "\n",
    "**String Concatenation**\n",
    "\n",
    "Concatenation is simply joining strings together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HelloWorld\n"
     ]
    }
   ],
   "source": [
    "var1 = 'Hello'  # String 1\n",
    "var2 = 'World'  # String 2\n",
    "var3 = var1 + var2  # Concatenate two string as String 3\n",
    "print(var3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HelloWorld\n"
     ]
    }
   ],
   "source": [
    "var1 = 'Hello' 'World'\n",
    "print(var1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you concatenate a variable of another data type, it will result to an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-974e56630dc5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mvar1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Hello'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mvar2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvar1\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mvar2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "var1 = 'Hello'\n",
    "var2 = 1\n",
    "print(var1+var2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**String Indexing**\n",
    "\n",
    "String is a sequence of characters. We can access the elements (characters) by using the `[ ]` syntax. Note that Python uses zero-based indexing--the first character is at location 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1 = 'Python'\n",
    "len(var1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'P'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following will result into an error since we only have 6 elements in our string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-15d4fa01d899>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvar1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "var1[6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are also immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-a207e949a80e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvar1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'J'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "var1[0] = 'J'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also access elements in the reverse order by using negative values instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'P'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[-6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**String Slicing**\n",
    "\n",
    "You can access a subset of a string using the slice syntax `var1[start : end]`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Py'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pytho'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[0:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[0:7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pyth'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Py'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[:-4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var1[:2]+var1[-4:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**String Formatting**\n",
    "\n",
    "There are different ways of formatting a string in Python:\n",
    " - format function\n",
    " - f-Strings\n",
    " \n",
    "Below are some examples for the format function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I have 2 dogs'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I have {} dogs\".format(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I have 2 dogs'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"I have {} dogs\"\n",
    "text.format(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I have 2 dogs'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = \"I have {} dogs\"\n",
    "num = 2\n",
    "text.format(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also change the string to a float or percentage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 20.00 3.140 40.00%'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{} {:.2f} {:.3f} {:.2%}\".format(1, 20, 3.14, 0.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the f-String approach to format a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I have 2 dogs'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"I have {2} dogs\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I have 2.00 dogs'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"I have {2:.2f} dogs\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I have 2.00 dogs'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = 2\n",
    "f\"I have {num:.2f} dogs\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 20.00 3.140 40.00%'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"{1} {20:.2f} {3.14:.3f} {0.4:.2%}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Other built-in String methods**\n",
    "\n",
    "- lower - transforms all the characters in the string into their lowercase versions.\n",
    "- capitalize - the first letter is capitalized.\n",
    "- center - has 2 arguments: length of string and the padding character. This method centers a string based on the length provided and the padding for the new string is the padding character argument passed.\n",
    "- count - counts the occurences of a substring.\n",
    "- endswith - checks if the string ends with the substring passed as argument.\n",
    "- join - joins strings together.\n",
    "- strip - removes trailing whitespaces.\n",
    "- split - splits a string into words based on a separator string.\n",
    "\n",
    "...and more! Please refer to the <a href=\"https://docs.python.org/3/library/stdtypes.html\">Python 3 documentation</a> for all methods for String data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original string: HELLO\n",
      "lower: hello\n",
      "---\n",
      "original string: Python\n",
      "capitalize: Python\n",
      "center with length of 9 and # padding: ##Python#\n",
      "center with length of 10 and @ padding: ##Python#\n",
      "y count: 1\n",
      "endswith 'on'? True\n",
      "endswith 'yes'? False\n",
      "---\n",
      "join using blank space: P y t h o n\n",
      "join using --: P--y--t--h--o--n\n",
      "Before rstrip:   Python     \n",
      "After rstrip: Python\n",
      "Original sentence: How are you?\n",
      "After split: ['How', 'are', 'you?']\n"
     ]
    }
   ],
   "source": [
    "print(\"original string:\", 'HELLO')\n",
    "print(\"lower:\", 'HELLO'.lower())\n",
    "\n",
    "print('---')\n",
    "\n",
    "print(\"original string:\", var1.capitalize())\n",
    "print(\"capitalize:\", var1.capitalize())\n",
    "print(\"center with length of 9 and # padding:\", var1.center(9, '#'))\n",
    "print(\"center with length of 10 and @ padding:\", var1.center(9, '#'))\n",
    "print(\"y count:\", var1.count('y'))\n",
    "print(\"endswith 'on'?\", var1.endswith('on'))\n",
    "print(\"endswith 'yes'?\", var1.endswith('yes'))\n",
    "\n",
    "print('---')\n",
    "\n",
    "sequence = ('P','y','t','h','o','n')\n",
    "print(\"join using blank space:\", ' '.join(sequence))\n",
    "print(\"join using --:\", '--'.join(sequence))\n",
    "\n",
    "var1_padded = \"  Python     \"\n",
    "print('Before rstrip:', var1_padded)\n",
    "print(\"After rstrip:\", var1_padded.strip())\n",
    "\n",
    "words = 'How are you?'\n",
    "print('Original sentence:', words)\n",
    "print('After split:', words.split(' '))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Numeric Data Types\n",
    "\n",
    "Python has 3 built-in numberic data types:\n",
    " - int\n",
    " - float\n",
    " - complex\n",
    " \n",
    "**int**\n",
    " \n",
    "integer is any number that does not contain a decimal point. In Python, there's no precision limit for integers (and floats) unlike other programming languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1329227995784915872903807060280344576"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this will crash on C\n",
    "2 ** 120"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the int constructor to convert a string (assuming that it has a correct format) into int."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('20')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**float**\n",
    "\n",
    "Floating point numbers are numbers with decimal point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the float constructor to convert any integer into float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the exponent notation.  \n",
    "`2e4` = $2 x 10^4.$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20000.0"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2e4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**complex**\n",
    "\n",
    "Complex numbers are the numbers with real and imaginary parts. Similar to int or float, we can use a complex constructor to create a complex number by passing the arguments. In reality, you'll rarely use this data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2+3j)\n"
     ]
    }
   ],
   "source": [
    "c_val = complex(2, 3)\n",
    "print(c_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "3.0\n",
      "(2-3j)\n"
     ]
    }
   ],
   "source": [
    "print(c_val.real)\n",
    "print(c_val.imag)\n",
    "print(c_val.conjugate()) # complex conjugate of c_val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Magnitude of a complex number:\n",
    "\n",
    "$\\sqrt{c.real^2 + c.imag^2}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.605551275463989"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(c_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Operators\n",
    "\n",
    "Operators are used to modify the value of operands. For instance, you have the following equation `2 x 4 = 8`. In this example, `2` and `4` are the operands and multiplication (`x`) is the operator. In Python, we have the following operators:\n",
    " - Arithmetic Operators\n",
    " - Relational (Comparison) Operators\n",
    " - Assignment Operators\n",
    " - Logical Operators\n",
    " - Bitwise Operators\n",
    " - Membership Operators\n",
    " - Identity Operators\n",
    " \n",
    "#### 2.3.1 Arithmetic Operators\n",
    " \n",
    "These are operators for basic arithmetic functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "0\n",
      "4\n",
      "1.0\n",
      "2\n",
      "9\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(2 + 2)  # addition \n",
    "print(2 - 2)  # subtraction \n",
    "print(2 * 2)  # multiplication\n",
    "print(2 / 2)  # division\n",
    "print(5 % 3)  # modulus - remainder\n",
    "print(3 ** 2)  # exponential\n",
    "print(5 // 3)  # floor division - division without remainder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.2 Relational Operators\n",
    " \n",
    "aka Comparison Operators. These are used to compare and identify relationships between operands."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a, b = 10, 10\n",
    "\n",
    "print(a==b)  # Equal to\n",
    "print(a!=b)  # Not equal to\n",
    "print(a>b)  # Greater than\n",
    "print(a<b)  # Less than\n",
    "print(a>=b)  # Greater than or equal to\n",
    "print(a<=b)  # Less than or equal to"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.3 Assignment Operators\n",
    "\n",
    "These are used to assign value to variables.\n",
    "\n",
    "**Equals ( = )**\n",
    "\n",
    "Assign value from the right to the variable on the left "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Add AND ( += )**  \n",
    "**Subtract AND ( -= )**  \n",
    "**Multiply AND ( *= )**  \n",
    "**Divide AND ( /= )**  \n",
    "**Modulus AND ( %= )**  \n",
    "**Exponent AND ( *= )**  \n",
    "**Floor Division AND ( //= )**  \n",
    "\n",
    "These are 2-in-1 operations. They apply the operation on the value and variable and assigns to the variable as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "a += 10  # It is equivalent to a = a + 10\n",
    "a -= 10  # It is equivalent to a = a - 10\n",
    "a *= 10  # It is equivalent to a = a * 10\n",
    "a /= 10  # It is equivalent to a = a / 10\n",
    "a %= 10  # It is equivalent to a = a % 10\n",
    "a **= 10  # It is equivalent to a = a ** 10\n",
    "a //= 10  # It is equivalent to a = a // 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.4 Bitwise Operators\n",
    "\n",
    "I suggest reading up on this topic on your own as this is something that you will rarely do when dealing with most data science tasks.\n",
    "\n",
    "#### 2.3.5 Logical Operators\n",
    "\n",
    "Python supports three logical operators: AND, OR and NOT.\n",
    "\n",
    "**AND ( and )**  \n",
    "If both the operands are true, the condition becomes true.\n",
    "\n",
    "**OR ( or )**  \n",
    "If any of the two operands are true, the condition becomes true.\n",
    "\n",
    "**NOT (not)**  \n",
    "Reverses the logical state of the operand. If true, it will become false and vice-versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True to False\n"
     ]
    }
   ],
   "source": [
    "c, d = True, False\n",
    "print(c and d)\n",
    "print(c or d)\n",
    "print(f'{c} to {not c}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.6 Membership Operators\n",
    "\n",
    "Checks if a value is inside a sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('P', 'y', 't', 'h', 'o', 'n')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'P' in sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'0' not in sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3.7 Identity Operators\n",
    "\n",
    "Checks if both operands are the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c == d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c is d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c != d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c is not d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Control Flow\n",
    "\n",
    "In programming, there are times when we want to run a specific section of code until it satisfies a specific condition. We use control flows for that, and like all programming languages, Python has the following commands for controlling the flow of program:\n",
    " - Conditional Statements: if, elif, else\n",
    " - Loop Statements: for, while\n",
    " - Loop Control Statements: break, continue, pass\n",
    " \n",
    "#### 2.4.1 Conditional Statements\n",
    "\n",
    "This is your usual if-else in other programming languages. What happens here is:\n",
    " - the code checks if the statement in the `if` part is true. If it is, execute the code under this block and end the whole if-else block.\n",
    " - if it is not true, it checks if the `elif` part is true. If it is, execute the code under this block and end the whole if-else block. `elif` is the equivalent of else if in other languages. `elif`s are the conditional statements in between `if` and `else`.\n",
    " - if none of the conditions passed applied to all the `if` and `elif`s, it will execute the code under this block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yay!\n"
     ]
    }
   ],
   "source": [
    "result = 1\n",
    "if result == 1:\n",
    "    print(\"Yay!\")\n",
    "elif result <= 3:\n",
    "    print(\"You're so close!\")\n",
    "else:\n",
    "    print(\"Alas! You got it wrong!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.2 Loop Statements\n",
    "\n",
    "When we want to run something multiple times, we use this. Python has 2 types of loops: `for` loop and `while` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in [0,1,2]:\n",
    "    print(f\"{i}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "i = 2\n",
    "while i >= 0:\n",
    "    print(f\"{i}\")\n",
    "    i -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We typically use the keyword `range` when dealing with loops. `range` creates a sequence of numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 8)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(f\"{i}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.3 Loop Control Statements\n",
    "\n",
    "They change the execution of loop from its intended sequence.\n",
    "\n",
    "**Break**\n",
    "\n",
    "This immediately stops the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Condition satisfied\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 10):\n",
    "    if i == 3:\n",
    "        print('Condition satisfied')\n",
    "        break\n",
    "    print(i)  # What would happen if this is placed before if condition?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Continue**\n",
    "\n",
    "Continue statement immediately stops the current iteration of the loop and proceeds to the next iteration of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Condition satisfied\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 5):\n",
    "    if i == 3:\n",
    "        print('Condition satisfied')\n",
    "        continue\n",
    "        print(\"whatever.. I won't get printed anyways.\")\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pass**\n",
    "\n",
    "Performs null operation--does nothing. It is generally used as a temporary placeholder for an unimplemented logic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Condition satisfied\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 5):\n",
    "    if i == 3:\n",
    "        print('Condition satisfied')\n",
    "        pass\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 Data Structures\n",
    "\n",
    "Earlier, data structures were briefly introduced. Once again, Python has the following data structures:\n",
    "\n",
    "|Type|Description|Example|\n",
    "|---|---|---|\n",
    "|list|Ordered collection of values|[1, 'abc', 3, 1]|\n",
    "|set|Unordered collection of unique values|{1, 'abc', 3}|\n",
    "|tuple|Immutable Ordered collection|(1, 'abc', 3)|\n",
    "|dict|Unordered key. value pairs|{'abc': 1, 'def': 2}|\n",
    "\n",
    "#### 2.5.1 Lists\n",
    "\n",
    "In Python, a list is a container for values of any data types. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jude', 'Sash', 'Unisse', 1, True, 3.0]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['Jude', 'Sash', 'Unisse', 1, True, 3.0]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to strings, we can access elements in a list by doing indexing and slicing. \n",
    "> Remember that Python is 0-index based."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jude'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sash', 'Unisse', 1]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Concatenating lists**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jude', 'Sash', 'Unisse', 1, True, 3.0]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = ['Jude', 'Sash', 'Unisse']\n",
    "list2 = [1, True, 3.0]\n",
    "my_list = list1+list2\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Updating the list**\n",
    "\n",
    "Unlike strings, lists are mutable--meaning you could change the value of a particular list's items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Teves', 'Sash', 'Unisse', 1, True, 3.0]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['Jude', 'Sash', 'Unisse', 1, True, 3.0]\n",
    "my_list[0] = 'Teves'\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Appending the list**\n",
    "\n",
    "We can also append data into the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jude', 'Sash', 'Unisse', 1, True, 3.0, None]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['Jude', 'Sash', 'Unisse', 1, True, 3.0]\n",
    "my_list.append(None)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Inserting an item into the list**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jude', 'Teves', 'Sash', 'Unisse', 1, True, 3.0]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['Jude', 'Sash', 'Unisse', 1, True, 3.0]\n",
    "my_list.insert(1, 'Teves')\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Removing an item in the list**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sash', 'Unisse', 1, True, 3.0]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['Jude', 'Sash', 'Unisse', 1, True, 3.0]\n",
    "my_list.pop(0)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nested Lists**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Jude', 'Sash', 'Unisse'], [1, True, 3.0]]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = ['Jude', 'Sash', 'Unisse']\n",
    "list2 = [1, True, 3.0]\n",
    "my_list = [list1, list2]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jude', 'Sash', 'Unisse']"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**List Comprehension**\n",
    "\n",
    "List comprehension is a more syntactic way of creating a list based on another list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3, 4]\n",
    "list2 = [elem for elem in list1 if elem % 2 == 0]\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3, 4]\n",
    "list2 = [elem+1 for elem in list1]\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Some built-in methods in Lists**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max: 4\n",
      "Min: 1\n",
      "Length: 4\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4]\n",
    "print('Max:', max(my_list))  # should only contain numbers\n",
    "print('Min:', min(my_list))  # should only contain numbers\n",
    "print('Length:', len(my_list)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`reverse` function applies the transformation inplace, modifies the list variable, and returns `None`. Be careful when using this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reverse: [4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4]\n",
    "my_list.reverse()  # after this, the list is reversed\n",
    "print('Reverse:', my_list) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may also use the following approach which does not modify the actual variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that when the list is called again, it returns its original contents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3, 2, 1]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sort` function sorts the list. You can only sort a list that in which its items have the same data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [3, 4, 2, 1]\n",
    "my_list.sort()\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jude', 'Sash', 'Unisse']"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['Sash', 'Jude', 'Unisse']\n",
    "my_list.sort()\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also sort using the keyword `sorted`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [3, 4, 2, 1]\n",
    "sorted(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.5.2 Tuples\n",
    "\n",
    "In Python, a tuple is like a list but immutable--we cannot do append, insert, and delete. Instead of `[ ]`, we use parentheses `( )` to create a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Jude', 'Sash', 'Unisse', 1, True, 3.0)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tuple = ('Jude', 'Sash', 'Unisse', 1, True, 3.0)\n",
    "my_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.5.3 Sets\n",
    "\n",
    "A set data type contains unique values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4}"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set = [1, 1, 2, 4]\n",
    "set(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4}"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set = {1, 1, 2, 4}\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can perform union and intersection on sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4, 5}"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set.union([1, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1}"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set.intersection([1, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.5.4 Dictionaries\n",
    "\n",
    "Dictionary (`dict`) is a container of key-value pairs. Similar to lists, dicts are mutable and can contain mixed types. In addition, dicts are unordered. Here are two ways of creating a dict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key': 'value', 'dsi': 100, 'programming': 9000.0}"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = {'key': 'value',\n",
    "           'dsi': 100,\n",
    "           'programming': 9000.00}\n",
    "\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key': 'value', 'dsi': 100, 'programming': 9000.0}"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = dict(key='value', dsi=100, programming=9000.00)\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Accessing an item**\n",
    "\n",
    "We can access the value in a dict by indexing using any valid key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict['key']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict.get('key')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict.get('time')  # returns None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Some built-in methods in dicts**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['key', 'dsi', 'programming'])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['value', 100, 9000.0])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Adding an item in dict**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key': 'value', 'dsi': 100, 'programming': 9000.0, 'time': '6PM'}"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = dict(key='value', dsi=100, programming=9000.00)\n",
    "my_dict['time'] = '6PM'\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Removing an item in dict**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value'"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = dict(key='value', dsi=100, programming=9000.00)\n",
    "my_dict.pop('key')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'dsi': 100, 'programming': 9000.0}"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Joining dicts**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key': 4, 'time': '6 PM', 'num': '6 PM'}"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1 = {'key': 1, 'time': '6 PM'}\n",
    "dict2 = {'key': 4, 'num': '6 PM'}\n",
    "\n",
    "dict1.update(dict2)\n",
    "dict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key': 4, 'num': '6 PM'}"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Clearing dicts**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = dict(key='value', dsi=100, programming=9000.00)\n",
    "my_dict.clear()\n",
    "my_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6 Functions\n",
    "\n",
    "Imagine the following code below:\n",
    "\n",
    "```python\n",
    "kg = 10\n",
    "lbs = kg*2.2\n",
    "print(f'{kg} kg = {lbs} lbs')\n",
    "\n",
    "...some code...\n",
    "\n",
    "kg = 87\n",
    "lbs = kg*2.2\n",
    "print(f'{kg} kg = {lbs} lbs')\n",
    "    \n",
    "```\n",
    "\n",
    "Notice that multiple lines are duplicated. When developing big software, expect to be reusing many pieces of code. That's where functions come in handy. It lets us call a block of code and executes it. We use functions for the following reasons:\n",
    " - it allows us to reuse blocks of code \n",
    " - it makes the code more readable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Defining a function**\n",
    "\n",
    "We define a function by using the `def` keyword followed by the name of the function, then the parameters or the arguments encapsulated in a parentheses, and lastly, a colon `:`. The code block within every function should be indented. The function is also expected to return something back to the caller. To demonstrate, we'll turn the code above into one that uses functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 kg = 22.0 lbs\n",
      "87 kg = 191.4 lbs\n"
     ]
    }
   ],
   "source": [
    "def kg_to_lbs(kg):\n",
    "    return kg*2.2\n",
    "\n",
    "kg = 10\n",
    "print(f'{kg} kg = {kg_to_lbs(kg)} lbs')\n",
    "# some code\n",
    "kg = 87\n",
    "print(f'{kg} kg = {kg_to_lbs(kg)} lbs')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Arguments**\n",
    "\n",
    "We can also pass multiple arguments to a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def something(num1, num2, num3):\n",
    "    return (num1+num2)*num3\n",
    "\n",
    "something(1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " We can also include the names of the arguments to pass the values out of order. Notice that we will still get the same output as above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "something(num2=2, num3=3, num1=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "something(2, 3, 1)  # this will have a different output"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}