Topic 03 - Data Structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Index<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Introduction\" data-toc-modified-id=\"Introduction-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Introduction</a></span></li><li><span><a href=\"#Lists\" data-toc-modified-id=\"Lists-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Lists</a></span><ul class=\"toc-item\"><li><span><a href=\"#Indexing\" data-toc-modified-id=\"Indexing-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Indexing</a></span></li><li><span><a href=\"#Slicing\" data-toc-modified-id=\"Slicing-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Slicing</a></span></li><li><span><a href=\"#Lists-methods\" data-toc-modified-id=\"Lists-methods-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Lists methods</a></span></li></ul></li><li><span><a href=\"#Dictionaries\" data-toc-modified-id=\"Dictionaries-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Dictionaries</a></span><ul class=\"toc-item\"><li><span><a href=\"#Methods\" data-toc-modified-id=\"Methods-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Methods</a></span></li></ul></li><li><span><a href=\"#Tuples\" data-toc-modified-id=\"Tuples-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Tuples</a></span></li><li><span><a href=\"#Expressions-with-*\" data-toc-modified-id=\"Expressions-with-*-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Expressions with *</a></span></li><li><span><a href=\"#Exercices\" data-toc-modified-id=\"Exercices-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Exercices</a></span><ul class=\"toc-item\"><li><span><a href=\"#Lists\" data-toc-modified-id=\"Lists-6.1\"><span class=\"toc-item-num\">6.1&nbsp;&nbsp;</span>Lists</a></span></li><li><span><a href=\"#Dicionaries\" data-toc-modified-id=\"Dicionaries-6.2\"><span class=\"toc-item-num\">6.2&nbsp;&nbsp;</span>Dicionaries</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "The most commom structures types in Python are:\n",
    "\n",
    "* Lists\n",
    "* Dictionaries\n",
    "* Tuples\n",
    "\n",
    "# Lists\n",
    "\n",
    "Are mutable sequences of any kind of objects. To create a list you have to use the following form: \n",
    "\n",
    "```Python\n",
    "list = [object1, object2,objectn]\n",
    "```\n",
    "\n",
    "You can also transform any object in a listy with \n",
    "```Python\n",
    "list(object)\n",
    "```\n",
    "\n",
    "Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = ['a', 'b', 'c', 'd']\n",
    "list3 = [list1, list2]\n",
    "list4 = list('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing\n",
    "\n",
    "To get the elements of a list you can use the following form:\n",
    "\n",
    "```Python\n",
    "list[index]\n",
    "```\n",
    "Remember that the index in Python beging with **0**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello world!'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello = ['Hello world!']\n",
    "hello[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'l'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello[0][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that in lists you can not use the notation [i,j] to access to the elements of internal lists\n",
    "\n",
    "To get the elements of a list but taking as reference the las element, you can use the following form:\n",
    "\n",
    "```Python\n",
    "list[-1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing\n",
    "\n",
    "You can acces to many elements in a list using the following form: \n",
    "\n",
    "```Python\n",
    "list[index1:index2:step]\n",
    "```\n",
    "\n",
    "However, *index2* will not be included in the result. Example "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[0:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[0:5:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With a negative step you can rever the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 4, 3, 2]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[-1:0:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you dont specify **index1** Python will assume that is **0**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you dont specify **index2** Python will assume that is the las element of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[-3:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some useful functions that can be used in lists are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to remove a specific element from a list using the **del** command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del list1[0]\n",
    "list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists methods \n",
    "Some of the most common methods are:\n",
    "\n",
    "* ```append(object)```, Add an object at the end of the list\n",
    "* ```del(index)```, Remove the element in **index** from the list\n",
    "* ```pop()```, Remove the last object in the list\n",
    "* ```sort()```, organizes the elements of a list based on a criterion.\n",
    "* ```reverse()```, invert the order of the list\n",
    "* `extend(list)`, concatenate a list with another one. Note that the first list will be modified\n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 4, 3, 2]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1.reverse()\n",
    "list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 42]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "a.append(42)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "a.extend(b)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to concatenate two lists without modify the first list you can use the operator **+**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  [1, 2, 3]\n",
      "c =  [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "c = a + b\n",
    "\n",
    "print('a = ',a)\n",
    "print('c = ',c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries\n",
    "\n",
    "Are data structures that relates **keys** and **values**. The **keys** have to be immutable so they normaly are *strings* The key and value set is called **item**.\n",
    "\n",
    "You can create dictionaries in two ways:\n",
    "\n",
    "1. Empty dictionary. Dictionary = {}.\n",
    "2. Dictionary = `{key:value}`. Each item have to be separated by *,*: Dictionary = `{key1:value1, key2:value2}`\n",
    "\n",
    "You also can create a new item in an existent dicionary with `dict[newKey] = value`.\n",
    "\n",
    "Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Name': 'Katy', 'Age': 31, 'Characteristic': 'Funny'}\n",
      "Katy\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Name':'Katy', 'Age':31, 'Characteristic':'Funny'}\n",
    "\n",
    "dict2 = {}\n",
    "dict2['Name'] = 'Jhair'\n",
    "dict2['Age'] = 29\n",
    "dict2['Characteristic'] = 'Serious'\n",
    "\n",
    "print(dict1)\n",
    "print(dict1['Name'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods\n",
    "\n",
    "The most commons are:\n",
    "\n",
    "* `keys()` to get the keys\n",
    "* `values()` to get the values\n",
    "* `items()` to get the items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['Name', 'Age', 'Characteristic'])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['Jhair', 29, 'Serious'])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict2.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('Name', 'Jhair'), ('Age', 29), ('Characteristic', 'Serious')])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict2.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "\n",
    "Are basically immutable list. They are created with: `tuple = (value1,value2)`. They are useful to save constants or to be used as keys in dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,) (1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "a = (1,)\n",
    "b = (1,2,3)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Expressions with *\n",
    "\n",
    "There is a way to pass arguments to functions from lists and dictionaries. This is done using asterisks, `*` before the list name and `**` before a dictionary. For example, we know that the `print` function takes any number of simple arguments, which will be printed as strings, and has some optional arguments, such as` end` and `sep`. Here we will define a list and a dictionary, and we will pass these objects to the print function. This is useful when we have many functions that take the same arguments, and want to set the arguments only once. The description of this is [here](https://docs.python.org/3/tutorial/controlflow.html#unpacking-argument-lists). This is useful when we want to create very general functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is an example\n"
     ]
    }
   ],
   "source": [
    "text = ['This', 'is', 'an', 'example']\n",
    "config = {'sep':' ', 'end':'\\n'}\n",
    "\n",
    "print(*text, **config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercices \n",
    "\n",
    "## Lists\n",
    "\n",
    "Using *list()* and *range()* create a list of numbers from 0 to 100 with steps of 5. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your code goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dicionaries\n",
    "\n",
    "Create a dictionary with the keys AG, BG, CG, ABG, ABC, and ABCG, and the values 1, 2, 3, 4, 7, 11. Then print the value for the key CG."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Your code goes here"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Index",
   "title_sidebar": "Index",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}