02 - dictionaries - instructor-with answer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hash table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Previously we learned about sequence object: *string*, *list*, *tuple*. Now we are going to learn about a new object which implement the notion of **hash table**.\n",
    "\n",
    "Why do we need this new notion? \n",
    "\n",
    "Sequence are great tool but they have one big limitation. The execution time to find one specific value inside is linear:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'x' in range(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 µs ± 107 ns per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit -n100 'x' in range(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.58 ms ± 116 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit -n100 'x' in range(100_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27 ms ± 411 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit -n100 'x' in range(1_000_000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a real problem because the membership test is very useful and common so we would like to have something which is not dependent of the number of element."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Another limitation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We would like, for example to associate a key to an element like here the name alice with the age 35. We cannot do that with a list or any of the sequence object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 't' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-79268e8768db>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'alice'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m35\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 't' is not defined"
     ]
    }
   ],
   "source": [
    "t['alice'] = 35"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the error we are getting. \n",
    "\n",
    "The hash table structure is the answer to this two limitations and in python it is implemented under the name of dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are created by using the squared bracket**[ ]**, dictionaries are created with curly bracket **{ }**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d = {} # en empty dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest way to create a dictionary with some value is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'keyname': 'keyvalue'}\n"
     ]
    }
   ],
   "source": [
    "d = {'keyname': 'keyvalue'}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we are using the previous example, we can create a hash table, a python dictionary, using the name of the person as *key* anf the age as *value*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d = {'alice': 35, 'bob': 18}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alice': 35, 'bob': 18}\n"
     ]
    }
   ],
   "source": [
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note: To go deeper**\n",
    "\n",
    "Dictionary can also be created with a function *dict* similar to the *list* function used to create list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alice': 35, 'jane': 24, 'bob': 18}\n"
     ]
    }
   ],
   "source": [
    "d2 = dict([('alice', 35), ('jane', 24), ('bob',18)])\n",
    "print(d2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'bob': 18, 'alice': 35, 'jane': 24}\n"
     ]
    }
   ],
   "source": [
    "d3 = dict(bob=18, alice=35, jane=24)\n",
    "print(d3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Access"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access an element of the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name of the person is used as key: alice\n",
      "The value associated to that key is: 35\n"
     ]
    }
   ],
   "source": [
    "key = 'alice'\n",
    "value = d['alice']\n",
    "\n",
    "print('The name of the person is used as key:', key)\n",
    "print('The value associated to that key is:', d[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding an element to a dictionary is done by creating a new *key* and affecting a value to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alice': 35, 'bob': 18}\n"
     ]
    }
   ],
   "source": [
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d['jane'] = 24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alice': 35, 'bob': 18, 'jane': 24}\n"
     ]
    }
   ],
   "source": [
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to add element using the method **update**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alice': 35, 'bob': 18, 'jane': 24, 'tom': 54, 'david': 87}\n"
     ]
    }
   ],
   "source": [
    "d2 = {'tom': 54, 'david': 87}\n",
    "\n",
    "d.update(d2)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**note:**\n",
    "\n",
    "It is not possible to use the operator *+* to concatenate dictionaries. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'dict' and 'dict'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-a6305e6df312>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m{\u001b[0m\u001b[0;34m'alice'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m35\u001b[0m\u001b[0;34m}\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m'bob'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m18\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'dict' and 'dict'"
     ]
    }
   ],
   "source": [
    "{'alice': 35} + {'bob': 18}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Key have to be unique; you cannot have two keys with the same name. If you try to add a key with a name already used you will overwrite the value of the previous one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alice': 35, 'bob': 18, 'jane': 24, 'tom': 54, 'david': 87}\n",
      "{'alice': 12, 'bob': 18, 'jane': 24, 'tom': 54, 'david': 87}\n"
     ]
    }
   ],
   "source": [
    "print(d)\n",
    "d['alice'] = 12\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Equality between dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To be equal, all the elements which compose one of the dictionay have to be present in the second and only them. The **position** is not important. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dictionary 1: {'alice': 12, 'bob': 18, 'jane': 24, 'tom': 54, 'david': 87}\n",
      "dictionary 2: {'tom': 54, 'david': 87}\n",
      "dictionary 3: {'bob': 18, 'alice': 35, 'jane': 24}\n",
      "dictionary 4: {'alice': 35, 'bob': 18, 'jane': 24}\n",
      "\n",
      "Dictionary 1 and dictionary 2 are not equal: False\n",
      "Dictionary 1 and dictionary 3 are not equal: False\n",
      "Dictionary 3 and dictionary 4 are equal: True\n"
     ]
    }
   ],
   "source": [
    "d1 = {'alice': 12, 'bob': 18, 'jane': 24, 'tom': 54, 'david': 87}\n",
    "d2 = {'tom': 54, 'david': 87}\n",
    "d3 = {'bob': 18, 'alice': 35, 'jane': 24}\n",
    "d4 = {'alice': 35, 'bob': 18, 'jane': 24}\n",
    "\n",
    "\n",
    "print('dictionary 1:', d1)\n",
    "print('dictionary 2:', d2)\n",
    "print('dictionary 3:', d3)\n",
    "print('dictionary 4:', d4)\n",
    "\n",
    "print()\n",
    "print('Dictionary 1 and dictionary 2 are not equal:', d1 == d2)\n",
    "print('Dictionary 1 and dictionary 3 are not equal:', d1 == d3)\n",
    "print('Dictionary 3 and dictionary 4 are equal:', d3 == d4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Useful method associated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries have their own methods. Some of the most useful are *keys* and *values* which, as their name suggest, extract all the keys and all the values in an iterator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['alice', 'bob', 'jane', 'tom', 'david'])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([12, 18, 24, 54, 87])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary are iterable (it is possible to use loop with them)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to operate some operation on a dictionary by iterating on the elements using the keys and the *keys* method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alice\n",
      "bob\n",
      "jane\n",
      "tom\n",
      "david\n"
     ]
    }
   ],
   "source": [
    "for key in d.keys():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**note: To go depper**\n",
    "\n",
    "You can iterate on a dictionary directly. This is equivalent to ask for the key. It save some character but at a cose of lisibility."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alice\n",
      "bob\n",
      "jane\n",
      "tom\n",
      "david\n"
     ]
    }
   ],
   "source": [
    "for k in d:\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keys from dictionary 3: ['bob', 'alice', 'jane']\n",
      "['alice', 'bob', 'jane']\n"
     ]
    }
   ],
   "source": [
    "keys = list(d3.keys())\n",
    "print('Keys from dictionary 3:', keys)\n",
    "\n",
    "# We can sort them.\n",
    "keys.sort()\n",
    "print(keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Presence (or not) of an element inside a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to test if a *key* is present in the dictionary (or not) using the keyword **in**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'alice' in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'mark' in d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or not:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'mark' not in d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warning:**\n",
    "\n",
    "You cannot test the value presence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 in d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But you can use the method *values* which will return a list of the value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 in d.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Composite dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to have composite object in a dictionary. A key has to be a simple object (string, integer, float). It cannot be a complex one like a numpy array but the value can be every valid python object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key1 : 1\n",
      "key2 : 2\n",
      "key3 : {'subdic': 3}\n",
      "key4 : [0 1 2 3 4 5 6 7 8 9]\n",
      "\n",
      "A composite dictionary: {'key1': 1, 'key2': 2, 'key3': {'subdic': 3}, 'key4': array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])}\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "d = {'key1': 1}\n",
    "d['key2'] = 2\n",
    "d['key3'] = {'subdic': 3}\n",
    "d['key4'] = np.arange(10)\n",
    "\n",
    "for key in d:\n",
    "    print(key, ':', d[key])\n",
    "    \n",
    "print()\n",
    "print('A composite dictionary:', d)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dictionary and string formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String and dictionary have strong link and the usage of dictionary increase the capacity of the print function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1st: 1 2nd: 2 3rd: 3\n",
      "1st: 1 , 2nd: 2 , 3rd: 3\n",
      "1st: 1, 2nd: 2, 3rd: 3\n",
      "1st: 1, 2nd: 2, 3rd: 3\n",
      "1st: 1, 2nd: 2, 3rd: 3\n",
      "1st: 1, 2nd: 2, 3rd: 3\n"
     ]
    }
   ],
   "source": [
    "d = {'a': 1, 'b':2, 'c': 3}\n",
    "\n",
    "print('1st:', d['a'], '2nd:', d['b'], '3rd:', d['c'])\n",
    "\n",
    "print('1st:', d['a'], ', 2nd:', d['b'], ', 3rd:', d['c'])\n",
    "\n",
    "print('1st: {}, 2nd: {}, 3rd: {}'.format(d['a'], d['b'],d['c']))\n",
    "\n",
    "print('1st: {0}, 2nd: {2}, 3rd: {1}'.format(d['a'], d['c'], d['b']))\n",
    "\n",
    "print('1st: {var[a]}, 2nd: {var[b]}, 3rd: {var[c]}'.format(var=d))\n",
    "\n",
    "print('1st: {first}, 2nd: {second}, 3rd: {third}'.format(first=1, second=2, third=3))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The format method allows you to manipulate your string in a very powerful way. You can find more documentation [here](https://pyformat.info/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "when you want to save information in a file this is also how you will format your output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f = open('myfile.txt', 'w')\n",
    "\n",
    "line1 = '1st: {var[a]}, 2nd: {var[b]}, 3rd: {var[c]}\\n'.format(var=d)\n",
    "line2 = '1st: {first}, 2nd: {second}, 3rd: {third}\\n'.format(first=1, second=2, third=3)\n",
    "line3 = '1st: {var[a]:04d}, 2nd: {var[b]:3.4f}, 3rd: {var[c]}\\n'.format(var=d)\n",
    "\n",
    "f.write(line1)\n",
    "f.write(line2)\n",
    "f.write(line3)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%more myfile.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "<li>\n",
    "    Read the file *agelist.txt* and copy the data in a dictionary similar to the one above.\n",
    "    <br>\n",
    "    Hint: Splice the data to not use the first line. \n",
    "</li>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Name    Age     \\n', 'Bob     18\\n', 'Jane    24\\n', 'Alice   35\\n']\n"
     ]
    }
   ],
   "source": [
    "with open('data/agelist.txt') as f:\n",
    "    data = f.readlines()\n",
    "\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bob     18'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1].strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Bob', '18']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1].strip().split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Bob': 18, 'Jane': 24, 'Alice': 35}\n"
     ]
    }
   ],
   "source": [
    "with open('data/agelist.txt') as f:\n",
    "    data = f.readlines()\n",
    "\n",
    "data = data[1:]  # Remove the header\n",
    "d = {}\n",
    "\n",
    "for i, line in enumerate(data):\n",
    "    line = line.strip().split()\n",
    "    d[line[0]] = int(line[1])\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background:#B1E0A8; padding:10px 10px 10px 10px;'>\n",
    "<H2> Challenges </H2>\n",
    "<li>\n",
    "    Create a list with the *inflammations* csv files present in the *data* directory.\n",
    "    <br>\n",
    "    Hint: Use the ```glob``` library.\n",
    "</li>\n",
    "<br>\n",
    "<li>\n",
    "Create a dictionary which will have for key the name of files from the previous list and as value the data from the files.\n",
    "</li>\n",
    "Hint: You can use the function ```loadtxt``` provided by the library ```numpy```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution Challenge 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/gruel/Documents/Cours/Python advanced class - Jupyter notebook/data\n",
      "['inflammation-01.csv', 'inflammation-02.csv', 'inflammation-03.csv']\n"
     ]
    }
   ],
   "source": [
    "%cd 'data/'\n",
    "import glob\n",
    "filenames = sorted(glob.glob('inflammation-*.csv'))\n",
    "print(filenames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution Challenge 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "\n",
      " inflammation-01.csv: <class 'numpy.ndarray'>\n",
      "\n",
      " inflammation-02.csv: <class 'numpy.ndarray'>\n",
      "\n",
      " inflammation-03.csv: <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "\n",
    "inflammation_data = {}\n",
    "for fname in filenames:\n",
    "    data = numpy.loadtxt(fname, delimiter=',') # CSV file\n",
    "    inflammation_data[fname] = data\n",
    "\n",
    "    \n",
    "print(type(inflammation_data))\n",
    "\n",
    "for key in inflammation_data:\n",
    "    #print('\\n', key, ':\\n\\n', inflammation_data[key])\n",
    "    print('\\n {}: {}'.format(key, type(inflammation_data[key])))\n",
    "    \n"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}