PythonIntroCh5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "< [Functions](PythonIntroCh4.ipynb) | [Contents](PythonIntro.ipynb) | [For Loop](PythonIntroCh6.ipynb) >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.\tTuples, Lists, and Dictionaries\n",
    "## 5.1\tIntroduction\n",
    "Your brain still hurting from the last lesson? Never worry, this one will require a little less thought. We're going back to something simple - variables - but a little more in depth.\n",
    "\n",
    "Think about it - variables store one bit of information. They may regurgitate (just not on the carpet...) that information at any point, and their bit of information can be changed at any time. Variables are great at what they do - storing a piece of information that may change over time.\n",
    "\n",
    "But what if you need to store a long list of information, which doesn't change over time? Say, for example, the names of the months of the year. Or maybe a long list of information that does change over time? Say, for example, the names of all your cats. You might get new cats, some may die, some may become your dinner (we should trade recipies!). What about a phone book? For that you need to do a bit of referencing - you would have a list of names, and attached to each of those names, a phone number. How would you do that?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.2\tThe Solution - Lists, Tuples, and Dictionaries\n",
    "For these three problems, Python uses three different solutions - Tuples, Lists, and Dictionaries:\n",
    "* **Lists** are what they seem - a list of values. Each one of them is numbered, starting from zero - the first one is numbered zero, the second 1, the third 2, etc. You can remove values from the list, and add new values to the end. Example: Your many cats' names.\n",
    "* **Tuples** are just like lists, but you can't change their values. The values that you give it first up, are the values that you are stuck with for the rest of the program. Again, each value is numbered starting from zero, for easy reference. Example: the names of the months of the year.\n",
    "* **Dictionaries** are similar to what their name suggests - a dictionary. In a dictionary, you have an 'index' of words, and for each of them a definition. In Python, the word is called a 'key', and the definition a 'value'. The values in a dictionary aren't numbered - they aren't in any specific order, either - the key does the same thing. You can add, remove, and modify the values in dictionaries. Example: telephone book."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2.1 Tuples\n",
    "Tuples are pretty easy to make. You give your tuple a name, then after that the list of values it will carry. For example, the months of the year:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "months = ('January','February','March','April','May','June',\\\n",
    "'July','August','September','October','November','  December')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Note that the `\\` thingy at the end of the first line carries over that line of code to the next line. It is useful way of making big lines more readable.\n",
    "* Technically you don't have to put those parentheses there (the `(` and `)` thingies) but it stops Python from getting things confused.\n",
    "* You may have spaces after the commas if you feel it necessary - it doesn't really matter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python then organises those values in a handy, numbered index - starting from zero, in the order that you entered them in. It would be organised like this:<br>\n",
    "\n",
    "| Index | Value |\n",
    "| :---: | :---: |\n",
    "| 0 | January |\n",
    "| 1 | February |\n",
    "| 2 | March |\n",
    "| 3 | April |\n",
    "| 4 | May |\n",
    "| 5 | June |\n",
    "| 6 | July |\n",
    "| 7 | August |\n",
    "| 8 | September |\n",
    "| 9 | October |\n",
    "| 10 | November |\n",
    "| 11 | December |\n",
    "And that is tuples! Really easy..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2.2 Lists\n",
    "Lists are extremely similar to tuples. Lists are modifiable (or 'mutable', as a programmer may say), so their values can be changed. Most of the time we use lists, not tuples, because we want to easily change the values of things if we need to.\n",
    "\n",
    "Lists are defined very similarly to tuples. Say you have FIVE cats, called Tom, Snappy, Kitty, Jessie and Chester. To put them in a list, you would do this:<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cats = ['Tom', 'Snappy', 'Kitty', 'Jessie', 'Chester']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you see, the code is exactly the same as a tuple, EXCEPT that all the values are put between square brackets, not parentheses. Again, you don't have to have spaces after the comma.\n",
    "\n",
    "You recall values from lists exactly the same as you do with tuples. For example, to print the name of your 3rd cat you would do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(cats[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also recall a range of examples, like above, for example - `cats[0:2]` would recall your 1st and 2nd cats. Try it in the field above.\n",
    "\n",
    "Where lists come into their own is how they can be modified. To add a value to a list, you use the `append()` function. Let's say you got a new cat called Catherine. To add her to the list you'd do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cats.append('Catherine')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the field below to check if the cat has been added to the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's a little weird, isn't it? I'll explain. That function is in a funny spot - after a period `.` after the list name. You'll get to see those things more in a later lesson. For the meanwhile, this is the form of the function that adds a new value to a list:\n",
    "```Python\n",
    "#add a new value to the end of a list:\n",
    "list_name.append(value-to-add)\n",
    "\n",
    "#e.g. to add the number 5038 to the list 'numbers':\n",
    "numbers.append(5038)\n",
    "```\n",
    "\n",
    "Clears things up? Good!\n",
    "Now to a sad situation - Snappy was shot by a neighbour, and eaten for their dinner (good on 'em!). You need to remove him (or her) from the list. Removing that sorry cat is an easy task, thankfully, so you have to wallow in sadness for as short a time as possible:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Remove your 2nd cat, Snappy. Woe is you.\n",
    "del cats[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check again which cats are in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You've just removed the 2nd cat in your list - poor old Snappy.\n",
    "And with that morbid message, lets move on to..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3 Dictionaries\n",
    "Okay, so there is more to life than the names of your cats. You need to call your sister, mother, son, the fruit man, and anyone else who needs to know that their favourite cat is dead. For that you need a telephone book.\n",
    "\n",
    "Now, the lists we've used above aren't really suitable for a telephone book. You need to know a number based on someone's name - not the other way around, like what we did with the cats. In the examples of months and cats, we gave the computer a number, and it gave us a name. This time we want to give the computer a name, and it gives us a number. For this we need *Dictionaries*.\n",
    "\n",
    "So how do we make a dictionary? Put away your binding equipment, it isn't that advanced.\n",
    "Remember, dictionaries have keys, and values. In a phone book, you have people's names, then their numbers. See a similarity?\n",
    "\n",
    "When you initially create a dictionary, it is very much like making a tuple or list. Tuples have `(` and `)` things, lists have `[` and `]` things. Guess what! Dictionaries have `{` and `}` things - curly braces. Here is an example below, showing a dictionary with four phone numbers in it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Make the phone book:\n",
    "phonebook = {'Andrew Parson':8806336, \\\n",
    "'Emily Everett':6784346, 'Peter Power':7658344, \\\n",
    "'Lewis Lame':1122345}\n",
    "print(phonebook['Lewis Lame'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you run it you see that Lewis Lame's number is printed onscreen. Notice how instead of identifying the value by a number, like in the cats and months examples, we identify the value, using another value - in this case the person's name.\n",
    "\n",
    "Ok, you've created a new phone book. Now you want to add new numbers to the book. What do you do? A very simple line of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Add the person 'Gingerbread Man' to the phonebook:\n",
    "\n",
    "phonebook['Gingerbread Man'] = 1234567\n",
    "\n",
    "# Didn't think I would give you\n",
    "# my real number now, would I?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All that line is saying is that there is a person called Gingerbread Man in the phone book, and his number is `1234567`. In other words - the key is `Gingerbread Man`, and the value is `1234567`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if it's added using the field below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You delete entries in a dictionary just like in a list. Let's say Andrew Parson is your neighbour, and shot your cat. You never want to talk to him again, and therefore don't need his number. Just like in a list, you'd do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del phonebook['Andrew Parson']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, very easy. the `del` operator deletes any function, variable, or entry in a list or dictionary (An entry in a dictionary is just a variable with a number or text string as a name. This comes in handy later on.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if the number is gone using the field below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that append function that we used with the list? Well, there are quite a few of those that can be used with dictionaries. Below, I will write you a program, and it will incorporate some of those functions in. It will have comments along the way explaining what it does. Experiment as much as you like with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#A few examples of a dictionary\n",
    "\n",
    "#First we define the dictionary\n",
    "#it will have nothing in it this time\n",
    "ages = {}\n",
    "\n",
    "#Add a couple of names to the dictionary\n",
    "ages['Sue'] = 23\n",
    "ages['Peter'] = 19\n",
    "ages['Andrew'] = 78\n",
    "ages['Karren'] = 45\n",
    "\n",
    "#Use an 'if' statement to find a key in the list.\n",
    "#Remember - this is how 'if' statements work -\n",
    "#they run if something is true\n",
    "#and they don't when something is false.\n",
    "if 'Sue' in ages:\n",
    "    print(\"Sue is in the dictionary. She is\", \\\n",
    "ages['Sue'], \"years old\")\n",
    "\n",
    "else:\n",
    "    print(\"Sue is not in the dictionary\")\n",
    "\n",
    "#Use the function keys() - \n",
    "#This function returns a list\n",
    "#of all the names of the keys.\n",
    "#E.g.\n",
    "print(\"The following people are in the dictionary:\")\n",
    "print(ages.keys())\n",
    "\n",
    "#You could use this function to\n",
    "#put all the key names in a list:\n",
    "keys = ages.keys()\n",
    "\n",
    "#You can also get a list\n",
    "#of all the values in a dictionary.\n",
    "#You use the values() function:\n",
    "print(\"People are aged the following:\", \\\n",
    "ages.values())\n",
    "\n",
    "#Put it in a list:\n",
    "values = ages.values()\n",
    "\n",
    "#You can sort lists, with the sorted() function\n",
    "#It will sort all values in a list\n",
    "#alphabetically, numerically, etc...\n",
    "#You can't sort dictionaries - \n",
    "#they are in no particular order\n",
    "print(keys)\n",
    "sortedkeys = sorted(keys)\n",
    "print(sortedkeys)\n",
    "\n",
    "print(values)\n",
    "sortedvalues = sorted(values)\n",
    "print(sortedvalues)\n",
    "\n",
    "#You can find the number of entries\n",
    "#with the len() function:\n",
    "print(\"The dictionary has\", \\\n",
    "len(ages), \"entries in it\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.3 Conclusion\n",
    "There are many other functions you can use to work with lists and dictionaries - too many to go through right now. We'll leave the lesson at this point - you have learnt enough for one lesson."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "< [Functions](PythonIntroCh4.ipynb) | [Contents](PythonIntro.ipynb) | [For Loop](PythonIntroCh6.ipynb) >"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}