02-data_structures-skeleton.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data structures\n",
    "\n",
    "Data can come in many different flavours and a big challenge is to bring it into a shape that can be used in your programs. Below are explanation about data structures: how you can use them and what you can use them for.\n",
    "\n",
    "Python supports several data structures in the standard library. Some packages (which you will learn about later) provide further, specialised data structures. Using the default data structure has advantages and you should prefer them unless you have specific requirements that are provided by an specialised library."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The standard data structures in Python are:\n",
    "\n",
    "- lists\n",
    "- tuples\n",
    "- dictionaries\n",
    "- sets\n",
    "\n",
    "Below you will see detailed explanations for each of the structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In some ways, strings behave like lists of characters. You have already used indexing on strings. You will see that the same indexing applies to lists. Thus, you can consider strings as data structures as well.\n",
    "\n",
    "You will learn more about strings later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Lists are data structures with a variable number of elements indexed by position. Depending on what other programming languages you have used before, they are functionally similar to what you would know as lists or arrays.\n",
    "\n",
    "Because the elements are indexed by position, they are also ordered. This makes lists useful to store data that has an inherent order (e.g., purchases that are ordered by dates).\n",
    "\n",
    "You can think of lists as a stack of folders, where each folder has a numbered position in the stack. You can then check what is in each folder, or add or remove folders to/from a set position in the stack.\n",
    "\n",
    "You can define lists by surrounding the values with square brackets (i.e. `[` and `]`) and separating them with commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "animal_farm = ['Old Major', 'Napoleon', 'Snowball', 'Boxer', 'Molli', 'Mr. Jones']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also put different datatypes into lists.\n",
    "\n",
    "```python\n",
    "[39, 'Snowball']\n",
    "```\n",
    "\n",
    "Lists are normal values in Python, which means you can place them inside other lists or tuples. In general, you can place them in any data structure.\n",
    "\n",
    "```python\n",
    "[1, 'Snowball', ['Mr. Jones', 'Boxer']]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing and slicing\n",
    "\n",
    "You can access the different components of a list by their position, like in the case of strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Snowball'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animal_farm[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use negative indexes in which case, elements are counted from the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mr. Jones'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animal_farm[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Snowball', 'Boxer', 'Molli']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animal_farm[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extended slice with step\n",
    "Python supports an extended slicing syntax that supports a step to specify how to iterate through indexes.\n",
    "\n",
    "Below we step every two elements on a copy of the `animal_farm` list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Old Major', 'Snowball', 'Molli']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animal_farm[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse order using negative stepping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Mr. Jones', 'Molli', 'Boxer', 'Snowball', 'Napoleon', 'Old Major']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animal_farm[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can combine all the slicing syntax together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Old Major', 'Napoleon', 'Snowball', 'Boxer', 'Molli', 'Mr. Jones']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Snowball', 'Napoleon']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(animal_farm)\n",
    "animal_farm[2:0:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Old Major', 'Napoleon', 'Snowball', 'Boxer', 'Molli', 'Mr. Jones']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Snowball', 'Napoleon', 'Old Major']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(animal_farm)\n",
    "animal_farm[2::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copying list\n",
    "You can use the `list` function or the `::` syntax to produce and independent copy of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Raoul', 'Napoleon', 'Snowball', 'Boxer', 'Molli', 'Mr. Jones']\n",
      "['Kevin', 'Napoleon', 'Snowball', 'Boxer', 'Molli', 'Mr. Jones']\n",
      "['David', 'Napoleon', 'Snowball', 'Boxer', 'Molli', 'Mr. Jones']\n"
     ]
    }
   ],
   "source": [
    "animal_farm2 = animal_farm[::]\n",
    "animal_farm3 = list(animal_farm)\n",
    "animal_farm[0] = \"Raoul\"\n",
    "animal_farm2[0] = \"Kevin\"\n",
    "animal_farm3[0] = \"David\"\n",
    "print(animal_farm)\n",
    "print(animal_farm2)\n",
    "print(animal_farm3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that:\n",
    "\n",
    "- You can use slicing and negative indexes together (e.g., `middle = list_name[2:-2]`).\n",
    "- You can ommit the first index (defaults to `0`) and/or the sencond index (defaults to the lenght of the list).\n",
    "- This notation also works on strings (e.g., `string_name[0].upper() + string_name[1:]`).\n",
    "- The slice is a new, fresh list: mutations to one list do not affect the other.\n",
    "- The first index is *inclusive*, the second is *exclusive*.\n",
    "\n",
    "Summary:\n",
    "\n",
    "```a[start:end] # items start through end-1\n",
    "a[start:]    # items start through the rest of the array\n",
    "a[:end]      # items from the beginning through end-1\n",
    "a[:]         # a copy of the whole array\n",
    "a[start:end:step] # start through not past end, by step\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding elements to a list\n",
    "\n",
    "Every list has the `.append()` and `.extend()` methods. They are very useful to manipulate lists. As list are mutable, they can be changed after they are created. So naturally we can also extend lists. Now let's welcome a member to the farm, how about a donkey."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Raoul', 'Napoleon', 'Snowball', 'Boxer', 'Molli', 'Mr. Jones', 'Benjamin']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "donkey = 'Benjamin'\n",
    "animal_farm.append(donkey)\n",
    "\n",
    "animal_farm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will notice that we did not need to assign the new `list` of pets of a different variable, we changed the existing list. This comes down to the mutable nature of lists.\n",
    "\n",
    "If you need to add multiple entries in a list, you have to use `extend` instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Raoul',\n",
       " 'Napoleon',\n",
       " 'Snowball',\n",
       " 'Boxer',\n",
       " 'Molli',\n",
       " 'Mr. Jones',\n",
       " 'Benjamin',\n",
       " 'Jessie',\n",
       " 'Bluebell',\n",
       " 'Pincher']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animal_farm.extend(['Jessie', 'Bluebell', 'Pincher'])\n",
    "animal_farm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that you can also use the `+` operator. However, you have to remember that, unlike `extend` and `append`, the `+` operator creates  a new list instead of mutating the existing list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing elements from a list\n",
    "\n",
    "There are several ways to remove elements from a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `.remove()`\n",
    "\n",
    "The `.remove()` method can delete `element`s that have a specific `value`. Note, it will only remove the *first* element with that `value`. Sadly Old Major passed away."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Raoul',\n",
       " 'Snowball',\n",
       " 'Boxer',\n",
       " 'Molli',\n",
       " 'Mr. Jones',\n",
       " 'Benjamin',\n",
       " 'Jessie',\n",
       " 'Bluebell',\n",
       " 'Pincher']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animal_farm.remove('Napoleon')\n",
    "animal_farm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `del`\n",
    "\n",
    "We can remove a list element by index if with `del`. It is time to start the revolution and remove Mr. Jones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Raoul',\n",
       " 'Snowball',\n",
       " 'Boxer',\n",
       " 'Molli',\n",
       " 'Benjamin',\n",
       " 'Jessie',\n",
       " 'Bluebell',\n",
       " 'Pincher']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del animal_farm[4]\n",
    "animal_farm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `.pop()`\n",
    "\n",
    "The `.pop()` methods of list can also remove `elements` of a `list` based on `index`. The difference to `del` is that it not just remove the element, but in addition it will return the deleted `value`. This allows us to store the value as another variable, or add it to a new list for instance. Some animals are better than others. We need to (sadly) get rid of Boxer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Boxer'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knackered = animal_farm.pop(2)\n",
    "knackered"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeed, the hard working horse was removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Raoul', 'Snowball', 'Molli', 'Benjamin', 'Jessie', 'Bluebell', 'Pincher']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animal_farm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutating elements\n",
    "\n",
    "You can also mutate each element of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Napoléon', 'Snowball', 'Molli', 'Benjamin', 'Jessie', 'Bluebell', 'Pincher']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animal_farm[0] = 'Napoléon'\n",
    "animal_farm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "We can think of a tuple as a row out of a table: it contains a fixed number of values (one for each column of the table). In a simple tuple, you access the values based on the column number (i.e., by position).\n",
    "\n",
    "Unlike lists, tuples are not mutable - i.e. you cannot change their length or modify their contents. You can think of tuples as a filing cabinet filled with laminated sheets - you cannot add more drawers to the filing cabinet, or edit the material in it, but they still have a set order and you can look in a particular drawer to see what is in it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To construct a tuple, you place the different values, in order, separated by commas, between parentheses (`(` and `)`). Tuples are values like any others and you can store them in variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Isaac', 'Newton', 1642)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "famous_scientist = ('Isaac', 'Newton', 1642)\n",
    "famous_scientist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like lists, tuples are indexed by position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Isaac Newton\n"
     ]
    }
   ],
   "source": [
    "print(famous_scientist[0] + ' ' + famous_scientist[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This form of indexing is not robust. If you change your code so that other values are also tracked (e.g., place of birth), the indexing of other values can change. Additionally, the indexing is obscure: what are the fields `0` and `1` for? Fortunately, there is an alternative.\n",
    "\n",
    "You can also extract the different values from a tuple into separate variables directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Newton, Isaac Newton\n"
     ]
    }
   ],
   "source": [
    "fname, lname, year = famous_scientist\n",
    "print(lname + ', ' + fname + ' ' + lname)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be careful when unpacking a tuple: you need use the exact same number of variables as there are values in the tuple. Otherwise we get an `Error`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = famous_scientist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "Dictionaries are made of keys that have associated values. \n",
    "You can imagine a dictionary as folders in a library, each with a label (the `key`). \n",
    "When you want a folder with a particular label, `Python` acts as a librarian and looks up the folder location using an index (or `hash`). \n",
    "It's very quick to find the folder with a particular label and check or modify what's in it. \n",
    "It is also easy to add new folders or remove them from the library - however they have no fixed order!\n",
    "\n",
    "There are two ways to define dictionaries, either with the native syntax (using curly braces (`{}`) and colons (`:`)) or using the function `dict()` function. In both cases we need to speficy the `key` and `value` of the data that we want the dictionary to hold.\n",
    "\n",
    "For instance these two ways of defining a dictionary are equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Simpsons', 'location': 'Springfield'}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dict_name = {'key_1':value_1, 'key_2':value_2, ...}\n",
    "family = {'name': 'Simpsons', 'location': 'Springfield'}\n",
    "family"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could also have defined the dictionary with the curly brackets and semicolons between quoted keys and values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dict_name = dict(key_1=value_1, key_2=value_2, ...)\n",
    "alt_family = dict(name='Simpsons', location='Springfield')\n",
    "alt_family == family"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that you can use all simple values (strings, numbers, booleans) as keys."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### keys and values\n",
    "\n",
    "We can access the different dictionary entries via their key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Simpsons'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "family['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutation\n",
    "\n",
    "Again, dictionaries are mutable, so they can be changed. You can use the native syntax or the `update` method.\n",
    "\n",
    "This can be used both to change the value associated to an existing key or to add a new key-value pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Simpsons',\n",
       " 'location': 'Springfield',\n",
       " 'members': ['Homer', 'Marge', 'Bart', 'Lisa', 'Maggie']}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "family['members'] = ['Homer', 'Marge', 'Bart', 'Lisa', 'Maggie']\n",
    "family"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "family['members'] = ['Homer', 'Marge', 'Bart', 'Lisa', 'Maggie']\n",
    "family"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Until Python 3.7, dictionaries were not ordered. This means that you can not assume that the order in which you defined the entries in the dictionary, will be the order in which they are returned when you ask for the dictionarie's content. \n",
    "\n",
    "From Python 3.7, the order in which you defined the entries is maintained."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "You can create sets using the native syntax (curly braces (`{}`)) or convert other collections using the `set` function. You can think of a set as a bag of different coloured balls. \n",
    "It is very quick to open the bag and see if a particular coloured ball is in there, or add or remove balls to the bag, but they have no order or label. You can also only have one ball of each colour (there are no repeated values in a set!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "allergies = { 'peanut', 'kiwi' }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or equivalently"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "allergies = set(['peanut', 'kiwi'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding and removing elements\n",
    "\n",
    "You can add and remove elements using the methods `add` and `discard`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "allergies.add('milk')\n",
    "allergies.discard('kiwi')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elements\n",
    "\n",
    "You cannot access individual elements of a set: they are not index by position nor name. Instead, you can test whether an element belongs to a set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 'kiwi' in allergies:\n",
    "    print('Do not serve the fruit salad!')\n",
    "if 'milk' in allergies:\n",
    "    print('Do not serve the ice cream!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use cases\n",
    "\n",
    "These different data structures are useful for different use cases. Consider what operations you need on your data structure:\n",
    "\n",
    "- Is it a fixed layout? Tuples!\n",
    "- Is there an inherent order? Lists!\n",
    "- Is there a semantic way to access the different elements? Dictionaries!\n",
    "- Otherwise? Sets!\n",
    "\n",
    "The choice is a bit more complicated, but essentially boils down to this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following sources of information, what data structure should you use to record the information?\n",
    "\n",
    "- The license plates of cars currently in a car park.\n",
    "- The titles of the books of a given author.\n",
    "- The publication year of the books of a given author.\n",
    "- The payroll information of a company (including information for each employee: seniority, job title, salary, etc.).\n",
    "- The geographical coordinates of found shipwreck."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}