Session 3a_ [({collections})].ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CDCS Training Programme\n",
    "# Introduction to Python\n",
    "## Session 3a: [({collections})]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------\n",
    "\n",
    "### Learning objectives for this session:\n",
    "\n",
    "At the end of this notebook you will know:\n",
    "\n",
    "- How to use lists within Python.\n",
    "- Why we might instead use Tuples or Sets.\n",
    "- How to utilise dictionaries to store multiple collections.\n",
    "- How to deal with real world data with lists of dictionaries, and dictionaries of lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------\n",
    "\n",
    "## 1. Storing many items in a LIST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**LIST**: Collection of similar, ordered values, refered to by their index: 0,1,2,3,...\n",
    "\n",
    "A list can change. Keys are numbers from 0, and come with lots of functions/methods**.\n",
    "\n",
    "You can store all of the variables from above example in one 'collection' of variables.\n",
    "\n",
    "- Use LIST to keep a list of items that are similar.\n",
    "- You will be able to access them e.g. to find or change them, with their 'index' - where in the row they are.\n",
    "- Often used when order is meaningful.\n",
    "\n",
    "You can think of a Python LIST as a - shelf with books; a queue of people waiting for a bus; list of student names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are many ways to store a number of connected variables.\n",
    "\n",
    "planet0 = \"Mercury\"\n",
    "planet1 = \"Venus\"\n",
    "planet2 = \"Earth\"\n",
    "planet3 = \"Mars\"\n",
    "planet4 = \"Jupyter\"\n",
    "planet5 = \"Saturn\"\n",
    "planet6 = \"Uranus\"\n",
    "\n",
    "# But using a lot of simmilarly named variables stops making sense very quickly.\n",
    "# Imagine there were 300 planets to remember. \n",
    "# ...Or that you had to quickly say how many planets you have.\n",
    "# ...Or that you want to remove the first planet, but keep the others! \n",
    "# You'd have to rename all of your variables!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To create a list variable, just surround your values in square brackets, and assign it to a variable.\n",
    "\n",
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\", \"Saturn\", \"Uranus\"]\n",
    "\n",
    "print(planets[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below you will learn how to put things into a list, take things out of a list, change it, etc.\n",
    "\n",
    "**IMPORTANT: We count starting from 0**: in Python (and most other programming languages) we do not count like humans, starting from 1, as in '1,2,3,...' but rather we count starting from 0. So '0,1,2,3,...' . This means that the first item in a list is accessed by ```list_name[0]```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access items in a list:\n",
    "\n",
    "print(planets[0]) # The first planet is...\n",
    "print(planets[2]) # The third item...\n",
    "print(planets[-2]) # Second planet from the end is..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(planets[20]) \n",
    "\n",
    "# Watch out: you cannot request an index that does not exist.\n",
    "# Read the error.\n",
    "# As always, read it from the bottom, and look for the arrow ---> it points to the problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typically we want to determine some properties of a list. For example its length, or how many times an item occurs within it. We may also just be interested in the index of a particular item for later usage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(planets))\n",
    "\n",
    "# 'len()' is a build-in Python function, like 'print()'. \n",
    "# It returns 'length of collection'.\n",
    "# You might have seen it already somewhere."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(planets.count(\"Earth\")) # How many 'Earths' are there?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will not error when there are no such items. \n",
    "# It will just say there are no 'Kryptons' found in the solar system.\n",
    "\n",
    "print(planets.count(\"Krypton\") )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(planets.index(\"Mars\")) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planets.index(\"Krypton\") \n",
    "# Read the error! From the bottom! Then follow the '---->'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typically we may want to remove and add elements to our lists. We can do this fairly easily using the '.pop' and '.append' commands (and others too). Check their usage out below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\", \"Saturn\", \"Uranus\"]\n",
    "\n",
    "print(planets)\n",
    "removed_third_planet = planets.pop(2) # Remove item at this index AND RETURN IT. So that you can save it in a variable. \n",
    "print(planets)\n",
    "\n",
    "print(removed_third_planet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\", \"Saturn\", \"Uranus\"]\n",
    "\n",
    "print(planets)\n",
    "last_planet = planets.pop() # If no index is specified in 'pop()', the LAST element is removed AND RETURNED.\n",
    "print(planets)\n",
    "\n",
    "print(last_planet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another way to delete an item at index. It's quite rare, because it has a weird syntax.\n",
    "\n",
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\", \"Saturn\", \"Uranus\"]\n",
    "\n",
    "print(planets)\n",
    "del planets[2]\n",
    "print(planets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\", \"Saturn\",\"Uranus\"]\n",
    "\n",
    "print(planets)\n",
    "planets.remove(\"Venus\") # Remove one by value (if many of the same value are present, remove the first instance).\n",
    "print(planets)\n",
    "\n",
    "# Try it with:\n",
    "# planets.remove(\"Krypton\") \n",
    "# This will error?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\", \"Saturn\",\"Uranus\"]\n",
    "\n",
    "print(planets)\n",
    "planets.clear() # delete all\n",
    "print(planets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add one at the end.\n",
    "\n",
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\"]\n",
    "\n",
    "print(planets)\n",
    "planets.append(\"Pluto\") \n",
    "print(planets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add one at a specific place and push everything else up\n",
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\"]\n",
    "\n",
    "print(planets)\n",
    "planets.insert(2, \"Krypton\") \n",
    "print(planets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add another LIST of items. Notice the argument is a LIST! i.e. it's some elements in a [ ]\n",
    "planets = [\"Mercury\", \"Venus\",\"Earth\"] \n",
    "\n",
    "print(planets)\n",
    "planets.extend([\"Jupyter\", \"Saturn\"]) \n",
    "print(planets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# combine two lists (as if you were combining two numbers 2+2 )\n",
    "# add all of right list items at the end of left list, we're adding List + List\n",
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\"]\n",
    "\n",
    "print(planets)\n",
    "planets += [\"Uranus\", \"Neptune\"] \n",
    "print(planets)\n",
    "\n",
    "# planets = planets + \"Pluto\" # this would error. Can't add List + String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# note: appending a List to a List will do something weird. Look at the brackets! what happened?\n",
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\"]\n",
    "\n",
    "print(planets)\n",
    "planets.append([\"Saturn\",\"Uranus\"]) # add collection AS AN ITEM\n",
    "print(planets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So remember:\n",
    "\n",
    "- **append( a )** - add anything to a list, it will become the last item\n",
    "- **extend( [a,b,c] )** - add another list to a list. They will merge into one.\n",
    "\n",
    "Finally a couple of other things we may want to do, is check whether an element is in a list, or perhaps reverse the order of the list or sort it. We can do all these things just as easily too!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\"]\n",
    "\n",
    "is_earth_in_planets = \"Earth\" in planets\n",
    "print(is_earth_in_planets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if \"Earth\" in planets:\n",
    "    print(\"It's here!\")\n",
    "else:\n",
    "    print(\"Nope\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\"]\n",
    "\n",
    "print(planets)\n",
    "planets.reverse()\n",
    "print(planets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\"]\n",
    "\n",
    "print(planets)\n",
    "planets.sort() # Sorts alphabetically.\n",
    "print(planets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------\n",
    "\n",
    "## 2. Tuples and Sets: simpler, less powerful lists.\n",
    "\n",
    "We will not really talk about tuples and sets much, but you might see them at some point. Here are some defining features of each that are important to know about...\n",
    "\n",
    "**Tuple:**\n",
    "- Exactly like a list, but once created, cannot be changed.\n",
    "- Take less memory and a a bit faster, but this does not matter until you have gigabytes of data.\n",
    "\n",
    "**Set:**\n",
    "- Can only contain each element once.\n",
    "- Is useful for getting unique lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TUPLE: Like list, but NEVER changes, keys are numbers from 0.\n",
    "\n",
    "weekdays = (\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\")\n",
    "print(weekdays)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can do all the same things as a List, apart from anything that would change it's contents.\n",
    "# We won't use them much.\n",
    "\n",
    "print(weekdays[0])\n",
    "print(weekdays[3])\n",
    "print(weekdays[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We won't use them much.\n",
    "\n",
    "scattered_fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "print(scattered_fruits)\n",
    "\n",
    "# Notice order will change!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scattered_fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "\n",
    "print(scattered_fruits)\n",
    "scattered_fruits.add(\"kiwi\")\n",
    "print(scattered_fruits)\n",
    "\n",
    "scattered_fruits.add(\"plum\")\n",
    "print(scattered_fruits)\n",
    "\n",
    "scattered_fruits.add(\"apple\") # Apple is ignored! All values in a set need to be unique, so NO DUBLICATES!\n",
    "print(scattered_fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might find yourself using a SET to remove duplicates from a list. It's a bit of a hack, but you can: \n",
    "\n",
    "- Start with a list with some duplicates.\n",
    "- Turn that list into a set, which will remove duplicates.\n",
    "- Turn the set back into a list.\n",
    "\n",
    "Note that you will lose the order (it migtht change randomly) in the process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list = [\"apple\", \"banana\", \"banana\", \"cherry\", \"kiwi\", \"plum\",\"apple\", \"kiwi\"]\n",
    "print(fruit_list)\n",
    "\n",
    "fruit_set = set( fruit_list )\n",
    "print(fruit_set)\n",
    "\n",
    "fruit_list = list( fruit_set )\n",
    "print(fruit_list)\n",
    "\n",
    "# Indeed, this could be a one-liner.\n",
    "# Notice the order became jumbled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indeed, this could be a one-liner:\n",
    "\n",
    "fruit_list = [\"apple\", \"banana\", \"banana\", \"cherry\", \"kiwi\", \"plum\",\"apple\", \"kiwi\"]\n",
    "\n",
    "print(fruit_list)\n",
    "fruit_list = list(set(fruit_list))\n",
    "print(fruit_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**TOP TIP**: How would you find out how many unique values are in a list?\n",
    "\n",
    "- Turn the list into a set - it will only keep unique values.\n",
    "- Check the length of that set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list = [\"apple\", \"banana\", \"banana\", \"cherry\", \"kiwi\", \"plum\",\"apple\", \"kiwi\"]\n",
    "print( \"Number of unique values:\", len(set(fruit_list)) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------\n",
    "\n",
    "## 3. Dictionaries: A collection of different 'values'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's imagine that we want to store a group of data about one object.\n",
    "# They are all related, but the values are NOT EQUALLY important (unlike iin LIST items).\n",
    " \n",
    "coffee_type = \"Latte\"\n",
    "coffee_size = \"Large\"\n",
    "coffee_sugars = 2\n",
    "coffee_milk = \"Oat\"\n",
    "coffee_table_number = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Theoretically we could store above information in a LIST, where we remember which index describes what:\n",
    "\n",
    "coffee = [\"Latte\", \"Large\", 2, \"Oat\",  8]\n",
    "\n",
    "print(\"Can I have one\",coffee[1],coffee[0],\"with\",coffee[2],\"sugars and\",coffee[3],\"milk to table\",coffee[4])\n",
    "\n",
    "# You should get shivers looking at the above line of code. What a terrible piece of code!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The problem with the above list is that the index is the only way for us to know which piece of information means what.\n",
    "\n",
    "- We need to remember that index 0 means 'coffe_type', index 1 means 'coffe_size', index 2 means 'coffee_sugars', etc.\n",
    "- If we remove the first piece of data, all other ones will become out of place!\n",
    "- If we describe a few similar objects, eg. many coffees, their descriptions should all follow the same order.\n",
    "\n",
    "A data structure described above would be very inflexible, error-prone and force us to decide everything about our data at the very beginning. That would be disastrous in a real-life scenario. \n",
    "\n",
    "What would really help, is if we could somehow:\n",
    "\n",
    "- Label each piece of information with a name that describes what it is, like - \"Type\" is \"Latte\", \"Size\" is \"Large\")\n",
    "- Have flexibility to add or remove some information without losing any of it. \n",
    "\n",
    "Dictionaries have key-value pairs. That is each piece of data ('value') has a label ('key') describing what it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DICTIONARY - Keys can be anything, order doesn't matter, but they need to be unique.\n",
    "\n",
    "coffee_order = {\"type\":\"Latte\", \"size\":\"Large\", \"sugars\": 2, \"milk\": \"Oat\", \"table_number\": 8}\n",
    "\n",
    "print(\"Can I have one\",coffee_order['size'],coffee_order['type'],\"with\",\n",
    "      coffee_order['sugars'],\"sugars and\",coffee_order['milk'],\"milk to table\",coffee_order['table_number'])\n",
    "\n",
    "# Still TERRIBLE code, but at least you know what is what! It is longer, but more 'human'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then use the keys that we define in order to get some of the information that we want back."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( coffee_order[\"milk\"] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will error, because there is no key \"with_caffeine\".\n",
    "\n",
    "print( coffee_order[\"with_caffeine\"] ) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And that's why it is safer to use built-in dictionary methods - tools that come built within Python, we'll talk about them later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( coffee_order.get(\"milk\") ) # Get value by key.\n",
    "print( coffee_order.get(\"table_number\") ) # Get value by key."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is much safer than getting value by index, like we did in the example anout LISTS - `coffee_order[3]`. \n",
    "Or directly by key `coffee_order['milk']`. That's because if key is not there, the `.get(key)` will automatically return `None` instead of throwing a scary, but helpful error.\n",
    "\n",
    "**'None'** Is another Python data type, like 'string' or 'bool', and has just one value... `None` :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( coffee_order.get(\"with_caffeine\") ) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are able to handle missing data quite well. Should you request a value to be returned but the key is missing i.e if None is not very meaningful to the situation, you can set some default value to return.\n",
    "\n",
    "The format is ```some_dict.get(some_key, value_if_missing)```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( coffee_order.get(\"some key\", \"Default value when Key missing\") ) # You can put anything here.\n",
    "print( coffee_order.get(\"with_caffeine\", \"unknown\") ) # You can put anything here, in place of 'Unknown'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is often useful for implementing **business logic**. \n",
    "E.g. If your client reqeusts: \n",
    "If the caffeine level is unknown, assume it is with caffeine. \n",
    "Most coffee drinkers would just assume that unless they specifically said they want a decaf, their coffee will have caffeine. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_order = {\"type\":\"Latte\", \"size\":\"Large\"}\n",
    "\n",
    "print( coffee_order.get(\"size\", \"normal\") ) # You can put anything here as the 'backup'.\n",
    "print( coffee_order.get(\"milk\", \"no\") ) \n",
    "print( coffee_order.get(\"with_caffeine\", \"no caffeine\") )\n",
    "\n",
    "# If there is a value - return it - otherwise, return the backup value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change or add values:\n",
    "\n",
    "In dictionaries there is not much difference between adding a value or changing a value.\n",
    "\n",
    "Basically, to change a value you add it again and it overwrites/replaces the previous value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_order = {\"type\":\"Latte\", \"milk\": \"Oat\"}\n",
    "print(coffee_order)\n",
    "\n",
    "coffee_order[\"type\"] = \"Lungo\" # Change value, if key already exists.\n",
    "print(coffee_order)\n",
    "\n",
    "coffee_order[\"own_cup\"] = True # Add key-value pair, if key doesn't exist yet.\n",
    "print(coffee_order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You can use functions for more safe and predictable results.\n",
    "\n",
    "E.g. ```setdefault(some_key, some_value)``` will only change the value **if this key does not exist yet**.\n",
    "\n",
    "So it should really be called \"set_if_empty()\" or something like that. Oh well let's work with what we have ;) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_order = {\"type\":\"Latte\", \"milk\": \"Oat\"}\n",
    "\n",
    "print(coffee_order)\n",
    "coffee_order.setdefault(\"temperature\",\"hot\") # This adds a key-value pair.\n",
    "coffee_order.setdefault(\"type\",\"Cappuchino\") # This does nothing, because this dictionary already has a key 'type'.\n",
    "print(coffee_order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "💥 **JARGON: SYNTAX** = Grammar and vocabulary of a programing language e.g. what words, brackets or dots to use.\n",
    "\n",
    "💥 **JARGON: SYNTACTIC SUGAR** = When a Python syntax makes your life easier and sweeter, where theoretically you could have done it 'the old bitter way'. Like replacing `x = x + z` with `x += z` or helping you to avoid extra 'if-else' statements like ```some_list.get(some_key, value_if_missing)```.\n",
    "\n",
    "💥 **JARGON: SYNTACTIC VINEGAR** = When a Python syntax makes your life harder, confusing and miserable, like ```setdefault``` having a confusing name. This works much less in Scotland, because here we put vinegar on chips and that's tasty :) Yum yum!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with other data types, we can do many manipulations to dictionaries. This includes removing items, combining them with other dictionaries, and de-coupling the keys and values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_order = {\"type\":\"Latte\", \"milk\": \"Oat\"}\n",
    "\n",
    "print(coffee_order)\n",
    "milk_value = coffee_order.pop(\"milk\") # Remove value AND RETURN IT (like 'pop()' with lists).\n",
    "print(coffee_order) # This is the dictionary after 'pop()ing'. Notice that \"milk\": \"Oat\" is gone.\n",
    "\n",
    "print(\"Milk was\", milk_value) # this is what 'pop()' returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_order = {\"type\":\"Latte\", \"size\":\"Large\",\"sugars\": 6,  \"milk\" : \"Cow\"}\n",
    "\n",
    "print(coffee_order) \n",
    "coffee_order.update( { \"milk\": \"Oat\", \"cup\": \"takeaway\"}) \n",
    "print(coffee_order) \n",
    "\n",
    "# Milk is overwritten, because it already exsisted, cup is added."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_order = {\"type\":\"Latte\", \"size\":\"Large\", \"sugars\": 2,\"milk\": \"Oat\", \"table_number\": 8}\n",
    "\n",
    "print( coffee_order.keys() ) # Returns all keys as a list.\n",
    "print( coffee_order.values() ) # Returns all values as a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is no guarantee the results of  ```keys()``` and ```values()``` will be ordered in any particular way.\n",
    "\n",
    "Also, while dictionaries are sort of like a list and, basically behave like lists. You can force them to actually be a list by CASTING them, like we've casted other 'type's' in Python before. Remember int(\"22\") or string(123)? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_order = {\"type\":\"Latte\", \"size\":\"Large\", \"sugars\": 2,\"milk\": \"Oat\", \"table_number\": 8}\n",
    "\n",
    "print( list(coffee_order.keys()) ) # Returns all keys as a list.\n",
    "print( list(coffee_order.values()) ) # Returns all values as a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------\n",
    "\n",
    "## 4. Real World Data: Lists of Dictionaries, and Dictionaries of Lists.\n",
    "\n",
    "We already know that lists describe collections of similar objects. And dictionaries describe details/attributes of one complicated object. But what if you want to have a list of complicated objects?\n",
    "\n",
    "E.g. If one coffee order looks like this: ```coffee_order = {\"type\":\"Latte\", \"milk\": \"Oat\"}```.\n",
    "What if you wanted to store many coffee orders? That is a very likely scenario.\n",
    "\n",
    "This is where you would follow the principles you've learned and try them in a new context."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of having a number of variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_order0 = {\"type\":\"Latte\", \"milk\": \"Cow\"}\n",
    "coffee_order1 = {\"type\":\"Lungo\", \"milk\": \"None\"}\n",
    "coffee_order2 = {\"type\":\"Latte\", \"milk\": \"Oat\", \"sugar\" : 2}\n",
    "\n",
    "print(coffee_order0, coffee_order1, coffee_order2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You would create a list with these variables in it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_order0 = {\"type\":\"Latte\", \"milk\": \"Cow\"}\n",
    "coffee_order1 = {\"type\":\"Lungo\", \"milk\": \"None\"}\n",
    "coffee_order2 = {\"type\":\"Latte\", \"milk\": \"Oat\", \"sugar\" : 2}\n",
    "\n",
    "coffee_orders = [coffee_order0, coffee_order1, coffee_order2] # Here, we're putting 3 things in a list!\n",
    "print(coffee_orders)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could even skip having those temporary variables 'coffee_order0', etc. and define dictionaries as you create the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_orders = [{'type': 'Latte', 'milk': 'Cow'}, \n",
    "                 {'type': 'Lungo', 'milk': 'None'}, \n",
    "                 {'type': 'Latte', 'milk': 'Oat', 'sugar': 2}]\n",
    "\n",
    "print(coffee_orders)\n",
    "\n",
    "# Tip: When you click/move to the end of a bracket, its 'sibling' bracket will change colour.\n",
    "# Try it - click at both brackets right after ''sugar': 2'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to read such complex data structures? It looks like a mess of brackets! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will need to train yourselfs to identify brackets and try to decipher what belongs where, but also, Python has a special package to help you to \"pretty print\" things.\n",
    "\n",
    "Remember from the date-time session, a package is a collection of functions written by someone else in Python and bundelled together to give us the ability to do cool new things. They exist, so that Python in itself can remain simple and quick, but we have the option to install special extras if we want to work with tools like - dates, graphs, statistics etc.\n",
    "\n",
    "We can think of packages as 'apps' for Python, that we install/import from a Python 'app store'. Just like apps on your phone give you the ability to do something better - better photos, better calendar or a more fun game - packages give Python new abilities to be more helpful.\n",
    "\n",
    "We import/install packages with a piece of Python code, but we have to re-run that import every time we start running a Notebook. In other words: packages are enabled just temporarily. But don't worry! We can just enable them over and over again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You need to run this, but just once per Notebook.\n",
    "\n",
    "import pprint as pp\n",
    "\n",
    "# Here we import a package 'pprint' and we give it short nickname 'pp'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_orders = [{'type': 'Latte', 'milk': 'Cow'}, \n",
    "                 {'type': 'Lungo', 'milk': 'None'},\n",
    "                 {'type': 'Lungo', 'milk': 'Cow'},\n",
    "                 {'type': 'Latte', 'milk': 'None'},\n",
    "                 {'type': 'Filter', 'milk': 'Cow'},\n",
    "                 {'type': 'Lungo', 'milk': 'Cow'},\n",
    "                 {'type': 'Latte', 'milk': 'None'},\n",
    "                 {'type': 'Filter', 'milk': 'Cow'},\n",
    "                 {'type': 'Latte', 'milk': 'Oat', 'sugar': 2}]\n",
    "\n",
    "# First the old version, the 'un-pretty print'.\n",
    "\n",
    "print(coffee_orders)\n",
    "\n",
    "# Notice how it's hard to read."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here from the package 'pp', we use the method/function called 'pprint', which is like 'print()'... but prettier.\n",
    "\n",
    "pp.pprint(coffee_orders)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# But, if you by accident use 'pprint' to print something simple, it will also be fine.\n",
    "\n",
    "pp.pprint(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indeed, it is also a bit better than plain print, because it will indicate variable type with ''.\n",
    "# Which 'print()' does not do automatically :(\n",
    "    \n",
    "print(1234)\n",
    "print(\"1234\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pp.pprint(1234)\n",
    "pp.pprint(\"1234\")\n",
    "\n",
    "# This can be very useful for debugging."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because `coffee_orders` is just a normal list, but instead of simple strings it holds whole dictionaries, you can go ahead and use the same operations you did on lists and dictionaries in order to access the different elements of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_orders = [{'type': 'Latte', 'milk': 'Cow'}, \n",
    "                 {'type': 'Lungo', 'milk': 'None'}, \n",
    "                 {'type': 'Latte', 'milk': 'Oat', 'sugar': 2}]\n",
    "pp.pprint(coffee_orders)\n",
    "print() # extra line, just for readability\n",
    "\n",
    "pp.pprint(coffee_orders[0])\n",
    "print()\n",
    "\n",
    "pp.pprint(coffee_orders[0]['type']) # or coffee_orders[0].get('type')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Overwrite element at index 1:\n",
    "\n",
    "coffee_orders[1] = {'type': 'Espresso', 'milk': 'None', 'sugar': 4}\n",
    "pp.pprint(coffee_orders)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only way to learn this, is to experiment and practice. You will gradually absorb the idea through repetition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(coffee_orders[0])\n",
    "print(coffee_orders[2])\n",
    "print(coffee_orders[2]['sugar'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to think about elements of a list? Think of them as variables! \n",
    "\n",
    "You can treat a part of a list like that, as you would treat any variable. You can print it, or you can store it in another variable, or you can even change it.\n",
    "\n",
    "For example, let's extract the first item in this list and save it in a new variable.\n",
    "We can extract some information from that variable, bacause it's a dictionary with keys - 'type', 'milk' and 'sugar'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_orders = [{'type': 'Latte', 'milk': 'Cow'}, \n",
    "                 {'type': 'Lungo', 'milk': 'None'}, \n",
    "                 {'type': 'Latte', 'milk': 'Oat', 'sugar': 2}]\n",
    "\n",
    "first_coffee = coffee_orders[0] # saving a piece of Dict in another variable\n",
    "print(first_coffee)\n",
    "\n",
    "print(first_coffee['milk'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could also do it directly, without a temporary variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_orders = [{'type': 'Latte', 'milk': 'Cow'}, \n",
    "                 {'type': 'Lungo', 'milk': 'None'}, \n",
    "                 {'type': 'Latte', 'milk': 'Oat', 'sugar': 2}]\n",
    "\n",
    "print(coffee_orders[0])\n",
    "\n",
    "print(coffee_orders[0]['milk'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diving/Reaching deeper into data!\n",
    "\n",
    "Because when you reach into a variable, you can read it from the left:\n",
    "\n",
    "```coffee_orders[0]['milk']``` means:\n",
    "\n",
    "- Get variable coffee_orders ```coffee_orders```.\n",
    "- Then from that result get element at index 0 from it ```[0]```.\n",
    "- Then from that result get a value of a key milk ```['milk']```.\n",
    "\n",
    "Here's a step by step breakdown:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here are the above steps broken down so you can see it better: \n",
    "\n",
    "print(coffee_orders)\n",
    "print(coffee_orders[0])\n",
    "print(coffee_orders[0]['milk'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So for example, to print the 'sugar' value of the third item you would need to:\n",
    "\n",
    "- Get the third item (remember we count starting from 0)\n",
    "- Then ask for a value under the key 'sugar'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_orders = [{'type': 'Latte', 'milk': 'Cow'}, \n",
    "                 {'type': 'Lungo', 'milk': 'None'}, \n",
    "                 {'type': 'Latte', 'milk': 'Oat', 'sugar': 2}]\n",
    "\n",
    "print(coffee_orders[2]['sugar'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same way as you can extract a value, you could change it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_orders = [{'type': 'Latte', 'milk': 'Cow'}, \n",
    "                 {'type': 'Lungo', 'milk': 'None'}, \n",
    "                 {'type': 'Latte', 'milk': 'Oat', 'sugar': 2}]\n",
    "\n",
    "coffee_orders[2]['sugar'] = 1\n",
    "pp.pprint( coffee_orders )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is more, you can use a variable to indicate the index or key that you want to acess:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coffee_orders = [{'type': 'Latte', 'milk': 'Cow'}, \n",
    "                 {'type': 'Lungo', 'milk': 'None'}, \n",
    "                 {'type': 'Latte', 'milk': 'Oat', 'sugar': 2}]\n",
    "\n",
    "which_order = 1\n",
    "which_attribute = 'type'\n",
    "\n",
    "print(coffee_orders[ which_order ][ which_attribute ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use above technique TIME AND AGAIN within the upcoming weeks. \n",
    "\n",
    "Have a careful read of the above code. Try to change it, just to see what it does e.g. get last item's 'milk'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How about dictionaries with lists? It's just the same: read from left-hand-side.\n",
    "\n",
    "Read from the left-hand-side and imagine drilling into boxes of boxes..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calculator = {\n",
    "    'numbers': [1,2,3,4,5,6,7,8,9,0],\n",
    "    'functions': [\"+\",\"-\",\"*\",\"/\",\"=\"]\n",
    "}\n",
    "\n",
    "pp.pprint( calculator )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the value of key 'functions' and then get the fourth item in it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pp.pprint( calculator )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( calculator['functions'] )\n",
    "print( calculator['functions'][3] )\n",
    "print( calculator['numbers'][-1] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------\n",
    "\n",
    "## ⭐️⭐️⭐️💥 What you have learned in this session: Three stars and a wish.\n",
    "**In your own words** write in the Markdown cell below:\n",
    "\n",
    "- 3 things you would like to remember from this notebook.\n",
    "- 1 thing you wish to understand better in the future or a question you'd like to ask."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Add your reflections here.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------------\n",
    "\n",
    "## Topic Overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LIST:\n",
    "\n",
    "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupyter\", \"Saturn\", \"Uranus\"]\n",
    "print(planets[0])\n",
    "print(planets[-2])\n",
    "\n",
    "print(planets)\n",
    "planets.sort()\n",
    "print(planets)\n",
    "planets.pop(2)\n",
    "print(planets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DICTIONARY:\n",
    "\n",
    "coffee_order = {\"type\":\"Latte\", \"size\":\"Large\", \"sugars\": 2, \"milk\": \"Oat\", \"table_number\": 8}\n",
    "print(coffee_order[\"type\"])\n",
    "print(coffee_order.get(\"cup\", \"takeaway cup\"))\n",
    "print(coffee_order.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# COLLECTIONS OF COLLECTIONS:\n",
    "\n",
    "import pprint as pp \n",
    "# Let's import a helpfull library pprint('pretty print'), and nickname it 'pp'.\n",
    "\n",
    "coffee_orders = [{'type': 'Latte', 'milk': 'Cow'}, \n",
    "                 {'type': 'Lungo', 'milk': 'None'}, \n",
    "                 {'type': 'Latte', 'milk': 'Oat', 'sugar': 2}]\n",
    "\n",
    "# 'Ugly print':\n",
    "\n",
    "print(coffee_orders)\n",
    "\n",
    "print() # Prints more empty space (new line)\n",
    "\n",
    "# 'Pretty print' (it prints things in a more readable way - in wrows)\n",
    "\n",
    "pp.pprint(coffee_orders)\n",
    "\n",
    "print()\n",
    "\n",
    "# One item:\n",
    "\n",
    "print(coffee_orders[-1]['milk'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try to stick to one naming convention -- be consistent with your names. \n",
    "\n",
    "### Whenever you are unclear of how to read big blocks of data, read it from the outside to the inside.\n",
    "\n",
    "### 'Chisel' at it - one step at a time, get closer to the inside."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------\n",
    "\n",
    "# ⛏ Exercise: Create some data, and then read some data.\n",
    "\n",
    "\n",
    "**1: Create data for a number of sandwiches / bagels.**\n",
    "\n",
    "Create a list with a number of dictionaries in it. Each dictionary should describe a sandwich: eg. bread type, price, name. Some attributes will be strings, other numbers or even boolean values. Make sure you have some of each.\n",
    "\n",
    "It is up to you what information you store about a sandwich. Make your list have at least 4 items, and make sure each item has at least 3 attributes. If you do not know where to start, use above examples with coffee orders. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here wrtite your code\n",
    "# this task is about sandwiches, but if it was about fruits, it could look like this:\n",
    "fruits = [{'species':'apple', 'variety':'granny smith', 'color':'green'},\n",
    "         {'species':'apple', 'variety':'McIntosh', 'color':'red'},\n",
    "         {'species':'banana', 'color':'yellow', 'stickers':['fairtrader', 'organic']\n",
    "         }]\n",
    "# so now write something like that for your favourite 3-4 sanwiches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# more space for your code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write some queries:\n",
    "# eg. what's the colour of the last fruit?\n",
    "fruits[-1]['color']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2: Can you add a list of toppings to EACH sandwich?**\n",
    "\n",
    "Make a list of strings like ```[\"bacon\", \"lettuce\", \"tomato\"]``` so that someone could ask \"what is the second topping on the first sandwich\" by writing ```sandwiches[0]['toppings'][1]```. Always remember to read from the left hand side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sandwiches = [ \n",
    "        # Here add some sandwich info, like we did for coffee orders.\n",
    "    ]\n",
    "\n",
    "# First topping on last sandwich:\n",
    "print(sandwiches[-1]['topping'][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ⛏ Exercise: Extract information from below data from a real life API source:\n",
    "\n",
    "Below is an excerpt form the API (publicly available data) of Bank of Scotland. \n",
    "It describes 3 cash machines with all of their attributes - languages they support, accessibility issues, etc.\n",
    "\n",
    "Use what you have learned in this notebook to understand what you are looking at. Then come up with 5 different questions yourself and write code that will find it out for you:\n",
    "\n",
    "E.g: Easy Level - What is the MinimumPossibleAmount I can recieve from the first cash machine.\n",
    "\n",
    "```print( bank_of_scotland_atms[0]['MinimumPossibleAmount'] ) ```\n",
    "\n",
    "eg. Harder Level - How many languages does the last cash machine support?\n",
    "\n",
    "```print( len( bank_of_scotland_atms[-1]['SupportedLanguages'] ) )```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Practise clicking on the bracket to see its 'sibling' bracket i.e. where it opens/closes.\n",
    "\n",
    "bank_of_scotland_atms = [{'Identification': 'BFF7BC11',\n",
    "  'SupportedLanguages': ['eng', 'spa', 'ger', 'fre', 'pol', 'gae', 'ukr'],\n",
    "  'ATMServices': ['PINUnblock',\n",
    "   'Balance',\n",
    "   'BillPayments',\n",
    "   'CashWithdrawal',\n",
    "   'FastCash',\n",
    "   'MobilePhoneTopUp',\n",
    "   'PINChange',\n",
    "   'MiniStatement'],\n",
    "  'Accessibility': ['WheelchairAccess'],\n",
    "  'SupportedCurrencies': ['GBP'],\n",
    "  'MinimumPossibleAmount': '10',\n",
    "  'Branch': {'Identification': '80453100'},\n",
    "  'Location': {'LocationCategory': ['BranchExternal'],\n",
    "   'Site': {'Identification': '80453100'},\n",
    "   'PostalAddress': {'AddressLine': ['136 BUCHANAN STREET; BALFRON'],\n",
    "    'BuildingNumber': 'BOS BRANCH',\n",
    "    'StreetName': '136 BUCHANAN STREET',\n",
    "    'TownName': 'GLASGOW',\n",
    "    'CountrySubDivision': ['GLASGOW'],\n",
    "    'Country': 'GB',\n",
    "    'PostCode': 'G63 0TG',\n",
    "    'GeoLocation': {'GeographicCoordinates': {'Latitude': '56.071629',\n",
    "      'Longitude': '-4.336911'}}}}},\n",
    " {'Identification': 'BFA6HC11',\n",
    "  'SupportedLanguages': ['eng', 'spa', 'ger', 'fre'],\n",
    "  'ATMServices': ['PINUnblock',\n",
    "   'Balance',\n",
    "   'BillPayments',\n",
    "   'CashWithdrawal',\n",
    "   'FastCash',\n",
    "   'MobilePhoneTopUp',\n",
    "   'PINChange',\n",
    "   'MiniStatement'],\n",
    "  'Accessibility': ['AudioCashMachine', 'WheelchairAccess'],\n",
    "  'SupportedCurrencies': ['GBP'],\n",
    "  'MinimumPossibleAmount': '10',\n",
    "  'Branch': {'Identification': '80496000'},\n",
    "  'Location': {'LocationCategory': ['BranchInternal'],\n",
    "   'Site': {'Identification': '80496000'},\n",
    "   'PostalAddress': {'AddressLine': ['BRISTOL ROOM COPLEY DATA CENTRE; WAKEFIELD ROAD'],\n",
    "    'BuildingNumber': 'BOS BRANCH',\n",
    "    'StreetName': 'BRISTOL ROOM COPLEY DATA CENTRE',\n",
    "    'TownName': 'HALIFAX',\n",
    "    'CountrySubDivision': ['WEST YORKSHIRE'],\n",
    "    'Country': 'GB',\n",
    "    'PostCode': 'HX3 0TD',\n",
    "    'GeoLocation': {'GeographicCoordinates': {'Latitude': '51.454900',\n",
    "      'Longitude': '2.592000'}}}}},\n",
    " {'Identification': 'BF88GC11',\n",
    "  'SupportedLanguages': ['eng', 'spa', 'ger', 'fre'],\n",
    "  'ATMServices': ['PINUnblock',\n",
    "   'Balance',\n",
    "   'BillPayments',\n",
    "   'CashWithdrawal',\n",
    "   'FastCash',\n",
    "   'MobilePhoneTopUp',\n",
    "   'PINChange',\n",
    "   'MiniStatement'],\n",
    "  'Accessibility': ['AudioCashMachine', 'WheelchairAccess'],\n",
    "  'SupportedCurrencies': ['GBP'],\n",
    "  'MinimumPossibleAmount': '10',\n",
    "  'Branch': {'Identification': '80452300'},\n",
    "  'Location': {'LocationCategory': ['BranchInternal'],\n",
    "   'Site': {'Identification': '80452300'},\n",
    "   'PostalAddress': {'AddressLine': ['111 HIGH STREET;'],\n",
    "    'BuildingNumber': 'BOS BRANCH',\n",
    "    'StreetName': '111 HIGH STREET',\n",
    "    'TownName': 'ANNAN',\n",
    "    'CountrySubDivision': ['DUMFRIES AND GALLOWAY'],\n",
    "    'Country': 'GB',\n",
    "    'PostCode': 'DG12 6AB',\n",
    "    'GeoLocation': {'GeographicCoordinates': {'Latitude': '54.987176',\n",
    "      'Longitude': '-3.260075'}}}}}]\n",
    "\n",
    "pp.pprint(bank_of_scotland_atms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# eg: what is the MinimumPossibleAmount I can recieve from the first cash machine\n",
    "\n",
    "print( bank_of_scotland_atms[0]['MinimumPossibleAmount'] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# how many languages does the last cash machine support?\n",
    "\n",
    "print( len( bank_of_scotland_atms[-1]['SupportedLanguages'] ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What else could you do with this ATM data? Have a play!\n",
    "\n",
    "It's best if you imagine that the client is asking you a question, and you need to use code to askwer them. eg:\n",
    "\n",
    "- does the first cach machine have 'AudioCashMachine' accessibility feature? (remember you can use if/and/True/False)\n",
    "- what are 'TownName's of all 3 machines?\n",
    "- think of yoru own"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# try to solve the task here"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}