DATA2010 Lab_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0cf349d1",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# DATA2010: Intro to Python and Anaconda"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8256c950",
   "metadata": {},
   "source": [
    "# Lecture Objectives\n",
    "\n",
    "\n",
    "* Get familiar with the Anaconda and the IDE's within.\n",
    "* Learn Basic syntax of Python and re-connect Python and R\n",
    "* Better understading of Numpy and Pandas\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec42f38a",
   "metadata": {},
   "source": [
    "# Python: the basics\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Python is a general purpose programming language that supports rapid development\n",
    "of scripts and applications.\n",
    "\n",
    "Python's main advantages:\n",
    "\n",
    "* Open Source software, supported by Python Software Foundation\n",
    "* Available on all major platforms (ie. Windows, Linux and MacOS) \n",
    "* It is a general-purpose programming language, designed for readability\n",
    "* Supports multiple programming paradigms ('functional', 'object oriented')\n",
    "* Very large community with a rich ecosystem of third-party packages"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5258c1f8",
   "metadata": {},
   "source": [
    "## Interpreter\n",
    "\n",
    "Python is an interpreted language[*](https://softwareengineering.stackexchange.com/a/24560) which can be used in two ways:\n",
    "\n",
    "* \"Interactive\" Mode: It functions like an \"advanced calculator\", executing\n",
    "  one command at a time:\n",
    "* \"Scripting\" Mode: Executing a series of \"commands\" saved in text file,\n",
    "  usually with a `.py` extension after the name of your file:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79e45d1e",
   "metadata": {},
   "source": [
    "## Using interactive Python in Jupyter-style notebooks\n",
    "\n",
    "A convenient and powerful way to use interactive-mode Python is via a Jupyter Notebook, or similar browser-based interface.\n",
    "\n",
    "This particularly lends itself to data analysis since the notebook records a history of commands and shows output and graphs immediately in the browser.\n",
    "\n",
    "There are several ways you can run a Jupyter(-style) notebook - locally installed on your computer or hosted as a service on the web. Today we will use a Jupyter notebook service provided by Google: https://colab.research.google.com (Colaboratory).\n",
    "\n",
    "### Jupyter-style notebooks: a quick tour\n",
    "\n",
    "Go to https://colab.research.google.com and login with your Google account.\n",
    "\n",
    "Select ***NEW NOTEBOOK → NEW PYTHON 3 NOTEBOOK*** - a new notebook will be created.\n",
    "\n",
    "---\n",
    "\n",
    "Type some Python code in the top cell, eg:\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c9dd799e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Jupyter!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello Jupyter!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c26b2e1f",
   "metadata": {},
   "source": [
    "***Shift-Enter*** to run the contents of the cell"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d3f66e7",
   "metadata": {},
   "source": [
    "You can add new cells.\n",
    "\n",
    "***Insert → Insert Code Cell***\n",
    "\n",
    "---\n",
    "\n",
    "NOTE: When the text on the left hand of the cell is: `In [*]` (with an asterisk rather than a number), the cell is still running. It's usually best to wait until one cell has finished running before running the next.\n",
    "\n",
    "Let's begin writing some code in our notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8326bcd",
   "metadata": {},
   "source": [
    "# Prerequisite"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbd6fd09",
   "metadata": {},
   "source": [
    "Check the system path and version of jupyter notebook and python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4c74db19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E:\\Anaconda\\python.exe\n",
      "3.7.11 (default, Jul 27 2021, 09:42:29) [MSC v.1916 64 bit (AMD64)]\n",
      "sys.version_info(major=3, minor=7, micro=11, releaselevel='final', serial=0)\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(sys.executable)\n",
    "print(sys.version)\n",
    "print(sys.version_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cab9f5e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.7.11\n"
     ]
    }
   ],
   "source": [
    "from platform import python_version\n",
    "print(python_version())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4acd1ae8",
   "metadata": {},
   "source": [
    "### Or most simple way to check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "45e3e656",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.7.11\n"
     ]
    }
   ],
   "source": [
    "!python -V"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fad4340",
   "metadata": {},
   "source": [
    ">The exclamation/bang(!) simply means to run a conda install command."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c544b00e",
   "metadata": {
    "raw_mimetype": "text/html"
   },
   "source": [
    "# Comments in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e59f857e",
   "metadata": {
    "raw_mimetype": "text/x-python"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "DATA2010!\n"
     ]
    }
   ],
   "source": [
    "# This is a single line comment\n",
    "print(\"Hello, World!\")\n",
    "print(\"DATA2010!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "eb98d792",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "This is a multiline\n",
    "comment.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c674f5ff",
   "metadata": {},
   "source": [
    "# Importing Libraries or Modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0119511e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98608375",
   "metadata": {},
   "source": [
    "> The Word \"import\" allocates the specific library installed in the environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4ef0d95f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the pyplot model class from matplotlib\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d860b23a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We run this to suppress various deprecation warnings and keeps our notebook cleaner\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe8785bb",
   "metadata": {},
   "source": [
    "# Basic Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96c4a1f4",
   "metadata": {},
   "source": [
    "### Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "587076ca",
   "metadata": {},
   "source": [
    "#### Types of numbers\n",
    "\n",
    "Python has various \"types\" of numbers (numeric literals). We'll mainly focus on integers and floating point numbers.\n",
    "\n",
    "Integers are just whole numbers, positive or negative. For example: 2 and -2 are examples of integers.\n",
    "\n",
    "\n",
    "\n",
    "| Examples         | Number Type            |\n",
    "|------------------|------------------------|\n",
    "| 1, 2, 100, -100  | Integer                |\n",
    "| 1.2,-0.5,2e2,3E2 | Floating Point Numbers |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e2a8d34",
   "metadata": {},
   "source": [
    "### Basic Arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "72648380",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Addition\n",
    "2 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "21a25203",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Subtraction\n",
    "2 - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d12e710f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplication\n",
    "2 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "48f6500a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Division\n",
    "3 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66a0adc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Floor Division\n",
    "7 // 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "787575c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modulo\n",
    "7 % 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "950b061e",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "736b8690",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8192"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Powers\n",
    "2 ** 13"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28d9edae",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dd10e46",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can use parentheses to specify orders\n",
    "(2+10) * (10+3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fec8ea15",
   "metadata": {},
   "source": [
    "### Variable Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f4b87ec5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create an object called \"x\" and assign it the number 5\n",
    "x = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "fcecc6b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Adding the objects\n",
    "x + x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a99ccc1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reassignment\n",
    "x = 30\n",
    "x = x + x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c03caf8",
   "metadata": {},
   "source": [
    "### Rules for naming variables\n",
    "\n",
    "1. Names can not start with a number.\n",
    "2. There can be no spaces in the name, use _ instead.\n",
    "3. Can't use any of these symbols :'\",<>/?|\\()!@#$%^&*~-+\n",
    "4. It's considered best practice (PEP8) that names are lowercase.\n",
    "5. Avoid using words that have special meaning in Python like \"list\" and \"str\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0204d997",
   "metadata": {},
   "source": [
    "### Dynamic Typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "2e186d82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = 2\n",
    "num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "fcc32cdb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a number'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = \"This is a number\"\n",
    "num"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6a0b1ea",
   "metadata": {},
   "source": [
    "### Determining type of variable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "359ce74f",
   "metadata": {},
   "source": [
    "Python provides a build in function called `type` to check the type of variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e9fefb20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0a323b16",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 5.5\n",
    "type(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9597ad38",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (4, 5)\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45d9d903",
   "metadata": {},
   "source": [
    "### Some common data types are:\n",
    "* int (for integer)\n",
    "* float\n",
    "* str (for string)\n",
    "* list\n",
    "* tuple\n",
    "* dict (for dictionary)\n",
    "* set\n",
    "* bool (for Boolean True/False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3ad3dac",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "994a73cc",
   "metadata": {},
   "source": [
    "Strings in Python are actually a sequence, used to record textual info."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "1f6e7ed6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am a string'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String using single quotes\n",
    "'I am a string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "1e267e71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am also a string'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String using double quotes\n",
    "\"I am also a string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "920f5431",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-34-d4e01b799727>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-34-d4e01b799727>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    'I'm using single quotes, but this will create an error'\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Be careful with quotes!\n",
    "'I'm using single quotes, but this will create an error'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f5590b1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I'm using single quotes, but this won't create an error\""
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You have to use the escape(\\) binder\n",
    "'I\\'m using single quotes, but this won\\'t create an error'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f76e31e",
   "metadata": {},
   "source": [
    "#### Python provides a `print` method to print a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73863c3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello, Welcome to the workshop')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22372d61",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('This is an example how to use print method.\\nI will be printed in next line because of \\\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec645cc2",
   "metadata": {},
   "source": [
    "#### Python provides a `len` method to calculate the length of a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "e2474004",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len('DATA2010 - Fall2021')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc6cd86a",
   "metadata": {},
   "source": [
    "#### Indexing and Slicing in Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bcb8131d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign s as a string\n",
    "s = 'Hello World'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "31efb5bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e615b975",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show first element (in this case a letter)\n",
    "s[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ef32b12",
   "metadata": {},
   "source": [
    "#### *We use `:` to perform Slicing* \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8eb7960",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grab everything past the first term all the way to the length of s which is len(s) However there's no change in s\n",
    "s[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00a7ee98",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grab everything UP TO the 3rd index\n",
    "s[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "279fa3ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# What if we done provide any index in slicing?\n",
    "\n",
    "s[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ab87239",
   "metadata": {},
   "source": [
    "#### Python also supports Negative Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cdf5b0bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Last letter (one index behind 0 so it loops back around)\n",
    "s[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b469eeb2",
   "metadata": {},
   "source": [
    "#### Grab everything but the last letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81f93d55",
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f74cb303",
   "metadata": {},
   "source": [
    "#### Step size in Slicing. Grab everything, but go in step sizes of 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c8154f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "s[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "221cfaf5",
   "metadata": {},
   "source": [
    "#### Reverse a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33177e0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "s[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a93eb7b",
   "metadata": {},
   "source": [
    "## String Properties\n",
    "### *String are Immutable !*\n",
    "Immutability may be used to ensure that an object remains constant throughout your program. The values of mutable objects can be changed at any time and place, whether you expect it or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0dcaccea",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Concate Strings\n",
    "\n",
    "s = s + ' concatenate me!!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "80a1b240",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World concatenate me!!'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2ef57674",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ppppp'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String Multiplication\n",
    "\n",
    "\n",
    "label = 'p'\n",
    "label * 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c86a295d",
   "metadata": {},
   "source": [
    "## String Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82f005b3",
   "metadata": {},
   "source": [
    "#### *Upper Case*\n",
    "\n",
    "Python has a build in method `upper` to get uppercase of a string.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "188e37dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO WORLD CONCATENATE ME!! CONCATENATE ME!!'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Upper Case a string\n",
    "s.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c49a8f2c",
   "metadata": {},
   "source": [
    "> Note these methods don't change the original string!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6f2e4c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "caf1d68c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world concatenate me!!'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a72c8e8",
   "metadata": {},
   "source": [
    "### Split\n",
    "Extract words from string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c00e659b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'World', 'concatenate', 'me!!']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Split a string by blank space (this is the default)\n",
    "s.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1c64a885",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello ', 'orld concatenate me!!']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Split by a specific element (doesn't include the element that was split on)\n",
    "s.split('W')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbeb9aca",
   "metadata": {},
   "source": [
    "## String Formatting\n",
    "\n",
    "String formatting lets you inject items into a string rather than trying to chain items together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f28743c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "player = 'Thomas'\n",
    "points = 33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9768ab99",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Last night, Thomas scored 33 points.'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Last night, '+player+' scored '+str(points)+' points.'  # concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "bc78f377",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Last night, Thomas scored 33 points.'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'Last night, {player} scored {points} points.'          # string formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d873e780",
   "metadata": {},
   "source": [
    "> There are **three ways** to perform string formatting.\n",
    "\n",
    "1. The oldest method involves placeholders using the modulo % character.\n",
    "2. An improved technique uses the .format() string method.\n",
    "3. The newest method, introduced with Python 3.6, uses formatted string literals, called f-strings."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca756c86",
   "metadata": {},
   "source": [
    "#### First Method* using **%**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fba7958",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"I'm going to inject %s here.\" %'something')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4cd67e38",
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = 'some', 'more'\n",
    "print(\"I'm going to inject %s text here, and %s text here.\"%(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e77fedd5",
   "metadata": {},
   "source": [
    "#### *Second Method* using **.format()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef2eb9fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('This is a string with an {}'.format('insert'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d5cfe88",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('The {2} {1} {0}'.format('fox','brown','quick'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ab384ec",
   "metadata": {},
   "source": [
    "#### *Third Method* using **f-strings**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22f7b1ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Asif'\n",
    "\n",
    "print(f\"He said his name is {name}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a09a10b",
   "metadata": {},
   "source": [
    "# List"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2efd30d6",
   "metadata": {},
   "source": [
    "List is an ordered sequence of elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "3c51f724",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign a list to an variable named my_list\n",
    "my_list = [1,2,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea55487c",
   "metadata": {},
   "source": [
    "#### Unlike strings, they are **mutable**, meaning the elements inside a list can be changed!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "32c91fce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 3]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[1] = 5\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fd4a7f9",
   "metadata": {},
   "source": [
    "#### We just created a list of integers, but lists can actually hold different object types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "78e2ac8b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A string', 23, 100.232, 'o']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['A string',23,100.232,'o']\n",
    "my_list "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a16685c0",
   "metadata": {},
   "source": [
    "#### Just like strings, list also has `len` to find length of string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "12c22ab6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['This', 'is', 'a', 'DATA2010', 'Lab']\n",
    "len(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26be2736",
   "metadata": {},
   "source": [
    "## Indexing and Slicing in List\n",
    "\n",
    "Indexing and slicing work just like in strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a6cd47ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 4, 5]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['one','two','three',4,5]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9fb0a01e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'one'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grab element at index 0\n",
    "my_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3df0c1bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grab index 1 and everything past it\n",
    "my_list[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea4a11b9",
   "metadata": {},
   "source": [
    "#### We can also use **+** to concatenate lists, just like we did for strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e88be599",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 4, 5, 'new item']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list + ['new item']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "3eba37c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 4, 5]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "769a0160",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list2 = my_list + ['new item']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "4eae2de7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 4, 5, 'new item']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c149cc3",
   "metadata": {},
   "source": [
    "> **Note**: *This doesn't actually change the original list!*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e8a8114",
   "metadata": {},
   "source": [
    "#### We can also use the * for a duplication method similar to strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4784b034",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make the list double\n",
    "my_list * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7631221",
   "metadata": {},
   "source": [
    "## List Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd2c67f1",
   "metadata": {},
   "source": [
    "***append***\n",
    "> Add an item to the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "544178b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['one', 'two', 'three', 4, 5, 'append me!']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Append\n",
    "my_list.append('append me!')\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3736eea6",
   "metadata": {},
   "source": [
    "***pop***\n",
    "> Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "decb0e32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'one'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pop off the 0 indexed item\n",
    "my_list.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "45b031f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'append me!'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign the popped element, remember default popped index is -1\n",
    "popped_item = my_list.pop()\n",
    "popped_item"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "230aeed5",
   "metadata": {},
   "source": [
    "***reverse***\n",
    "> Reverse the elements of the list in place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "dce0c83d",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = ['a','e','x','b','c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "74633671",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'b', 'x', 'e', 'a']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use reverse to reverse order (this is permanent!)\n",
    "new_list.reverse()\n",
    "new_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fa9cabe",
   "metadata": {},
   "source": [
    "***sort***\n",
    "> Sort the items of the list in place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3201b58d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use sort to sort the list (in this case alphabetical order, but for numbers it will go ascending)\n",
    "new_list.sort()\n",
    "\n",
    "new_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44e3de97",
   "metadata": {},
   "source": [
    "## Nested List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "b7db4ddc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's make three lists\n",
    "lst_1=[1,2,3]\n",
    "lst_2=[4,5,6]\n",
    "lst_3=[7,8,9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "d5155465",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a list of lists to form a matrix\n",
    "matrix = [lst_1,lst_2,lst_3]\n",
    "\n",
    "\n",
    "matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca60f4e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grab first item in matrix object\n",
    "matrix[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0c4f72d",
   "metadata": {},
   "source": [
    "## List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca36f103",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [1, 2, 3, 4]\n",
    "\n",
    "squares = [ n * n for n in nums ]  \n",
    "\n",
    "\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8996d24d",
   "metadata": {},
   "source": [
    "# Dictonary\n",
    "\n",
    "Dictionary in Python is an unordered collection of data values, used to store data values like a map, which unlike other Data Types that hold only single value as an element, Dictionary holds **key:value** pair.\n",
    "\n",
    "Dictonaries are like Hash Tables used in other languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "0cc895a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a dictionary with {} and : to signify a key and a value\n",
    "my_dict = {'key1':'value1','key2':'value2'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "77ef4efb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 'value1', 'key2': 'value2'}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "f5931c6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value2'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Call values by their key\n",
    "my_dict['key2']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "668579c6",
   "metadata": {},
   "source": [
    "#### Its important to note that dictionaries are **very flexible** in the data types they can hold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d52f6a9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {'key1':123,'key2':[12,23,33],'key3':['item0','item1','item2']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c426912e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's call items from the dictionary\n",
    "my_dict['key3']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e75d7740",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can call an index on that value\n",
    "my_dict['key3'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94b2a7c9",
   "metadata": {},
   "source": [
    "> To see the power and flexibility of Python lets see nested dictonaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "59f733f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionary nested inside a dictionary nested inside a dictionary\n",
    "d = {'key1':{'nestkey':{'subnestkey':'value'}}}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab61a4ff",
   "metadata": {},
   "source": [
    "\n",
    "#### Let's see how we can grab that value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "4899bbd4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Keep calling the keys\n",
    "d['key1']['nestkey']['subnestkey']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3db75458",
   "metadata": {},
   "source": [
    "## Dictonary Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d71b8dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a typical dictionary\n",
    "d = {'key1':1,'key2':2,'key3':3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f2da654",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Method to return a list of all keys \n",
    "d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67aaf7b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Method to grab all values\n",
    "d.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6939abae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Method to return tuples of all items\n",
    "d.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5056bf6b",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "\n",
    "In Python tuples are very similar to lists, however, unlike lists they are immutable meaning they can not be changed.\n",
    "\n",
    "The construction of a tuples use () with elements separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "968fe5ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a tuple\n",
    "t = (1,2,3)\n",
    "\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20e5902d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check len just like a list\n",
    "\n",
    "len(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e6ca674",
   "metadata": {},
   "source": [
    "> *Can also **mix object types***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "7d757b49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('one', 2)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = ('one',2)\n",
    "\n",
    "# Show\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5399f2f",
   "metadata": {},
   "source": [
    "#### *Use **indexing** just like we did in lists*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "638fed8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "t[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c8b5c09",
   "metadata": {},
   "source": [
    "#### ***Slicing** just like a list*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d95f04f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "t[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01e3d9ff",
   "metadata": {},
   "source": [
    "## Tuple Methods\n",
    "\n",
    "Tuple has two built-in methods."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "861230d6",
   "metadata": {},
   "source": [
    "#### ***index***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13caaed2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use .index to enter a value and return the index\n",
    "t.index('one')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "911b0eba",
   "metadata": {},
   "source": [
    "***count***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "61160ec1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use .count to count the number of times a value appears\n",
    "t.count('one')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8205db1b",
   "metadata": {},
   "source": [
    "### Tuples are Immutable!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfa78ff2",
   "metadata": {},
   "outputs": [],
   "source": [
    "t[0]= 'change'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4f61d40",
   "metadata": {},
   "source": [
    "> Because of this immutability, tuples can't grow. Once a tuple is made we can not add to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "002f5faf",
   "metadata": {},
   "outputs": [],
   "source": [
    "t.append('nope')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10c04cca",
   "metadata": {},
   "source": [
    "## Use of Tuple\n",
    "\n",
    "If in your program you are passing around an object and need to make sure it does not get changed, then a tuple becomes your solution. It provides a convenient source of data integrity."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47fd2f6a",
   "metadata": {},
   "source": [
    "### Sets\n",
    "Sets are an unordered collection of unique elements. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "c248a8fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = set()\n",
    "\n",
    "# We add to sets with the add() method\n",
    "x.add(1)\n",
    "\n",
    "#Show\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "87174af0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add a different element\n",
    "x.add(1)\n",
    "\n",
    "# Try to add the same element\n",
    "x.add(2)\n",
    "\n",
    "\n",
    "#Show\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "045e4525",
   "metadata": {},
   "source": [
    "> **Notice** how it won't place another 1 there. That's because a set is only concerned with unique elements! "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4847804",
   "metadata": {},
   "source": [
    "We can cast a list with multiple repeat elements to a set to get the unique elements. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a896307",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list with repeats\n",
    "list1 = [1,1,2,2,3,4,5,6,1,1]\n",
    "\n",
    "\n",
    "# Cast as set to get unique values\n",
    "set(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72678458",
   "metadata": {},
   "source": [
    "## Booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c7a9089",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boolean values are primitives (Note: the capitalization)\n",
    "True  # => TRUE\n",
    "False  # => False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "754c87b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# negate with not\n",
    "not True   # => False\n",
    "not False  # => True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4bce1b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boolean Operators\n",
    "True and False  # => False\n",
    "False or True   # => Truev"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d040771",
   "metadata": {},
   "source": [
    "> Note \"and\" and \"or\" are case-sensitive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8560afa",
   "metadata": {},
   "source": [
    "## Operators\n",
    "\n",
    "#### Operators are special symbols in python that carry out arthimetic and logical operations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44e099c5",
   "metadata": {},
   "source": [
    "### Operator Types\n",
    "\n",
    "1. Arithmetic Operators\n",
    "2. Comparison Operators\n",
    "3. Logical Operators\n",
    "4. Bitwise Operators\n",
    "5. Assignment Operators\n",
    "6. Special Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bdfc0f2",
   "metadata": {},
   "source": [
    "#### Arithmetic Operators "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "e167d925",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "x - y =  9\n",
      "x * y =  90\n",
      "x / y =  2.5\n",
      "x // y = 2\n",
      "x ** y =  11390625\n"
     ]
    }
   ],
   "source": [
    "x = 15\n",
    "y = 6\n",
    "\n",
    "# Addition Operator\n",
    "print('x + y = ', x + y)\n",
    "#print(x+y)\n",
    "\n",
    "# Subtraction Operator\n",
    "print('x - y = ', x - y)\n",
    "\n",
    "# Multiplication Operator\n",
    "print('x * y = ', x * y)\n",
    "\n",
    "# Division Operator\n",
    "print('x / y = ', x / y) # True Division\n",
    "print('x // y =', x//y) # Class Division\n",
    "\n",
    "# Exponential Operator\n",
    "print('x ** y = ', x ** y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c006def",
   "metadata": {},
   "source": [
    "#### Comparison Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d9099ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 12\n",
    "y = 10\n",
    "\n",
    "# Greater Than Operator\n",
    "print('x > y = ',x > y)\n",
    "\n",
    "# Greater Than or Equal To\n",
    "print('x >= y', x >= y)\n",
    "\n",
    "# Lesser Than Operator\n",
    "print('x < y = ',x < y)\n",
    "\n",
    "# Lesser Than or Equal To\n",
    "print('x <= y', x <= y)\n",
    "\n",
    "# Equal To Operator\n",
    "print('x == y ',x == y)\n",
    "\n",
    "# Not Equal To\n",
    "print('x != y', x != y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2823b37d",
   "metadata": {},
   "source": [
    "#### Logical Operators\n",
    "<pre>\n",
    "and - True if both operands are true\n",
    "or - True if one of the operand is true\n",
    "not - True if operand is false \n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c6f3c24",
   "metadata": {},
   "source": [
    "#### Bitwise Operators\n",
    "<pre>\n",
    "& -> Bitwise AND\n",
    "| -> Bitwise OR\n",
    "~ -> Bitwise NOT\n",
    "^ -> Bitwise XOR\n",
    ">> -> Bitwise Right Shift\n",
    "<< -> Bitwise Left Shift\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68b42e01",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 4\n",
    "\n",
    "# Bitwise AND\n",
    "print('x & y = ', x & y)\n",
    "# Bitwise OR\n",
    "print('x | y = ', x | y)\n",
    "# Bitwise NOT\n",
    "print('~ x = ', ~ x)\n",
    "# Bitwise XOR\n",
    "print('x ^ y = ', x ^ y)\n",
    "# Right shift\n",
    "print('x >> y = ', x >> y)\n",
    "# Left Shift\n",
    "print('x << y = ', x << y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e0ccaf4",
   "metadata": {},
   "source": [
    "#### Assignment Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acbff4cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "print(a)\n",
    "a += 5 # a = a + 5\n",
    "print(a)\n",
    "a -= 5 # a = a - 5 \n",
    "print(a)\n",
    "a *= 5 # a = a * 5\n",
    "print(a)\n",
    "a /= 5 # a = a / 5\n",
    "print(a)\n",
    "a //= 2 # a = a // 2\n",
    "print(a)\n",
    "a %= 1 # a = a % 1\n",
    "print(a)\n",
    "a = 10\n",
    "a **= 2 # a = a ** 2\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce3837d5",
   "metadata": {},
   "source": [
    "###### Identity Operators\n",
    "\n",
    " <pre>\n",
    " is - True if the operands are identical\n",
    " is not - True if the operands are not identical\n",
    " </pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c163f348",
   "metadata": {},
   "outputs": [],
   "source": [
    "x1 = 2\n",
    "y1 = 2\n",
    "x2 = 'Hello'\n",
    "y2 = \"Hello\"\n",
    "x3 = [1,2,3]\n",
    "y3 = (1,2,3)\n",
    "\n",
    "print('x1 is y1 = ', x1 is y1)\n",
    "print('x1 is y2 = ', x1 is y2)\n",
    "print('x3 is not y3 = ', x3 is not y3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70a26be9",
   "metadata": {},
   "source": [
    "###### Membership Operators\n",
    "<pre>\n",
    "    in - True if value / variable is found in sequence\n",
    "    not in - True if value / variable is not found in the sequence\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9655fc35",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'Hello World'\n",
    "y = {1:'a',2:'b'}\n",
    "\n",
    "print(\"'H' in x \", 'H' in x)\n",
    "print('hello not in x ','hello' not in x)\n",
    "print('1 in y = ',1 in y)\n",
    "print('a in y = ',a in y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32bf735f",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "* Function is a group of related statements that perform a specific task.\n",
    "* Function help break large programs into smaller and modular chunks\n",
    "* Function makes the code more organised and easy to manage\n",
    "* Function avoids repetition and there by promotes code reusability\n",
    "\n",
    "#### Two types of functions\n",
    "1. Built-In Functions\n",
    "2. User Defined Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "170bd3ae",
   "metadata": {},
   "source": [
    "### Function Syntax\n",
    "```python\n",
    "def function_name(arguments):\n",
    "    '''This is the docstring for the function'''\n",
    "    # note the indentation, anything inside the function must be indented\n",
    "    # function code goes here\n",
    "    ...\n",
    "    return\n",
    "    \n",
    "# calling the function\n",
    "function_name(arguments)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "87f033e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# Simple Function\n",
    "def greet():\n",
    "    '''Simple Greet Function'''\n",
    "    print('Hello World')\n",
    "    \n",
    "greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "808617e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello  DATA\n"
     ]
    }
   ],
   "source": [
    "# Function with arguments\n",
    "def greet(name):\n",
    "    '''Simple Greet Function with arguments'''\n",
    "    print('Hello ', name)\n",
    "    \n",
    "greet('DATA')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "ee5d246b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "# Function with return statement\n",
    "def add_numbers(num1,num2):\n",
    "    return num1 + num2\n",
    "\n",
    "print(add_numbers(2,3.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "5fa6b6c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HelloWorld\n"
     ]
    }
   ],
   "source": [
    "# Since arguments are not strongly typed you can even pass a string\n",
    "print(add_numbers('Hello','World'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3141eaf",
   "metadata": {},
   "source": [
    "### Scope and Lifetime of Variables\n",
    "Variables in python has local scope which means parameters and variables defined inside the function is not visible from outside.\n",
    "\n",
    "Lifetime of a variable is how long the variable exists in the memory. Lifetime of variables defined inside the function exists as long as the function executes. They are destroyed once the function is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "79b1a8a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value inside the function  5\n",
      "Value outside the function 10\n"
     ]
    }
   ],
   "source": [
    "def myfunc():\n",
    "    x = 5\n",
    "    print('Value inside the function ',x)\n",
    "    \n",
    "x = 10\n",
    "myfunc()\n",
    "print('Value outside the function',x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "c2614bb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value inside the function  10\n",
      "Value outside the function 10\n"
     ]
    }
   ],
   "source": [
    "def myfunc():\n",
    "    #x = 5\n",
    "    print('Value inside the function ',x)\n",
    "    \n",
    "x = 10\n",
    "myfunc()\n",
    "print('Value outside the function',x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d10ee8d0",
   "metadata": {},
   "source": [
    "##### Global Variable\n",
    "Variables declared inside the function are not available outside. The following example will generate an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcb97c29",
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc():\n",
    "    y = 5\n",
    "    print('Value inside the function ',y)\n",
    "    \n",
    "myfunc()\n",
    "print('Value outside the function',y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6018e18",
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc():\n",
    "    global z\n",
    "    z = 5\n",
    "    print('Value inside the function ',z)\n",
    "    \n",
    "#z = 10\n",
    "myfunc()\n",
    "print('Value outside the function',z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94910515",
   "metadata": {},
   "source": [
    "# Now let's play with Pandas and Numpy"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}