02_data_structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python 2: Data Structures\n",
    "\n",
    "Notebooks 01-03 will give a quick introduction to the Python programming language, explaining variables, operators, data structures, control flow, functions and some other useful techniques.\n",
    "\n",
    "This notebook introduces data structures, which can store large numbers of variables in a structured and logical way, and make programming easier, faster and more efficient.\n",
    "The data structures we cover are:\n",
    "* Lists\n",
    "* Tuples\n",
    "* Dicts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You've seen some of the basic data types such as `int`, `float` and `str` in notebook 1. When we want to store large numbers of these in a structured way, we can use the data structures built in to python.\n",
    "\n",
    "The two most commonly used data structures are the list and the dict."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "A list stores a one-dimensional array of variables, and behaves similarly to arrays in other languages such as C.\n",
    "\n",
    "A list can be declared by listing values between square brackets, separated by commas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [0, 1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access elements of a list by providing an index between square brackets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(my_list[0])\n",
    "print(my_list[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that python is zero-indexed - the first item in this list is item 0, and the last item is item 3.\n",
    "\n",
    "If you try to access item 4, this will throw an `IndexError` as this list has no fourth element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32mf:\\local\\cgvi-python-intro\\02_data_structures.ipynb Cell 8\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/f%3A/local/cgvi-python-intro/02_data_structures.ipynb#X10sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mprint\u001b[39m(my_list[\u001b[39m4\u001b[39;49m])\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "print(my_list[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The special index `-1` will return the final element in the list.\n",
    "\n",
    "You can also use other negative indices to return the second to last element `-2`, the third to last `-3` and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(my_list[-1])\n",
    "print(my_list[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can add an item to the end of the list using `append()` which will make it one element longer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list has length 4\n",
      "The list has length 5\n",
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(\"The list has length\", len(my_list))\n",
    "my_list.append(4)\n",
    "print(\"The list has length\", len(my_list))\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can extract part of a list using a \"slice\". These include a colon `:` with indices on either side. For example `1:3` means items 1 and 2 in the list (note that the ending index is not included).\n",
    "\n",
    "You don't have to include both indices: the slice `:3` means elements in the list up to (but not including) element 3. The slice `3:` means all element from element 3 onward.\n",
    "\n",
    "There are some examples of slices below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The whole list: [0, 1, 2, 3, 4]\n",
      "Elements in the list from 1 to 3: [1, 2]\n",
      "Elements in the list up to the second-last element: [0, 1, 2]\n",
      "Elements in the list from 1 onwards: [1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "my_list = [0, 1, 2, 3, 4]\n",
    "\n",
    "print(\"The whole list:\", my_list[:])\n",
    "print(\"Elements in the list from 1 to 3 (not including 3):\", my_list[1:3])\n",
    "print(\"Elements in the list up to (but not including) the second-last element:\", my_list[:-2])\n",
    "print(\"Elements in the list from 1 onwards:\", my_list[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike languages such as C, a list can contain a mixture of data types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 'hello', 1.0, False, None]\n"
     ]
    }
   ],
   "source": [
    "my_mixed_list = [0, \"hello\", 1.0, False, None]\n",
    "print(my_mixed_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Operators and Lists\n",
    "\n",
    "In an exercise in the last notebook we saw that operators `+` and `*` can be applied to strings. They can also be applied to lists. \n",
    "\n",
    "Try doing this to the lists below - what do you predict will happen?\n",
    "\n",
    "Does multiplying a list by another list work? How about subtraction? Why do you think this is?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_a = [0, 1, 2]\n",
    "list_b = [3, 4, 5]\n",
    "\n",
    "# Try adding the two lists\n",
    "# Your code here...\n",
    "\n",
    "# Try multiplying a list by an integer\n",
    "# Your code here..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Tuples are a lot like lists, but are *immutable*. This means they cannot be modified after being created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (0, 1, 2) # Note that tuples are created with parentheses () not square brackets [].\n",
    "print(my_tuple[0]) # But you access elements with [], just like a list.\n",
    "print(my_tuple[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because they are immutable, they don't have functions like `append()` and you can't change the value of an element in the tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-11ad61e324ed>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmy_tuple\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "my_tuple = (0,1)\n",
    "my_tuple.append(2) # This will throw an AttributeError, because a tuple doesn't have an append() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-87d73f91b0eb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmy_tuple\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "my_tuple = (0,1,2)\n",
    "my_tuple[2] = 3 # This throws a TypeError as you can't assign to a tuple after creating it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (0,1,2)\n",
    "my_tuple = (1,2,3) # This works fine though.\n",
    "# This is because you aren't changing a tuple - you're creating an entirely new one\n",
    "# and assigning it to the same variable my_tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a quick note, you can make a tuple of type 1, but need to be a bit careful. Parentheses `()` can also be used like they are in mathematics, to specify order of operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 + 2 * 2 = 5\n",
      "(1 + 2) * 2 = 6\n"
     ]
    }
   ],
   "source": [
    "# If you do 1 + 2 * 2, the multiplication will happen first\n",
    "# so we get 1 + 2 * 2 = 1 + 4 = 5\n",
    "print(\"1 + 2 * 2 =\",  1 + 2 * 2)\n",
    "\n",
    "# To make the addition happen first, use parentheses\n",
    "# Here we have (1 + 2) * 2 = 3 * 2 = 6\n",
    "print(\"(1 + 2) * 2 =\", (1 + 2) * 2)\n",
    "\n",
    "# For more info on the order operators are applied in, see https://docs.python.org/3/reference/expressions.html#operator-precedence\n",
    "# They roughly follow the mathematical order you may remember from school (BIDMAS/BODMAS/BEDMAS/PEMDAS).\n",
    "# But as a general rule, include parentheses to make it clear what you mean, and make your code easy to read!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because of this, for example `(0)` just means the `int` value `0`. If you want to make a tuple of length 1, containing the value `0`, you need to add a comma at the end, making `(0,)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of (0): <class 'int'>\n",
      "Type of (0,) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "print(\"Type of (0):\", type((0))) # This is the integer 0\n",
    "print(\"Type of (0,)\", type((0,))) # This is the tuple (0,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dicts\n",
    "\n",
    "Dict is short for dictionary. Dicts work a bit like lists, except that rather than using integers to index elements in the structure, dicts use strings.\n",
    "\n",
    "In other languages they might be called \"maps\" as they are map from strings (called \"keys\") to objects (called \"values\"). Each key maps to a single value, so they form a set of pairs we call \"key-value pairs\".\n",
    "\n",
    "To make a dict, you provide a series of keys and values in curly brackets `{}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'string_1': 1, 'string_2': 2}\n"
     ]
    }
   ],
   "source": [
    "# Below we make a dict with two key-value pairs.\n",
    "# The keys are the strings \"string_1\" and \"string_2\".\n",
    "# The values are the numbers 1 and 2.\n",
    "my_dict = {\"string_1\": 1, \"string_2\": 2}\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the keys can be any string you like, they don't have to be in any set format like \"string_1\" and \"string_2\" above.\n",
    "\n",
    "Just like lists, you can access elements using square brackets. However to access an element of a dict you provide the right string. These strings are referred to as \"keys\" and the items stored in the dict are known as \"values\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(my_dict[\"string_1\"])\n",
    "print(my_dict[\"string_2\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like lists if you try to access something that isn't in the dict, you will get an error (this time, a `KeyError`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'string_3'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-efdd58018dfe>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"string_3\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'string_3'"
     ]
    }
   ],
   "source": [
    "print(my_dict[\"string_3\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding new elements to a dict is straightforward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'string_1': 1, 'string_2': 2, 'string_3': 3}\n"
     ]
    }
   ],
   "source": [
    "my_dict[\"string_3\"] = 3\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that you can nest any of these datatypes. For example, here's a dict which contains a list, a tuple and another dict as values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nested_dict = {\"list\": [0, 1], \"tuple\": (0, 1), \"dict\": {\"hello\": 1}}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further Reading\n",
    "\n",
    "I'd recommend checking out the python tutorial on [Data Structures](https://docs.python.org/3/tutorial/datastructures.html). \n",
    "\n",
    "We didn't cover [Sets](https://docs.python.org/3/tutorial/datastructures.html#sets) in this tutorial, but they are sometimes useful, and there is more information available there."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.5 ('base')",
   "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.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "c921a71fa7d5301530abc76a09084737c3fca4b7328b11bbb5dba4e94f78eaed"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}