Review Sheet DW Quiz 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"3DC.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python 3 Cheat Sheet\n",
    "\n",
    "Revision content from last quiz is below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------------\n",
    "# Part 2 (New Content for Mid Terms)\n",
    "-----------\n",
    "## Nested Lists\n",
    "A nested list just refers to a list of lists. The elements of the outer list are inner lists. \n",
    "### Creating a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "nestedlist=[[1,1,1],[2,2,2],[3,3,3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retrieving items from nested list\n",
    "To retrieve an inner list from the outer list, retrieve the inner list as an element of the outer list.\n",
    "\n",
    "To retrieve the elements from the inner list, retrieve the elements of the list as usual."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Retrieving first inner list:\n",
      "[1, 1, 1]\n",
      "\n",
      "\n",
      "Retrieving all inner lists:\n",
      "[1, 1, 1]\n",
      "[2, 2, 2]\n",
      "[3, 3, 3]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Retrieving first inner list:\")\n",
    "print(nestedlist[0])\n",
    "print(\"\\n\")\n",
    "\n",
    "print(\"Retrieving all inner lists:\")\n",
    "for innerlist in nestedlist:\n",
    "    print(innerlist)\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Retrieving first element in first inner list:\n",
      "1\n",
      "\n",
      "\n",
      "Retrieving all elements in first inner list:\n",
      "1\n",
      "1\n",
      "1\n",
      "\n",
      "\n",
      "Retrieving all elements in all inner lists:\n",
      "Inner List Number: 0\n",
      "1\n",
      "1\n",
      "1\n",
      "Inner List Number: 1\n",
      "2\n",
      "2\n",
      "2\n",
      "Inner List Number: 2\n",
      "3\n",
      "3\n",
      "3\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Retrieving first element in first inner list:\")\n",
    "print(nestedlist[0][0])\n",
    "print(\"\\n\")\n",
    "\n",
    "print(\"Retrieving all elements in first inner list:\")\n",
    "for element in nestedlist[0]:\n",
    "    print(element)\n",
    "print(\"\\n\")\n",
    "\n",
    "print(\"Retrieving all elements in all inner lists:\")\n",
    "for innerlist in nestedlist:\n",
    "    print(\"Inner List Number:\",nestedlist.index(innerlist))\n",
    "    for element in innerlist:\n",
    "        print(element)\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------\n",
    "## Tuples\n",
    "Tuples are wrapped in round brackets.\n",
    "Operation on tuples are same as lists.\n",
    "The difference between tuples and lists is that tuples are immunerable(uneditable)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('potato', 'strawberry', 'watermelon')\n",
      "\n",
      "\n",
      "A way to edit tuples is to create a list with every item of the tuple.\n",
      "['tomato', 'strawberry', 'watermelon']\n",
      "\n",
      "\n",
      "After editing the list, you can then convert is back to a tuple.\n",
      "('tomato', 'strawberry', 'watermelon')\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "fruits=(\"potato\",\"strawberry\",\"watermelon\")\n",
    "print(fruits)\n",
    "print(\"\\n\")\n",
    "\n",
    "#fruits[0]=\"tomato\" \n",
    "#Attempting to edit the tuple will return a TypeError: 'tuple' object does not support item assignment\n",
    "\n",
    "print(\"A way to edit tuples is to create a list with every item of the tuple.\")\n",
    "fruitlist= list(fruits)\n",
    "fruitlist[0]=\"tomato\"\n",
    "print(fruitlist)\n",
    "print(\"\\n\")\n",
    "\n",
    "print(\"After editing the list, you can then convert is back to a tuple.\")\n",
    "fruits=tuple(fruitlist)\n",
    "print(fruits)\n",
    "print(\"\\n\")\n",
    "\n",
    "#NOTE: If you have assigned something to the variable \"list\" ie. list=[], list() function WILL fail.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------\n",
    "## Dictionary\n",
    "The main feature of the dictionary is the key value pair. The values are attached to keys which allow the values to be retrieved.\n",
    "### Creating Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Club': '3DC', 'IsAwesome': True}\n",
      "\n",
      "\n",
      "Adding new item\n",
      "{'Club': '3DC', 'IsAwesome': True, 'Year': 2019}\n",
      "\n",
      "\n",
      "Another way to construct a dictionary\n",
      "{'Club': '3DC', 'IsAwesome': True, 'Year': 2019}\n"
     ]
    }
   ],
   "source": [
    "dictionary={\n",
    "    \"Club\":\"3DC\",\n",
    "    \"IsAwesome\":True\n",
    "}\n",
    "print(dictionary)\n",
    "print(\"\\n\")\n",
    "\n",
    "print(\"Adding new item\")\n",
    "dictionary[\"Year\"]=2019\n",
    "print(dictionary)\n",
    "print(\"\\n\")\n",
    "\n",
    "#Another way to construct a dictionary\n",
    "print(\"Another way to construct a dictionary\")\n",
    "dictionary2 = dict(Club=\"3DC\", IsAwesome=True, Year=2019)\n",
    "print(dictionary2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting or changing item in Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing Dictionary\n",
      "{'Club': '3DC', 'IsAwesome': True, 'Year': 2019}\n",
      "\n",
      "\n",
      "Printing Item (given key)\n",
      "3DC\n",
      "\n",
      "\n",
      "Changing Item (given key)\n",
      "2020\n",
      "{'Club': '3DC', 'IsAwesome': True, 'Year': 2020}\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Printing Dictionary\")\n",
    "print(dictionary)\n",
    "print(\"\\n\")\n",
    "\n",
    "print(\"Printing Item (given key)\")\n",
    "print(dictionary[\"Club\"])\n",
    "print(\"\\n\")\n",
    "\n",
    "print(\"Changing Item (given key)\")\n",
    "dictionary[\"Year\"]=2020\n",
    "print(dictionary[\"Year\"])\n",
    "print(dictionary)\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating through Dictionary\n",
    "Through iteration, you are able to obtain these things:\n",
    "- List of keys\n",
    "- List of values\n",
    "- List of keys and values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obtaining List of Keys\n",
      "Club\n",
      "IsAwesome\n",
      "Year\n",
      "\n",
      "\n",
      "Obtaining List of Values\n",
      "3DC\n",
      "True\n",
      "2020\n",
      "\n",
      "\n",
      "Obtaining List of Key-Value pairs\n",
      "Club : 3DC\n",
      "IsAwesome : True\n",
      "Year : 2020\n"
     ]
    }
   ],
   "source": [
    "print(\"Obtaining List of Keys\")\n",
    "for key in dictionary:\n",
    "    print(key)\n",
    "print(\"\\n\")\n",
    "\n",
    "print(\"Obtaining List of Values\")\n",
    "for key in dictionary:\n",
    "    print(dictionary[key])\n",
    "print(\"\\n\")\n",
    "\n",
    "print(\"Obtaining List of Key-Value pairs\")\n",
    "for key,value in dictionary.items(): #NOTE: .items() method is required\n",
    "    print(key,\":\",value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking if key is in dictionary\n",
    "Sometimes to check if a field is filled in a dictionary, checking if a key exists can be very useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test 1\n",
      "Key exists!\n",
      "\n",
      "\n",
      "Test 2\n",
      "Key not found!\n"
     ]
    }
   ],
   "source": [
    "def key_test(dictionary_tested,testing_key):\n",
    "    if testing_key in dictionary:\n",
    "        print(\"Key exists!\")\n",
    "    else:\n",
    "        print(\"Key not found!\")\n",
    "\n",
    "print(\"Test 1\")\n",
    "key_test(dictionary,\"Year\")\n",
    "print(\"\\n\")\n",
    "\n",
    "print(\"Test 2\")\n",
    "key_test(dictionary,\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------------------------------\n",
    "## Recursion\n",
    "In Python, a function can call itself. A function that calls itself is known as a recursive function. Your function should have a way to break out of the recursion. Below is a really simple example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recursive_double(x):\n",
    "    x+=x\n",
    "    print(x)\n",
    "    if x==4096: #function must be able to breakout!\n",
    "        return x \n",
    "    else:\n",
    "        return recursive_double(x) #Need to have the return in front when recursively calling the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "8\n",
      "16\n",
      "32\n",
      "64\n",
      "128\n",
      "256\n",
      "512\n",
      "1024\n",
      "2048\n",
      "4096\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursive_double(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------------\n",
    "## String Operators\n",
    "Strings are just like lists of characters. You can hence use list methods such as splicing.\n",
    "### List Methods on String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "bc\n"
     ]
    }
   ],
   "source": [
    "string=\"abcd\"\n",
    "print(string[0])\n",
    "print(string[1:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also string specific methods such as split() or lowercase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n",
      "def\n",
      "\n",
      "\n",
      "ABC\n",
      "Def\n"
     ]
    }
   ],
   "source": [
    "string=\"abc,def\"\n",
    "string1,string2=string.split(',')\n",
    "print(string1)\n",
    "print(string2)\n",
    "print(\"\\n\")\n",
    "\n",
    "print(string1.upper())\n",
    "print(string2.capitalize())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Comparisons\n",
    "Strings are compared lexicographically i.e using ASCII value of the characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "string1=\"BBBB\"\n",
    "string2=\"bbbb\"\n",
    "string3=\"bbb\"\n",
    "string4=\"aaaa\"\n",
    "\n",
    "print(string2>string1) #lowercase > uppercase\n",
    "print(string2>string3) #longer string > shorter string\n",
    "print(string2>string4) #behind alphabets \"z,x,y\" > forward alphabets \"a,b,c\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------\n",
    "## Reading and Writing Files\n",
    "A Python script can be used to read or write other files. This can be done with the open() function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n",
      "We are from 3DC!\n",
      "You are awesome!\n",
      "Bye Bye!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "file = open(\"testfile1.txt\",\"r\")\n",
    "print(file.read()) #Reads everything in file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "!\n",
      "We \n"
     ]
    }
   ],
   "source": [
    "file = open(\"testfile1.txt\",\"r\")\n",
    "\n",
    "print(file.read(5)) #Number of characters read\n",
    "print(file.read(5)) #Next 5 characters are read "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n",
      "W\n"
     ]
    }
   ],
   "source": [
    "file = open(\"testfile1.txt\",\"r\")\n",
    "# Nextline character \"\\n\" are included in the character\n",
    "print(file.read(8)) \n",
    "#Characters counted here are H,e,l,l,o,!,\\n,W"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n",
      "\n",
      "We are from 3DC!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "file = open(\"testfile1.txt\",\"r\")\n",
    "print(file.readline()) #reads 1st line\n",
    "print(file.readline()) #reads next line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "He\n",
      "l\n"
     ]
    }
   ],
   "source": [
    "file = open(\"testfile1.txt\",\"r\")\n",
    "print(file.readline(2)) #reads first 2 characters in line\n",
    "print(file.readline(1)) #reads next character in line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open(\"testfile2.txt\",\"w\") \n",
    " \n",
    "file.write(\"\\n\")\n",
    "file.write(\"Hello World\") \n",
    "file.write(\"\\n\")\n",
    "file.write(\"This is our new text file\") \n",
    "file.write(\"\\n\")\n",
    "file.write(\"and this is another line.\") \n",
    "file.write(\"\\n\")\n",
    "file.write(\"Why? Because we can.\") \n",
    " \n",
    "file.close() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Hello World\n",
      "This is our new text file\n",
      "and this is another line.\n",
      "Why? Because we can.\n"
     ]
    }
   ],
   "source": [
    "file=open(\"testfile2.txt\",\"r\")\n",
    "print(file.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------------------------------\n",
    "# Earlier Content (from previous quiz)\n",
    "---------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical Operators and PEDMAS\n",
    "### Numerical Operators\n",
    "In python arithmetic operators are used with numeric values to perform common numerical operations\n",
    "\n",
    "| Operator          | Description                                                  | Example                                                      |\n",
    "| ----------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |\n",
    "| + Addition        | Adds values on either side of the operator                   | `10 + 20` returns `30`                                       |\n",
    "| - Subtraction     | Subtracts right hand operand from left hand operand          | `0 - 10` returns `-10`                                       |\n",
    "| * Multiplication  | Multiplies values on either side of the operator             | `20 * 10` returns `200`                                      |\n",
    "| / Division        | Divides left hand operand by right hand operand and returns remainder | `4 / 2` returns `2`                                          |\n",
    "| % Modulus         | Divides left hand operand by right hand operand and returns remainder | `5 % 2` returns `1`                                          |\n",
    "| ** Exponent       | Performs exponential (power) calculation on operators        | `2**3` returns `8`                                           |\n",
    "| // Floor Division | Division that results in the quotient having its digits after the decimal place removed (not rounded). If one of the operands is negative, the result is floored i.e. rounded towards negative infinity | `9 // 2` returns `4` , `9.0 // 2.0` returns  `4.0`, `-11 // 3` returns `-4`, `-11.0 // 3.0` returns `-4.0` |\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The order of precedence follows the PEMDAS rule: \n",
    "<img src=\"PEMDAS.png\">\n",
    "\n",
    "Since Parantheses has priority, it can be used to ensure precedence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "### List Creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[] | <class 'list'>\n",
      "[] | <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "# create empty list\n",
    "names = []\n",
    "cities = list()\n",
    "\n",
    "print(names, type(names), sep=\" | \")\n",
    "print(cities, type(cities), sep=\" | \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add new items "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Eve', 'Katy', 'Rachel', 'Phoebe', 'Annabelle', 'Adele']\n",
      "['Tokyo', 'Singapore', 'New York City', 'Shanghai', 'KL', 'Manila', 'Jakarta', 'Seoul', 'Bangkok']\n"
     ]
    }
   ],
   "source": [
    "names.append(\"Eve\")\n",
    "names.append(\"Katy\")\n",
    "names.append(\"Rachel\")\n",
    "names.append(\"Phoebe\")\n",
    "names.append(\"Annabelle\")\n",
    "names.append(\"Adele\")\n",
    "print(names)\n",
    "\n",
    "cities = [\"Tokyo\", \"Singapore\", \"New York City\", \"Shanghai\", \"KL\", \"Manila\", \"Jakarta\", \"Seoul\", \"Bangkok\"]\n",
    "print(cities)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Access items(s) in a List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eve\n",
      "Phoebe\n",
      "Adele\n",
      "Annabelle\n",
      "\n",
      "Hello, Eve\n",
      "Hello, Katy\n",
      "Hello, Rachel\n",
      "Hello, Phoebe\n",
      "Hello, Annabelle\n",
      "Hello, Adele\n",
      "\n",
      "Hello, Eve\n",
      "Hello, Katy\n",
      "Hello, Rachel\n",
      "Hello, Phoebe\n",
      "Hello, Annabelle\n",
      "Hello, Adele\n",
      "\n",
      "0 | Eve\n",
      "1 | Katy\n",
      "2 | Rachel\n",
      "3 | Phoebe\n",
      "4 | Annabelle\n",
      "5 | Adele\n"
     ]
    }
   ],
   "source": [
    "# access by a specific index\n",
    "print(names[0])\n",
    "print(names[3])\n",
    "print(names[-1])\n",
    "print(names[-2])\n",
    "\n",
    "print() # just to print a line break\n",
    "\n",
    "# traverse all items in a list\n",
    "for name in names:\n",
    "  print(\"Hello,\", name)\n",
    "\n",
    "print() # just to print a line break\n",
    "\n",
    "# this will show you \"i\" is an arbitrary temporary variable name\n",
    "# below will produce the same output as above\n",
    "for i in names:\n",
    "  print(\"Hello,\", i)\n",
    "\n",
    "print() # just to print a line break\n",
    "\n",
    "# sometimes indexes are useful \n",
    "# how to get the item and its index at the same time? \n",
    "for index, name in enumerate(names):\n",
    "  print(index, name, sep=\" | \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Count number of items in a List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "9\n",
      "['Eve', 'Katy', 'Rachel', 'Phoebe', 'Annabelle', 'Adele', 'Adele', 'Adele', 'Adele']\n"
     ]
    }
   ],
   "source": [
    "length = len(names)\n",
    "print(length)\n",
    "\n",
    "names.append(\"Adele\") # this shows List can contain multiple identical objects\n",
    "names.append(\"Adele\")\n",
    "names.append(\"Adele\")\n",
    "print(len(names))\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove items from a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Katy', 'Rachel', 'Phoebe', 'Annabelle', 'Adele', 'Adele', 'Adele', 'Adele']\n",
      "\n",
      "removed name: Katy\n",
      "['Rachel', 'Phoebe', 'Annabelle', 'Adele', 'Adele', 'Adele', 'Adele']\n",
      "\n",
      "['Rachel', 'Phoebe', 'Annabelle', 'Adele', 'Adele', 'Adele']\n",
      "\n",
      "# 01: ['Rachel', 'Phoebe', 'Annabelle', 'Adele', 'Adele']\n",
      "# 02: ['Rachel', 'Phoebe', 'Annabelle', 'Adele']\n",
      "# 03: ['Rachel', 'Phoebe', 'Annabelle']\n"
     ]
    }
   ],
   "source": [
    "# remove an item at specific index\n",
    "# method 1: del\n",
    "del names[0]\n",
    "print(names)\n",
    "print()\n",
    "\n",
    "# method 2: pop\n",
    "removed_name = names.pop(0) # pop() also returns the item being deleted\n",
    "print(\"removed name:\", removed_name)\n",
    "print(names)\n",
    "print()\n",
    "\n",
    "# remove an item with specific value\n",
    "names.remove(\"Adele\") # this will remove the first occurrence of 'Adele' only\n",
    "print(names)\n",
    "print()\n",
    "\n",
    "# remove the last item from a List\n",
    "names.pop() # 01\n",
    "print(\"# 01:\", names)\n",
    "\n",
    "names.pop(-1) # 02\n",
    "print(\"# 02:\", names)\n",
    "\n",
    "del names[-1] # 03\n",
    "print(\"# 03:\", names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Rachel', 'Phoebe', 'Annabelle']\n",
      "['Eve', 'Katy', 'Rachel']\n",
      "['Phoebe', 'Annabelle', 'Adele']\n"
     ]
    }
   ],
   "source": [
    "names = ['Rachel', 'Phoebe', 'Annabelle', 'Eve', 'Katy', 'Rachel', 'Phoebe', 'Annabelle', 'Adele']\n",
    "class_01 = names[:3]\n",
    "class_02 = names[3:6]\n",
    "class_03 = names[6:]\n",
    "\n",
    "print(class_01)\n",
    "print(class_02)\n",
    "print(class_03)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Concatenation (Join 2 lists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cities: ['Tokyo', 'Singapore', 'Shanghai', 'Jakarta', 'Bangkok']\n",
      "american_cities: ['Los Angeles', 'Seattle', 'San Diego', 'Chicago']\n",
      "cities: ['Tokyo', 'Singapore', 'Shanghai', 'Jakarta', 'Bangkok', 'Los Angeles', 'Seattle', 'San Diego', 'Chicago', 'Los Angeles', 'Seattle', 'San Diego', 'Chicago']\n"
     ]
    }
   ],
   "source": [
    "cities = [\"Tokyo\", \"Singapore\", \"Shanghai\", \"Jakarta\", \"Bangkok\"]\n",
    "american_cities = [\"Los Angeles\", \"Seattle\", \"San Diego\", \"Chicago\"]\n",
    "\n",
    "print(\"cities:\", cities)\n",
    "print(\"american_cities:\", american_cities)\n",
    "\n",
    "# you can do this \n",
    "for city in american_cities:\n",
    "  cities.append(city)\n",
    "\n",
    "# or more succinctly \n",
    "cities = cities + american_cities\n",
    "\n",
    "print(\"cities:\", cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove duplicates from list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Tokyo', 'Singapore', 'Shanghai', 'Jakarta', 'Bangkok', 'Los Angeles', 'Seattle', 'San Diego', 'Chicago', 'Los Angeles', 'Seattle', 'San Diego', 'Chicago']\n",
      "['Singapore', 'Seattle', 'Jakarta', 'Los Angeles', 'San Diego', 'Chicago', 'Tokyo', 'Shanghai', 'Bangkok']\n"
     ]
    }
   ],
   "source": [
    "print(cities)\n",
    "cities = list(set(cities))\n",
    "print(cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a block of code which performs a specific task when called. A function accepts inputs as parameters and provides an output in the form of a result "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a Function\n",
    "A function is defined using the keyword def"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello_function(): # keyword def is used for function definition\n",
    "    print(\"Hello World!\") # This function prints out “Hello World!” when called"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calling a Function\n",
    "A function is called by writing out the function name followed by parenthesis "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "def hello_function():\n",
    "    print(\"Hello World!\")\n",
    "\n",
    "hello_function()  # The function is called in this statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arguments\n",
    "Information is passed on to the function in the form of an argument. It is specified after the function name within parenthesis. A function can have any number of arguments separated with a comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello John\n"
     ]
    }
   ],
   "source": [
    "def hello_name_function(name):   # The argument of the given function is name\n",
    "    print(\"Hello \"+ name)\n",
    "    \n",
    "hello_name_function(\"John\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function must be called with the exact number of arguments as specified in the function definition. \n",
    "\n",
    "You can send any data types of argument to a function (string, number, list, dictionary etc.), and it will be treated as the same data type inside the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return Values\n",
    "The output of a function is specified as the return value of the function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def square_function(x):   # The function takes the number to be squared as the input\n",
    "    return x*x            # The function returns the square of the function when called \n",
    "\n",
    "square_function(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports the following logical conditions for mathematics: \n",
    "- Equals: a==b \n",
    "- Not Equals: a!=b \n",
    "- Less Than: a<b \n",
    "- Greater Than: a>b \n",
    "- Lesser Than or Equal to: a<=b \n",
    "- Greater Than or Equal to: a>=b\n",
    "- And: a and b \n",
    "- Or: a or b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `if` Statement:\n",
    "The if statement in Python is written by using the keyword “if”. It is always necessary to use the correct indentation to avoid getting an error. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is greater than b\n"
     ]
    }
   ],
   "source": [
    "a = 400\n",
    "b = 300\n",
    "if a>b:    # This statement checks if the condition a being greater than b is satisfied \n",
    "    print(\"a is greater than b\")    # If the condition is satisfied this line is executed\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `elif` Statement:\n",
    "This statement is a way of saying “If the previous conditions fail but if this condition satisfied”. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is greater than b\n"
     ]
    }
   ],
   "source": [
    "a = 400\n",
    "b = 300\n",
    "if a>b: \n",
    "    print(\"a is greater than b\")\n",
    "elif a==b:         # This statement checks the new condition if the previous one fails \n",
    "    print(\"a is equal to be\")    # This line is executed if the new conditions is true\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `else` Statement:\n",
    "The else condition is used if all the previous statements are not satisfied \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is greater than b\n"
     ]
    }
   ],
   "source": [
    "a = 400\n",
    "b = 300\n",
    "if a>b:\n",
    "    print(\"a is greater than b\")\n",
    "elif a==b: \n",
    "    print(\"a is equal to b\")\n",
    "else:        # This statement in this program accounts for the condition that a<b. \n",
    "    print(\"a is lesser than b\") \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested `if`:\t\n",
    "An if statement within an if statement is a nested if statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a greater than b\n"
     ]
    }
   ],
   "source": [
    "a = 400\n",
    "b = 300\n",
    "if a != b:\n",
    "    if a > b:    # This is an example of an if statement used within an if statement\n",
    "        print(\"a greater than b\")\n",
    "    if a < b:\n",
    "        print(\"a lesser than b\")\n",
    "else:\n",
    "    print(\"a is equal to b\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `while` Loops\n",
    "### The Condition\n",
    "Using a while loop we can execute a set of statements as long as a given condition is satisfied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1        # The initial value of x is 1\n",
    "while x<=5:  # As long as x is lesser than or equal to 5 the loop is executed \n",
    "    x += 1   # The x value keeps getting incremented by 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `break` Statement\n",
    "The break statement can be used to break out of the while loop even when the given condition is satisfied"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "while x<=5:\n",
    "    x += 1 \n",
    "    if x==3:\n",
    "        break  # Even though x = 2 satisfies the condition the loop is broken \n",
    "    print(x) #loop broken so print(x) is not executed for x>=3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `continue` Statement\n",
    "Just like in the case of for loops, the continue statement allows the current iteration of the loop to be broken and moves to the next iteration "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "while x<=5:\n",
    "    x += 1 \n",
    "    if x==3:\n",
    "        continue  # Even though x = 2 satisfies the condition the current iteration is broken \n",
    "    print(x) # print(x) is skipped when x==3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `else` Statement \n",
    "The else statement can be used to execute a given block of code when the condition is not satisfied "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is greater than 5\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "while x<=5:\n",
    "    x += 1\n",
    "else:\n",
    "    print(\"The number is greater than 5\")   # This block of code is run when x>5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` Loop\n",
    "A for loop in Python is used in iterating over a sequence (a list, tuple, set, dictionary or a string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4]\n",
    "for i in lst:    # In this example the for loop is used to iterate over a list \n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `break` Statement:\n",
    "The break statement is used to break the for loop before it has looped through all the items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4]\n",
    "\n",
    "for i in lst:\n",
    "    print(i)\n",
    "    if i==2:\n",
    "        break    # When i = 2 the loop is broken\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `continue` Statement:\n",
    "The continue statement is used to break from the current iteration of the loop and continue with the next one\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "lst = [1,2,3,4]\n",
    "\n",
    "for i in lst:\n",
    "    print(i)\n",
    "    if i==2:\n",
    "        continue    # When i = 2 the current iteration of the loop is broken\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Range Function:\n",
    "The range() function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(6):\n",
    "    print(i)    # Numbers from 0 to 5 are printed "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The range() function defaults to 0 as a starting value, however it is possible to specify the starting value by adding a parameter: range(2, 6), which means values from 2 to 6 (but not including 6):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(2,6):\n",
    "    print(i)    # Numbers from 2 to 6 not including 6 are printed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The range() function defaults to increment the sequence by 1, however it is possible to specify the increment value by adding a third parameter: range(2, 30, 3):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(2,6,2):\n",
    "    print(i)    # Numbers 2,4 are printed \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib\n",
    "Matplotlib is a Python 2D plotting library which produces publication quality figures in a variety of hardcopy formats and interactive environments across platforms. TL;DR: Matplotlib is used to plot graphs.\n",
    "\n",
    "### pyplot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "matplotlib.pyplot is a collection of command style functions that make matplotlib work like MATLAB. Each pyplot function makes some change to a figure: e.g., creates a figure, creates a plotting area in a figure, plots some lines in a plotting area, decorates the plot with labels, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline \n",
    "# Jupyter plot formatting, should not be needed in other IDEs\n",
    "\n",
    "plt.plot([1, 2, 3, 4])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types of plots\n",
    "Using pyplot, you are able to plot these figures:\n",
    "\n",
    "- line plot (above)\n",
    "- scatter plot\n",
    "- histogram\n",
    "- box plot\n",
    "- bar plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scatter Plot\n",
    "plt.scatter(x,y) \n",
    "x and y can be lists for multiple points but lists must be of equal length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter([1,3,5],[2,4,6]) # Point 1=(1,2), Point 2=(3,4), Point 3=(5,6)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histogram\n",
    "plt.hist(values,bins)\n",
    "bins are the bracket in which the values which fulfil the criteria will be tallied, and displayed as a bar.\n",
    "bins usually only include the left side value on the number line (smaller value), with the exception of the last bin, which is inclusive of both left and right values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1., 2., 3.]), array([0, 1, 2, 3]), <a list of 3 Patch objects>)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = [0,1,1.5,2,2.5,3,4,5]\n",
    "\n",
    "plt.hist(x,[0,1,2,3]) # 2nd argument is the bins inside which the number of values are tallied 0<=x<1, 1<=x<2, 2<=x<=3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Box Plot\n",
    "Box plot is really useful for easily determining the median, upper quartile and lower quartile.\n",
    "The points outside of the whiskers are known as outliers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'box plot')"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "spread = np.random.rand(50) * 100\n",
    "center = np.ones(25) * 50\n",
    "flier_high = np.random.rand(10) * 100 + 100\n",
    "flier_low = np.random.rand(10) * -100\n",
    "data = np.concatenate((spread, center, flier_high, flier_low))\n",
    "#randomly generate values\n",
    "\n",
    "plt.boxplot(data)\n",
    "plt.title('box plot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bar Plot\n",
    "There are compulsory parameters in plt.bar(), first is the label of each bar. Below, this is in the form of a list called labels, containing the strings \"A\" and \"B\". Next parameter is the height, this is in [len(A),len(B)]. These 2 parameters are sufficient to plot a bar plots. Bar plots are important in comparing values of different categories, eg number of catlovers vs doglovers in SUTD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 2 artists>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "performance = [10,8,6,4,2,1]\n",
    "labels=[\"A\",\"B\"]\n",
    "A=[]\n",
    "B=[]\n",
    "for i in performance:\n",
    "    if i<5:\n",
    "        A+=[i]\n",
    "    else:\n",
    "        B+=[i]\n",
    "count=[len(A),len(B)]\n",
    "        \n",
    "plt.bar(labels,count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Labelling\n",
    "To label the title of the graph, you use the function plt.title(\"Title Name\") and to label the horizontal and vertical axes, you use the functions plt.xlabel(\"Horizontal Axis Label\") and plt.ylabel(\"Vertical Axis Label\") respectivel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([1, 2, 3, 4])\n",
    "plt.title(\"Title\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.xlabel(\"x\")\n",
    "plt.show()"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}