06 Data structures.ipynb

{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Introduction\n\nA data structure is an 'object' in a program that holds a collection of data. A simple\ndata structure might be an 'array' that holds the components of a vector, or a list of\nnames. A more complicated data structure might represent a telephone directory, \nholding [name, telephone number] pairs.\n\nModern languages, like Python, provide a range of library (built-in) data structures.\nThese are well-tested and optimised; it is good practice to use library data structures to make programs\nsimpler, easier to read and more efficient. \n\nIt is possible to develop your own data structures for special purposes. In this activity\nwe focus on selecting and using built-in data structures. The creation\nof your own data structures is introduced in Activity 12.\n\n\n### Objectives\n\n- Use `list`, `tuple` and dictionary (`dict`) data structures\n- Use iteratation to visit entries in a data structure \n- Learn to select the right data structure for an application"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Data structures\n\nSo far we have restricted our examples to simple built-in data types, e.g. `string`, `int`, and `float`. In practice, programs will use *data structures* to collect data together into useful packages. For example, rather than representing a vector `r` of length 3 using three floats `u`, `v` and `w`, we could represent \nit as a list of floats, `r = [u, v, w]`. Similarly, if we want to store the names of students in a laboratory group, rather than a string variable for each student, we could work with a list of names, e.g.:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "lab_group0 = [\"Sarah\", \"John\", \"Joe\", \"Emily\"]\nlab_group1 = [\"Roger\", \"Rachel\", \"Amer\", \"Caroline\", \"Colin\"]",
      "execution_count": 1,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "This is a much more powerful construction because we can perform operations on a list, such as checking its length (number of students in a lab group), sort the names in the list into alphabetical order, and add or remove names. We could even make a list-of-lists, e.g."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "lab_groups = [lab_group0, lab_group1]",
      "execution_count": 2,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "to collect all the lab groups together into a *nested* list.\n\nData structures are particularly useful when passing data to functions. Say we want a function that prints the names of students in a given lab group. Rather than passing the name of each student (with different groups having differing numbers of members), we can pass just the list of lab group members to the function.\nSimilarly, we could develop a function that computes the dot product between two vectors of arbitrary length, passing to the function just the two vectors rather than each component.\n\nWe will look at three built-in Python data structures that are commonly used. They are:\n\n- `list` \n- `tuple`\n- `dict` (dictionary)"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Lists\n\nA `list` is a sequence of data. An 'array' in most other languages is a similar concept, but Python lists are more general than most arrays as they can hold a mixture of types. A list is constructed using square brackets:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "lab_group0 = [\"Sarah\", \"John\", \"Joe\", \"Emily\", \"Quang\"]\nprint(\"Lab group members: {}\".format(lab_group0))\nprint(\"Size of lab group: {}\".format(len(lab_group0)))\n\nprint(\"Check the Python object type: {}\".format(type(lab_group0)))",
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Lab group members: ['Sarah', 'John', 'Joe', 'Emily', 'Quang']\nSize of lab group: 5\nCheck the Python object type: <class 'list'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The function '`len`' returns the length (number of items) of the list.\n\nAn empty list is created by"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "my_list = []",
      "execution_count": 4,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "A list of length 5 with repeated values can be created by"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "my_list = [\"Oliver\"]*5\nprint(my_list)",
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": "['Oliver', 'Oliver', 'Oliver', 'Oliver', 'Oliver']\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Iterating over lists\n\nLooping over each item in a list (or more generally a sequence) is called *iterating*. We iterate over the members of the lab group using the syntax:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for member in lab_group0:\n    print(member)",
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Sarah\nJohn\nJoe\nEmily\nQuang\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Say we want to iterate over the names of the lab group members, and get the position\nof each member in the list. We use `enumerate` for this: "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for n, member in enumerate(lab_group0):\n    print(n, member)",
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": "0 Sarah\n1 John\n2 Joe\n3 Emily\n4 Quang\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "In the above, `n` is the position in the list and `member` is the $n$th entry in the list. Sometimes we need to know the position, in which case `enumerate` is helpful. However, when possible it is preferable to use a 'plain' iteration. Note that Python counts from zero - it uses zero-based indexing."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Manipulating lists \n\nThere are many functions for manipulating lists. It might be useful to sort the list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "lab_group0.sort()\nfor member in lab_group0:\n    print(member)",
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Emily\nJoe\nJohn\nQuang\nSarah\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "In the above, `sort` is known as a 'method' of a `list`. It performs an *in-place* sort, i.e. `lab_group0` is sorted, rather than creating a new list with sorted entries (for the latter we would use `sorted(lab_group0)`, which returns a new list). More on methods later when we get to object-oriented design.\n\nWith lists we can add and remove students:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Remove the second student (indexing starts from 0, so 1 is the second element)\nlab_group0.pop(1)\nprint(lab_group0)\n\n# Add new student \"Josephine\" at the end of the list\nlab_group0.append(\"Josephine\")\nprint(lab_group0)",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": "['Emily', 'John', 'Quang', 'Sarah']\n['Emily', 'John', 'Quang', 'Sarah', 'Josephine']\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "or maybe join two groups to create one larger group: "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "lab_group1 = [\"Roger\", \"Rachel\", \"Amer\", \"Caroline\", \"Colin\"]\n\nlab_group = lab_group0 + lab_group1\nprint(lab_group)",
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": "['Emily', 'John', 'Quang', 'Sarah', 'Josephine', 'Roger', 'Rachel', 'Amer', 'Caroline', 'Colin']\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "or create a list of group lists:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "lab_groups = [lab_group0, lab_group1]\nprint(lab_groups)\n\nprint(\"---\")\n\nprint(\"Print each lab group (name and members):\")\nfor i, lab_group in enumerate(lab_groups):\n    print(i, lab_group)",
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[['Emily', 'John', 'Quang', 'Sarah', 'Josephine'], ['Roger', 'Rachel', 'Amer', 'Caroline', 'Colin']]\n---\nPrint each lab group (name and members):\n0 ['Emily', 'John', 'Quang', 'Sarah', 'Josephine']\n1 ['Roger', 'Rachel', 'Amer', 'Caroline', 'Colin']\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Indexing\n\nLists store data in order, so it is possible to 'index into' a list using an integer (this will be familiar to anyone who has used C), e.g.:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "first_member = lab_group0[0]\nthird_member = lab_group0[2]\nprint(first_member, third_member)",
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Emily Quang\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "or"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for i in range(len(lab_group0)):\n    print(lab_group0[i])",
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Emily\nJohn\nQuang\nSarah\nJosephine\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Indices start from zero, and run through to (length - 1).\n\nIndexing can be useful for numerical computations. We use it here to compute the dot product of two vectors:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Two vectors of length 4\nx = [1.0, 3.5, 7.2, 8.9]\ny = [-1.0, 27.1, 1.0, 6]\n\n# Compute dot-product\ndot_product = 0.0\nfor i in range(len(x)):\n    dot_product += x[i]*y[i]\n\nprint(dot_product)",
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": "154.45000000000002\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "When possible, it is better to iterate over a list rather than use indexing, since there are data structures that support iterating but do not support indexing.\n\nIf we have a list-of-lists,"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "lab_group0 = [\"Sarah\", \"John\", \"Joe\", \"Emily\"]\nlab_group1 = [\"Roger\", \"Rachel\", \"Amer\", \"Caroline\", \"Colin\"]\nlab_groups = [lab_group0, lab_group1]",
      "execution_count": 15,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "we can use the first index to access a list, and a second index to access the entry in that list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "group = lab_groups[0]\nprint(group)\n\nname = lab_groups[1][2]\nprint(name)",
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": "['Sarah', 'John', 'Joe', 'Emily']\nAmer\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Heterogeneity (lists with mixed types)\n\nPython lists are heterogeneous data structures - this means they can store mixed types, e.g."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "mixed_list = [\"Adam\", 2 + 4j, 1.0, 4]\nfor entry in mixed_list:\n    print(entry, type(entry))",
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Adam <class 'str'>\n(2+4j) <class 'complex'>\n1.0 <class 'float'>\n4 <class 'int'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Arrays in most languages are homogeneous - all types in the array must be the same.\n\nThere are *many* ways in which lists can be manipulated. The best way to learn how to perform a specific operation is to use a search engine."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## List comprehension (advanced, optional)\n\nA powerful construct in modern languages, including Python, is *list comprehension*. It is a way to succinctly build lists from other lists. It can be very useful, but should be applied sensibly as it can sometimes be difficult to read. There is an optional extension exercise at the end of this notebook that uses list comprehension.\n\nSay we have a list of numbers, and we wish to create a new list that squares each number in the original list and adds 5. Using list comprehension:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = [4, 6, 10, 11]\ny = [a*a + 5 for a in x]\n\nprint(x)\nprint(y)",
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[4, 6, 10, 11]\n[21, 41, 105, 126]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "To understand the meaning, read the statement left-to-right.\n\nAs another example, say we have a list of names and we want to \n\n- build a new list of names that contains only the names with more than 5 characters; and \n- for these names we want to add a full stop at the end.\n\nUsing list comprehension:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "lab_group1 = [\"Roger\", \"Rachel\", \"Amer\", \"Caroline\", \"Colin\"]\ngroup = [name + \".\" for name in lab_group1 if len(name) > 5]\n\nprint(lab_group1)\nprint(group)",
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": "['Roger', 'Rachel', 'Amer', 'Caroline', 'Colin']\n['Rachel.', 'Caroline.']\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Mastering list comprehension is not simple, but it is very powerful."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Tuples\n\nTuples are closely related to lists. The main difference is that a tuple cannot be changed after it has been created. \nIn computing jargon, it is *immutable*.\n\nFor something that should not change after it has been created, such as a vector of length three with fixed entries, a tuple is more appropriate than a list. It is 'safer' in this case since it cannot be modified accidentally in a program. Being immutable ('read-only') also permits implementations to be optimised for speed.\n\nTo create a tuple, use round brackets. Say at a college each student is assigned a room, and the rooms are numbered. A student 'Laura' is given room 32:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "room = (\"Laura\", 32)\nprint(\"Room allocation: {}\".format(room))\nprint(\"Length of entry: {}\".format(len(room)))\nprint(type(room))",
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Room allocation: ('Laura', 32)\nLength of entry: 2\n<class 'tuple'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can iterate over tuples in the same way as with lists,"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Iterate over tuple values\nfor d in room:\n    print(d)",
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Laura\n32\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "and we can index into a tuple:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Index into tuple values\nprint(room[1])\nprint(room[0])",
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": "32\nLaura\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We might have a student who is given permission to live outside of college. To keep track of them we still want an entry for the student, but there is no associated room number. We can create a tuple of length one using '`(\"a\",)`', e.g.:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "room = (\"Adrian\",)\nprint(\"Room allocation: {}\".format(room))\nprint(\"Length of entry: {}\".format(len(room)))\nprint(type(room))",
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Room allocation: ('Adrian',)\nLength of entry: 1\n<class 'tuple'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "As part of a rooms database, we can create a list of tuples:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "room_allocation = [(\"Adrian\",), (\"Laura\", 32), (\"John\", 31), (\"Penelope\", 28), (\"Fraser\", 28), (\"Gaurav\", 19)]\nprint(room_allocation)",
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[('Adrian',), ('Laura', 32), ('John', 31), ('Penelope', 28), ('Fraser', 28), ('Gaurav', 19)]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "To make it easier for students to find their rooms on a printed room list, we can sort the list:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "room_allocation.sort()\nprint(room_allocation)",
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": "[('Adrian',), ('Fraser', 28), ('Gaurav', 19), ('John', 31), ('Laura', 32), ('Penelope', 28)]\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We could improve the printed list by not printing those living outside of the college:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for entry in room_allocation:\n    if len(entry) > 1:\n        print(\"Name: {} \\n  Room: {}\".format(entry[0], entry[1]))",
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Name: Fraser \n  Room: 28\nName: Gaurav \n  Room: 19\nName: John \n  Room: 31\nName: Laura \n  Room: 32\nName: Penelope \n  Room: 28\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "In summary, prefer tuples over lists when the length will not change."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Dictionaries (maps)\n\nWe used a list of tuples in the previous section to store room allocations. If we wanted to find which room a particular student has been allocated we would need to iterate through the list and check each name. For a very large list, this might not be very efficient.\n\nThere is a better way to do this, using a 'dictionary' (or sometimes called a 'map'). We have used indexing (with integers) into lists and tuples for direct access to a specific entry. This works if we know the index to the entry of interest. But, for a room list we identify individuals by name rather than a contiguous set of integers. Using a dictionary, we can build a 'map' from names (the *keys*) to room numbers (the *values*). \n\nA Python dictionary (`dict`) is declared using curly braces:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "room_allocation = {\"Adrian\": None, \"Laura\": 32, \"John\": 31, \"Penelope\": 28, \"Fraser\": 28, \"Gaurav\": 19}\nprint(room_allocation)\nprint(type(room_allocation))",
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": "{'Penelope': 28, 'John': 31, 'Adrian': None, 'Fraser': 28, 'Laura': 32, 'Gaurav': 19}\n<class 'dict'>\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Each entry is separated by a comma. For each entry we have a 'key', which is followed by a colon, and then the 'value'. Note that for Adrian we have used '`None`' for the value, which is a Python keyword for 'nothing' or 'empty'.\n\nNow if we want to know which room Fraser has been allocated, we can query the dictionary by key:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "frasers_room = room_allocation[\"Fraser\"]\nprint(frasers_room)",
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": "28\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "If we try to use a key that does not exist in the dictionary, e.g.\n\n    frasers_room = room_allocation[\"Frasers\"]\n\nPython will give an error (raise an exception). If we're not sure that a key is present, we can check:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"Fraser\" in room_allocation)\nprint(\"Frasers\" in room_allocation)",
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": "True\nFalse\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "(We can also use '`in`' to check if an entry exists in a list or tuple).\nWe can iterate over the keys in a dictionary:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for d in room_allocation:\n    print(d)",
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Penelope\nJohn\nAdrian\nFraser\nLaura\nGaurav\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "or iterate over both the keys and the values:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for name, room_number in room_allocation.items():\n    print(name, room_number)",
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Penelope 28\nJohn 31\nAdrian None\nFraser 28\nLaura 32\nGaurav 19\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that the order of the printed entries in the dictionary is different from the input order. This is because a dictionary stores data differently from a list or tuple. Lists and tuples store entries 'linearly' in memory\n(contiguous pieces of memory), which is why we can access entries by index. Dictionaries use a different type of storage which allows us to perform look-ups using a 'key'.\n\nWe have used a string as the key so far, which is common. However, we can use almost any type as a key, and we can mix types. For example, we might want to 'invert' the room allocation dictionary to create a room-to-name map: "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Create empty dictionary\nroom_allocation_inverse = {}\n\n# Build inverse dictionary to map 'room number' -> name \nfor name, room_number in room_allocation.items():\n    # Insert entry into dictionary\n    room_allocation_inverse[room_number] = name\n\nprint(room_allocation_inverse)",
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": "{32: 'Laura', 19: 'Gaurav', None: 'Adrian', 28: 'Fraser', 31: 'John'}\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We can now ask who is in room 28 and who is in room 29. Not all rooms are occupied, so we should include a check that the room number is a key in our dictionary:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "rooms_to_check = [28, 29]\n\nfor room in rooms_to_check:\n    if room in room_allocation_inverse:\n        print(\"Room {} is occupied by {}.\".format(room, room_allocation_inverse[room]))\n    else:\n        print(\"Room {} is unoccupied.\".format(room))",
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Room 28 is occupied by Fraser.\nRoom 29 is unoccupied.\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": "# Choosing a data structure\n\nAn important task when developing a computer program is selecting the *appropriate* data structure for a task.\nThe more flexible the data structure, generally the less efficient it will be and it will use more memory compared to simpler data structures.\n\n- If efficiency is not critical, pick a data structure that provides the functionality you need, and offers \n  flexibility and ease of use. Safety should also be considered (this can be a good reason for choosing a \n  tuple over a list).\n- Use iterators rather than indexing when possible. This will allow switching from data structures that support \n  indexing to data structures that do not support indexing (such as a '`set`' data structure).\n\nFor many numerical computations, efficiency is essential and picking the right data structure is critical\nfor this. We will look at data structures that are specialied for numerical computations in the next notebook, and we'll see the huge difference in speed there can be between different data structures."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Exercises\n\nComplete now the [06 Exercises](Exercises/06%20Exercises.ipynb) notebook."
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.5.4",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1
}