data_types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-WPhiNNFhk4N"
   },
   "source": [
    "# **Python tutorial: Working with basic data types**\n",
    "\n",
    "## Lesson series outline:\n",
    "\n",
    "This lesson covers some of the fundamentals of working with data types in Python. On completion of this lesson, you should be familiar with accessing and manipulating integers, floats, strings, lists and dictionaries. \n",
    "\n",
    "The Notebook is intended for users with no or minimal programming experience. Although syntax between programming languages vary, the basic principles acquired here will be transferable to other languages you pickup throughout your programming journey. \n",
    "\n",
    "Please drop me an email at josephellaway@gmail.com if you have any questions. \n",
    "\n",
    "\n",
    "\n",
    "### **Part 1)** Variables and data types\n",
    " - Integers\n",
    " - Floats\n",
    " - Strings\n",
    " - Lists\n",
    " - Dictionaries\n",
    " - ```type()```\n",
    "\n",
    "### **Part 2)** Numeric operators\n",
    " - Addition\n",
    " - Subtraction\n",
    " - Multiplication\n",
    " - Division\n",
    " - Modulous\n",
    "\n",
    "### **Part 3)** String manipulation\n",
    " - Slicing\n",
    " - Appending\n",
    " - Splitting\n",
    " - Removing\n",
    "\n",
    "### **Part 4)** Arrays - lists\n",
    " - Slicing\n",
    " - Appending\n",
    " - Removing\n",
    " \n",
    "### **Part 5)** Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EPh76jESx1_t"
   },
   "source": [
    "## **Part 1)** Variables and Data Types\n",
    "\n",
    "Variables are one of the fundamental features of any programming language. They allow us to store information in a computer's memory and can be accessed for manipulation by the program. Here, we will look at Python's basic data types (the variety of variables we have access to) and learn how to use them in a program. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integers\n",
    "a = 5\n",
    "b = 10\n",
    "c = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Floats\n",
    "d = 1.0\n",
    "e = 10.1\n",
    "f = 1/3\n",
    "g = 1/2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Strings\n",
    "tutor_fname = \"Joseph\"\n",
    "tutor_lname = 'Ellaway'\n",
    "greeting = \"Hello world!\"\n",
    "still_a_string = \"1234\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists\n",
    "number_list = [1, 2, 3, 4]\n",
    "\n",
    "string_list = [\"These\", \"are\", \"the\", \"elements\", \"of\", \"a\", \"list\"]\n",
    "\n",
    "list_of_lists = [[\"Embedded\", \"list\"], \n",
    "                 [1, 2, 3, 4], \n",
    "                 [\"Another\", \"embedded\", \"list\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tuples\n",
    "number_tuple = (1, 2, 3, 4)\n",
    "\n",
    "string_tuple = (\"These\", \"are\", \"the\", \"elements\", \"of\", \"a\", \"tuple\")\n",
    "\n",
    "tuple_of_tuples = ((\"Embedded\", \"list\"), \n",
    "                 (1, 2, 3, 4), \n",
    "                 (\"Another\", \"embedded\", \"list\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6pJ5se2fx5Hn"
   },
   "outputs": [],
   "source": [
    "# Dictionaries\n",
    "dict_1 = {\"key1\" : \"value1\",\n",
    "          \"key2\" : \"value2\",\n",
    "          \"key3\" : \"value3\"}\n",
    "\n",
    "dict_2 = {1 : 'string1',\n",
    "          2 : 'string2',\n",
    "          3 : 'string3'\n",
    "          }\n",
    "\n",
    "city_list = [('London', 'UK'), ('New York', 'US'), ('Tokyo', 'Japan')]\n",
    "dict_3 = dict(city_list)\n",
    "\n",
    "more_cities = ['Manchester', 'San Francisco', 'Kyoto']\n",
    "countries = ['UK', 'US', 'Japan']\n",
    "dict_4 = dict(zip(more_cities, countries))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sIJiUYU-70-x"
   },
   "source": [
    "## 1.1) User input and the ```print()``` function\n",
    "\n",
    "User input can be taken and fed into a Python program from the command line (or input/output box in Jupyter Notebook).\n",
    "\n",
    "The print function in Python allows us to print a variable to the command line, or the output window in Jupyter Notebook. \n",
    "\n",
    "This can allow us to visualise the changes we make to "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Y_tCrbZ47yPJ"
   },
   "outputs": [],
   "source": [
    "user_name = input(\"Enter your name: \")\n",
    "\n",
    "print('Hello ' + user_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tUp9UvKK0Gv5"
   },
   "source": [
    "We can also wrap user input inside of specific variable types in order to force the user to enter the correct input. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JuGJa70t0V2K"
   },
   "outputs": [],
   "source": [
    "user_fname = str( input('Enter your first name: ') )\n",
    "\n",
    "user_age = int( input('Enter your age: ') )\n",
    "\n",
    "print('User first name: ', user_fname, '\\nUser age: ', user_age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kbrjtnkt1Bjw"
   },
   "source": [
    "We can also retrieve the type of a variable using the built-in ```type()``` function in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0P2-QedE1BM4"
   },
   "outputs": [],
   "source": [
    "fname_type = type(user_fname)\n",
    "\n",
    "print(fname_type)\n",
    "\n",
    "# or more compact:\n",
    "\n",
    "print(type(user_fname))\n",
    "print(type(user_age))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pRNwk7L12IqU"
   },
   "source": [
    "## **Part 2)** Numeric Operators\n",
    "\n",
    "Maths can be easily performed in Python using it's built-in set of numeric operators. These are:\n",
    "\n",
    " - Addition: ```+```\n",
    " - Subtraction: ```-```\n",
    " - Multiplication: ```*```\n",
    " - Division: ```/```\n",
    " - Power: ```**```\n",
    " - Modulous: ```%```\n",
    "\n",
    "The modulous operator returns the difference from a division operation. e.g. ```5 % 3 = 2``` and ```6 % 3 = 0```.\n",
    "\n",
    "### **Exercise 1:**\n",
    "Use the numeric operators above to answer the following questions. Print your answers to the terminal using the ```print()``` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cVxM_Yon3Fy9"
   },
   "outputs": [],
   "source": [
    "# 1234 plus 4321\n",
    "\n",
    "# 789 minus 123\n",
    "\n",
    "# 13 multiplied by 99\n",
    "\n",
    "# 70 divided by 81\n",
    "\n",
    "# 81 cubed\n",
    "\n",
    "# Remainder of 123 divided by 12\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "30cxPab54STZ"
   },
   "source": [
    "Rounding to the nearest integer in programming is not simply as easy as converting a float to an integer. We need to employ two additional functions in Python, from which we import from something called a library. Libraries (sometimes called 'packages' or 'modules') are common to almost all programming languages and allow us to use pre-defined functions inside of our script, without having to copy and paste the entire source code into our program. \n",
    "\n",
    "The libaray for rounding floats up or down to the nearest integer is called ```math```. This libary contains many additional functions we can use to complement the set of basic numeris operators already built into Python. The ```ceil()``` and ```floor()``` functions will return a float ('decimal', in non-computing terms) rounded up or down to the nearest integer, respectively. \n",
    "\n",
    "Take a look at the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yESgexEw4eaC"
   },
   "outputs": [],
   "source": [
    "my_float = 1.5\n",
    "my_integer = int(my_float)\n",
    "print(my_integer)\n",
    "\n",
    "# This will import math module\n",
    "import math \n",
    "\n",
    "print(math.floor(-23.11))\n",
    "print(math.ceil(300.16))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XYFUh9I_6l0I"
   },
   "source": [
    "Notice how we write ```math.``` before each function call. This notation tells Python that the function we are using comes from the ```math``` libaray. We could have other functions called ```ceil()``` and ```floor()``` imported from other modules or created ourselves (explained later in the tutorial), and omitted the ```math.``` will prevent Python from disambiguating which libaray the function is being called from. \n",
    "\n",
    "Another useful function provided by ```math``` is the ```sqrt()``` function, which returns the square root of a given number.\n",
    "\n",
    "### **Exercise 2:**\n",
    "Using what you now know about function calls from libaries, find the square root of the first 10 prime numbers counting up from zero. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qIxw_uV78Od9"
   },
   "outputs": [],
   "source": [
    "# Enter code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JL5u3xk18Rs9"
   },
   "source": [
    "## **Part 3)** String Manipulation\n",
    "\n",
    "We have already looked at how strings can be stored as variables and how we can take in strings from the user from the command line. We will now look at how strings can be manipulated (changed, copied, sliced, etc). \n",
    "\n",
    "Take a look at and run the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "x38mjDic85JL"
   },
   "outputs": [],
   "source": [
    "# Greeting message\n",
    "\n",
    "long_greeting = \" Hello there, what nice weather we are having! \""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WY9xU40D9Bmt"
   },
   "source": [
    "The ```long_greeting``` variable currently stores a message in the form of a string. We can make a copy of ```long_greeting``` by creating another variable and setting it equal to ```long_greeting```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ix0WZb529XWa"
   },
   "outputs": [],
   "source": [
    "# Copying greeting\n",
    "long_greeting_copy = long_greeting \n",
    "long_greeting_copy += \"Very warm\"\n",
    "\n",
    "print(long_greeting)\n",
    "print(long_greeting_copy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VS1i_ozMHlth"
   },
   "outputs": [],
   "source": [
    "example_counter = 0\n",
    "example_counter += 1\n",
    "example_counter += 10\n",
    "example_counter -= 5\n",
    "example_counter /= 3\n",
    "example_counter *= 5\n",
    "\n",
    "print(example_counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PWPyMxl29knB"
   },
   "source": [
    "A copy of ```long_greeting``` has now been made, called ```long_greeting_copy```. Let's look at how we can find out the length of the message variable. \n",
    "\n",
    "Python has a built-in function called ```len()```, which returns the number of characters in a given string, array (e.g. list), or dictionary.\n",
    "\n",
    "### **Exercise 3:**\n",
    "\n",
    "How many characters are in the string ```long_greeting``` (i.e. length of the string)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZamHMukM-2_G"
   },
   "outputs": [],
   "source": [
    "# Enter your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KrP01ywe_CfY"
   },
   "source": [
    "Another feature of lists in Python is there ability to be 'sliced'. This means selecting a range of characters from the string and returning them either to a variable or to a function, like ```print()```. In programming, an index is used to denote the position of the element (characters in the case of a string), allowing us to select specific characters from our string. In Python, the starting index is set as ```0```. This means that the first character in the ```long_greeting``` variable is at position ```0```. In other programming languages, the starting index is ```1```, so make sure to check for your given language. \n",
    "\n",
    "Below are some examples of using index notation to slice our ```long_greeting``` string. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oc8y49wQ_Mrh"
   },
   "outputs": [],
   "source": [
    "# Selecting a single character from the string\n",
    "first_character = long_greeting[0]\n",
    "fifth_character = long_greeting[4]\n",
    "last_character = long_greeting[-1]      # Use negative integers to select from \n",
    "                                        # the other end of the string\n",
    "\n",
    "# Selecting a range of characters from the string\n",
    "start_slice = long_greeting[ : 6 ]         # A colon separates start-end positions \n",
    "middle_slice = long_greeting[10:15]\n",
    "end_slice = long_greeting[ -5 : ]\n",
    "\n",
    "print( end_slice )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fxxTJWiOB_bH"
   },
   "source": [
    "### **Exercise 4:**\n",
    "\n",
    "print out the word ```weather``` from the ```long_greeting``` string variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mHp34YHdCSxx"
   },
   "outputs": [],
   "source": [
    "# Enter code below\n",
    "long_greeting = \" Hello there, what nice weather we are having! \""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9xHOY4t1CWMZ"
   },
   "source": [
    "Another useful tool built into Python is the ```strip()``` method. Methods are similar to functions as they outsource some of the work to a pre-writted block of code. All we do is called the function/method and that block of code is executed. Methods differ from functions in the way we call them. For example, to call a function we would use the syntax: ```my_function(my_variable)```. However, methods are called on variables using the following syntax: ```my_variable.my_method()```. \n",
    "\n",
    "Take a look at the code below to see how methods are colled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1u8t_J_aCv6G"
   },
   "outputs": [],
   "source": [
    "# Creating a new variable lacking whitespace at either end\n",
    "whitespace_variable = \"    Added space at start, added space at the end.    \"\n",
    "\n",
    "whitespace_variable_stripped = whitespace_variable.strip()\n",
    "\n",
    "print(whitespace_variable_stripped)\n",
    "\n",
    "user_fname = input(\"Enter your first name: \")\n",
    "user_fname = user_fname.strip()\n",
    "\n",
    "# Print length of user name\n",
    "print( len(user_fname) )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "628u5_l_EMPS"
   },
   "source": [
    "To complement ```strip()```, Python has two additional methods called ```rstrip()``` and ```lstrip()```, which remove trailing whitespace from the right and left sides of the string, respectively. \n",
    "\n",
    "### **Exercise 5:**\n",
    "\n",
    "The ```long_greeting``` variable contains whitespace at both ends. Create a variable that has this whitespace removed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PpiuDeO9E4KR"
   },
   "outputs": [],
   "source": [
    "# Enter code below\n",
    "long_greeting = \" Hello there, what nice weather we are having! \""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OYf8CI1fE6Sp"
   },
   "source": [
    "We can also use the ```replace()``` method one strings to eliminated a selection of elements or replace them with something else. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "urgesa6f4n3i"
   },
   "outputs": [],
   "source": [
    "# Replacing letters in string\n",
    "another_greeting = \"Hello world!\"\n",
    "print(another_greeting)\n",
    "\n",
    "another_greeting = another_greeting.replace('!', '?')\n",
    "print(another_greeting)\n",
    "\n",
    "print()\n",
    "# Removing whitespace from string\n",
    "cat_message = \"Meow meow meow meow\"\n",
    "print(cat_message)\n",
    "\n",
    "cat_message = cat_message.replace(' ', '')\n",
    "print(cat_message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hDMmX19tBkkc"
   },
   "outputs": [],
   "source": [
    "# Removing whitespace from string\n",
    "cat_message = \"Meow meow meow meow\"\n",
    "print(cat_message)\n",
    "\n",
    "cat_message = cat_message.lower()\n",
    "cat_message = cat_message.replace('m', '')\n",
    "print(cat_message)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x8k7DwyK6KFi"
   },
   "source": [
    "We can also use the methods ```lower()``` and ```upper()``` to change the case of the characters in a string. This can be useful for dealing with user input, where some letters in a name can be either upper or lower case. \n",
    "\n",
    "Finally, the ```split()``` method allows us to convert a string into a Python array called a 'list'. ```split()``` will convert each element in a string into a set of elements contained within a list, using a given separater (default is a single space). Take a look at the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Y5k7XML76u0P"
   },
   "outputs": [],
   "source": [
    "# Splitting a string into a list\n",
    "dog_message = \"Bark woof bark woof\"\n",
    "dog_list = dog_message.split()\n",
    "\n",
    "print(dog_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1bR-n39P7Dfy"
   },
   "source": [
    "The code above removes all the spaces from the string, separating each word into a new string element contained by a list. Let's look at how choosing a different delimiter from the default affects the outcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7EsAfdEP7ZND"
   },
   "outputs": [],
   "source": [
    "# Splitting a string into a list based on a given character\n",
    "twitter_message = \"Tweet tweet tweet tweet\"\n",
    "twitter_list = twitter_message.split('w')\n",
    "print(twitter_list)\n",
    "\n",
    "twitter_message_2 = \"Tweet woof,tweet,tweet,tweet\"\n",
    "twitter_list_2 = twitter_message_2.split(',')\n",
    "\n",
    "print(twitter_list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kLzmRNXU7vRQ"
   },
   "source": [
    "See how all instances of the ```w``` character have vanished and the list now contains all sections of the original string as elements, splicing it on either side of the ```w``` character. _Note_, Python is case sensitive so using ```W``` would have produced a list of only one string element. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eLKNRBI_8OqO"
   },
   "source": [
    "### **Exercise 6**:\n",
    "\n",
    "Write a short program that takes a user's full name as input and returns their name as a single list, where each element contains only consonants. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dRsRbLFr9ZUV"
   },
   "outputs": [],
   "source": [
    "# Write code below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5A1J1T3q9cij"
   },
   "source": [
    "## **Part 4)** Arrays -> Lists\n",
    "\n",
    "Python's default array is a data type called the list. Lists are mutable (can be changed) objects which can themselves contain any other type of Python object, including lists themselves. \n",
    "\n",
    "Just like strings, lists can be sliced using the same syntax (```[]``` notation). We can also find out their length using the exact same function, ```len()```.\n",
    "\n",
    "### Exercise 7:\n",
    "Slice the list in the code block below to print out the first half of the elements. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LjXRg_fawPMp"
   },
   "outputs": [],
   "source": [
    "# Slicing\n",
    "\n",
    "my_string = \"Hello world!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LI9SCFneCl_d"
   },
   "source": [
    "We can add elements to a list by using the ```append()``` method, where the element we wish to add is entered as an argument (inside the method's brackets). Take a look at the example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1QRq0EJQxKxD"
   },
   "outputs": [],
   "source": [
    "my_string = \"Hello world\"\n",
    "\n",
    "print( len(my_string) )\n",
    "\n",
    "print( my_string.upper() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bKWU_-3TC6lL"
   },
   "outputs": [],
   "source": [
    "# Appending another first name to the list\n",
    "fnames = [\"Zadok\", \"Joseph\"]\n",
    "\n",
    "print(fnames)\n",
    "\n",
    "fnames.append(\"Katerina\")\n",
    "\n",
    "print(fnames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NB_388r3DQb0"
   },
   "source": [
    "By default, ```append()``` will always add new elements to the end of the list. In order to add new elements to a list at a specific position within the list, we need to use the ```insert()``` method, which takes two arguments -- the index and the element. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vdUx_iniDifp"
   },
   "outputs": [],
   "source": [
    "# Inserting a new element at index 3\n",
    "fnames.insert(1, \"Thomas\")\n",
    "\n",
    "print(fnames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3h78LzYiDtko"
   },
   "source": [
    "### Exercise 8:\n",
    "Add the following students to the list. \n",
    " - James\n",
    " - Hannah\n",
    "\n",
    "James must be the 4th student in the list and Hannah must be the last."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BaMziGc8ECN3"
   },
   "outputs": [],
   "source": [
    "# Write code below\n",
    "fnames = [\"Daniel\", \"Joseph\", \"Katerina\", \"Thomas\", \"Harvey\", \"John\", \"Anthony\", \"Natalie\"]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W5DnmKUiEFAk"
   },
   "source": [
    "Lists can also have their elements changed. We can use the slicing notation we have looked at in order to change one element to another. Take a look at this example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "saFYkknzMwBo"
   },
   "outputs": [],
   "source": [
    "# Updating a list\n",
    "fnames[2] = 123908123\n",
    "\n",
    "print(fnames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QiB4adP9M6fU"
   },
   "source": [
    "We can see that the entry ```\"Jack\"``` has now been changed to the string ```\"Alex\"``` because ```\"Jack\"``` was originally at index ```2``` in the list (remember that Python starts indexing at zero). \n",
    "\n",
    "Finally, we can remove entries (elements) from a list using either the ```remove()``` or ```pop()``` methods. Let's see how these works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "frOgQYo-NadP"
   },
   "outputs": [],
   "source": [
    "# Removing Alex from the list\n",
    "fnames.remove(\"Alex\") # remove comment to run\n",
    "print(fnames)\n",
    "\n",
    "fnames.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nPp7YfAs4STA"
   },
   "outputs": [],
   "source": [
    "# Remove method\n",
    "fnames = ['Zadok', 'Joseph', 'Katerina', 'Thomas', 'Harvey', 'John', 'Anthony', 'James', 'Natalie', 'Hannah']\n",
    "\n",
    "print(fnames)\n",
    "\n",
    "for name in [\"John\", \"Natalie\", \"Anthony\"]:\n",
    "  fnames.remove(name)\n",
    "\n",
    "print(fnames)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WVC_kddVNmsy"
   },
   "source": [
    "See how we enter the element we wish to remove when calling ```remove()```, whereas we specify the index we wish to remove with ```pop()```. ```pop()``` also returns the element being remove as soon as it is called; we do not need an additional print statement. \n",
    "\n",
    "## Exercise 9:\n",
    "\n",
    "Remove the last three entries from the lists below and print the results to the terminal. You should write one line of code, which should work on both lists without changing anything other than the variable name. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qqIbZ7DXOtDV"
   },
   "outputs": [],
   "source": [
    "# Input lists\n",
    "interger_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "list_of_integers = ['1', '2', '3', '4', '5', '6', '7', '8', '9']\n",
    "\n",
    "# Write code below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tR0l5eNdPdPl"
   },
   "source": [
    "### Exercise 10:\n",
    "\n",
    "Write some code that takes in a string from the user and add it to a new list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-VvAfq-mPnde"
   },
   "outputs": [],
   "source": [
    "# Write code below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u49g0j9mPuf3"
   },
   "source": [
    "## Part 4) Dictionaries\n",
    "\n",
    "The dictionary is a key-value data structure. They are similar to lists in that any Python data structure can be input as a value (including dictionaries themselves) but instead of accessing the values using the index position, we access them using the specified key. \n",
    "\n",
    "We have already defined some dictionaries, using four different approaches, in this notebook so let's print one of them out. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3yEoLH8nQawG"
   },
   "outputs": [],
   "source": [
    "# Dictionaries\n",
    "dict_1 = {\"key1\" : \"value1\",\n",
    "          \"key2\" : \"value2\",\n",
    "          \"key3\" : \"value3\"}\n",
    "\n",
    "\n",
    "classroom_dict = {\"Computing\" : [\"Emily\", \"Jack\", \"Toby\"], \n",
    "                  \"Maths\" : [\"Thom\", \"Zadok\", \"Natalie\"],\n",
    "                  \"Physics\" : [\"Matthew\", \"Angela\", \"Tiara\"],\n",
    "                  \"Biology\" : [\"Joseph\", \"Sara\", \"James\"]\n",
    "                  }\n",
    "\n",
    "\n",
    "classroom_list = [ [\"Emily\", \"Jack\", \"Toby\"], [\"Thom\", \"Zadok\", \"Natalie\"], [\"Matthew\", \"Angela\", \"Tiara\"], [\"Isaac\", \"Cara\", \"Siwat\"], [\"Joseph\", \"Sara\", \"James\"]  ]\n",
    "\n",
    "\"\"\"\n",
    "computing = 0\n",
    "maths = 1\n",
    "physics = 2\n",
    "history = 3\n",
    "biology = 4\n",
    "\"\"\"\n",
    "\n",
    "dict_2 = {987123 : 'string1',\n",
    "          98123 : 'string2',\n",
    "          1273 : 'string3'\n",
    "          }\n",
    "\n",
    "city_list = [ ('London', 'UK'), ('New York', 'US'), ('Tokyo', 'Japan') ]\n",
    "dict_3 = dict(city_list)\n",
    "\n",
    "print(dict_3)\n",
    "\n",
    "more_cities = ['Manchester', 'San Francisco', 'Kyoto']\n",
    "countries = ['UK', 'US', 'Japan']\n",
    "dict_4 = dict( zip(more_cities, countries) )\n",
    "\n",
    "print(dict_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o72NhTcHQlKP"
   },
   "source": [
    "We can access one of this dictionary's values by giving it it's corresponding key. Take a look:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DigooZpSQx-c"
   },
   "outputs": [],
   "source": [
    "classroom_dict = {\"Computing\" : [\"Emily\", \"Jack\", \"Toby\"], \n",
    "                  \"Maths\" : [\"Thom\", \"Zadok\", \"Natalie\"],\n",
    "                  \"Physics\" : [\"Matthew\", \"Angela\", \"Tiara\"],\n",
    "                  \"Biology\" : [\"Joseph\", \"Sara\", \"James\"]\n",
    "                  }\n",
    "\n",
    "classroom_dict[\"Maths\"]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UMGnWxAFq1dg"
   },
   "source": [
    "### **Exercise 11:**\n",
    "\n",
    "Write a short program to take a user's intput (first name, last name and age) and convert this information into a dictionary. The dictionary must contain the user's last name as the dictionary's key and have one value -- a list containing two elements: the user's first name and age. \n",
    "\n",
    "Here is an example of the dictionary created from a user ('Jane Doe', 35). \n",
    "\n",
    "```\n",
    "user_dictionary = {'Doe' : ['Jane', 35]}\n",
    "```\n",
    "\n",
    "Print the dictionary created to the terminal. \n",
    "\n",
    "You will have to use several techniques learned so far to make this program function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1c0PAK6rsZrY"
   },
   "outputs": [],
   "source": [
    "# Enter code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FBnBGk55sdho"
   },
   "source": [
    "Back at the start of this tutorial, we looked at several ways to instantiate (create) Python dictionaries. We will use one of the methods that converts two lists into a single dictionary and then update it by adding new entries. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YI8QEqjpByrl"
   },
   "outputs": [],
   "source": [
    "# Instantiating a new list\n",
    "keys = [1, 2, 3, 4]\n",
    "values = ['Julia', 'Susan', 'Emily', 'Rachel']\n",
    "\n",
    "roster_dictionary = dict(zip(keys, values))\n",
    "\n",
    "print(roster_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BcwLvFgzCj2J"
   },
   "source": [
    "There are two approaches to adding new entries to an existing Python dictionary, one where a dictionary is already present and another where one does not yet exist. Take a look at the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4IKhxb0mCxi3"
   },
   "outputs": [],
   "source": [
    "# Adding key-value pair directly\n",
    "roster_dictionary[5] = 'Mary'\n",
    "\n",
    "print(roster_dictionary)\n",
    "\n",
    "# Adding another dictionary to roster_dictionary\n",
    "new_entry = {6 : 'Dianne', \n",
    "             7 : 'Nikki'}\n",
    "\n",
    "roster_dictionary.update(new_entry)\n",
    "\n",
    "print(roster_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xoI7l9uzDTxQ"
   },
   "source": [
    "Just like we saw with lists, we can use the first approach to replace a value with a different value by calling the dictionary's key. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dOPtcVwKDfOT"
   },
   "outputs": [],
   "source": [
    "# Updating last entry\n",
    "roster_dictionary[7] = 'Zoe'\n",
    "print(roster_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "n4oeqJoMD1JA"
   },
   "source": [
    "Finally, the ```del ``` keyword is used to remove a value from a dictionary, given a specific key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eEBCf6wmD8Qt"
   },
   "outputs": [],
   "source": [
    "del roster_dictionary[7]\n",
    "\n",
    "print(roster_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "grO1S67TEcDs"
   },
   "source": [
    "Notice how this notation differs from our previous call of functions and methods. This is because ```del``` is a keyword in Python that flushes whatever is returned to it from memory. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t9agKg8YE4PX"
   },
   "source": [
    "### **Exercise 12:**\n",
    "\n",
    "Add some code below to update the existing dictionary with a new user, given by the user. The keys must be the user's surname and value a list of their first name and age. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "plcU6YDYENBg"
   },
   "outputs": [],
   "source": [
    "user_information = {'Smith' : ['Jane', 45], \n",
    "                    'Dwier' : ['Andy', 39],\n",
    "                    'Malone' : ['Kevin', 37],\n",
    "                    'Howard' : ['Ryan', 28]\n",
    "                    }\n",
    "\n",
    "# Enter code below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0bOnIjT7cpbi"
   },
   "source": [
    "### **Exercise 13:**\n",
    "\n",
    "Convert the two lists into a dictionary, where its keys are integers and values are strings. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JnOH82q2c1GL"
   },
   "outputs": [],
   "source": [
    "# Create a dictionary from these lists\n",
    "list1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "list2 = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Python_tutorial_basics_220111.ipynb",
   "private_outputs": true,
   "provenance": [
    {
     "file_id": "1KN1XR_77kUyXhTsV0_pVTZTjh046xEAp",
     "timestamp": 1641917544460
    }
   ]
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}