W2D2-Exercise_sol.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 2: Basic Python 2\n",
    "\n",
    "Builds on exercises provided with Programming with Python for Social Science by Phillip Brooker and from Social Data Science 2019 by Andreas Bjerre-Nielson\n",
    "\n",
    "## 2.1 Lists\n",
    "\n",
    "**Question 2.1.1**: make two lists, `mammals` and `reptiles`with respectively \"dog\",\"cat\",\"dolphin\" and \"gecko\",\"monitor lizard\",\"iguana\". What is the index of \"iguana\" in `reptiles`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.1.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'iguana'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mammals = [\"dog\", \"cat\", \"dolphin\"]\n",
    "reptiles = [\"gecko\", \"monitor lizard\", \"iguana\"]\n",
    "\n",
    "#The index of \"iguana\" is 2 because indices start from 0\n",
    "#Checking answer\n",
    "reptiles[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.1.2**: make a list `animals` which consist of first `mammals`, then `reptiles`. \n",
    "Hint: See what happens when you `+` two lists together. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.1.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dog', 'cat', 'dolphin', 'gecko', 'monitor lizard', 'iguana']\n"
     ]
    }
   ],
   "source": [
    "#adding lists mammals and reptiles\n",
    "animals = mammals + reptiles\n",
    "\n",
    "#printing new list animals\n",
    "print(animals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.1.3**: Create list `some_reptiles` that contains only the second and third elements of `reptiles`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.1.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['monitor lizard', 'iguana']\n"
     ]
    }
   ],
   "source": [
    "#making a sub-list of reptiles\n",
    "some_reptiles = reptiles[1:3] \n",
    "\n",
    "#printing new list of some_reptiles\n",
    "print(some_reptiles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- range starts at 1 because indices start at 0\n",
    "- range ends at 3 because the endpoint is not included in taking the range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.1.4**: replace the second element of `reptiles` with \"komodo dragon\". What are the values of `some_reptiles` now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.1.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['monitor lizard', 'iguana']\n"
     ]
    }
   ],
   "source": [
    "#replacing the second element of reptiles\n",
    "reptiles[1] = \"komodo dragon\"\n",
    "\n",
    "#checking the values of some_reptiles\n",
    "print(some_reptiles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The values of `some_reptiles` didn't change because the elements of `reptiles` were copied when creating some_reptiles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.1.5**: Create a list `animals2` that contains nested lists `mammals` and `reptiles`. How would you access the element \"dolphin\"?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.1.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dolphin'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#creating animals2\n",
    "animals2 = [mammals, reptiles]\n",
    "\n",
    "#accessing 'dolphin' which is the third element \n",
    "#of the first list\n",
    "animals2[0][2]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Because the lists are nested, access the list indice first (i.e. mammals) and then the element index (dolphin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.1.6**: What is the length of `animals` versus `animals2`? Why? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.1.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "animals: 6\n",
      "animals2: 2\n"
     ]
    }
   ],
   "source": [
    "#The length of animals is 6 and animals2 is 2\n",
    "\n",
    "#Checking answer\n",
    "print(\"animals: \" + str(len(animals)))\n",
    "print(\"animals2: \" + str(len(animals2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- animals contains all of the elements in the main list\n",
    "- animals2 contains two lists (it does not matter how many elements are in these lists)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.1.7**: Take the list below (it is the population of Denmark on Jan 1 from 1901 to 2020 in 1000s).\n",
    "\n",
    "How many elements are in the list? \n",
    "\n",
    "What is the range of the first 10 items? \n",
    "\n",
    "What is the range for elements between indices 80 and 90 (i.e. 1981 - 1991)? \n",
    "\n",
    "What was the population in 1904 (Hint: This is the fourth element in the list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of years in the list is:120\n",
      "The range in the first 10 years is:275\n",
      "The range 1911 to 1921 is:24\n",
      "The population in 1904 was: 2532\n"
     ]
    }
   ],
   "source": [
    "#Data from https://www.statbank.dk/10021\n",
    "DK_population =[2447,2477,2506,2532,2560,2589,2621,2652,2687,2722,\n",
    "                2757,2788,2820,2851,2886,2921,2958,2991,3027,3061,\n",
    "                3265,3306,3340,3372,3406,3439,3467,3487,3510,3531,\n",
    "                3557,3590,3620,3651,3683,3711,3738,3765,3794,3826,\n",
    "                3849,3882,3926,3973,4023,4075,4123,4168,4211,4252,\n",
    "                4285,4315,4349,4389,4424,4454,4479,4501,4532,4566,\n",
    "                4601,4630,4666,4703,4741,4779,4820,4855,4879,4907,\n",
    "                4951,4976,5008,5036,5054,5065,5080,5097,5112,5122,\n",
    "                5124,5119,5116,5112,5111,5116,5125,5129,5130,5135,\n",
    "                5146,5162,5181,5197,5216,5251,5275,5295,5314,5330,\n",
    "                5349,5368,5384,5398,5411,5427,5447,5476,5511,5535,\n",
    "                5561,5581,5603,5627,5660,5707,5749,5781,5806,5823]\n",
    "\n",
    "#Answer to Question 2.1.8\n",
    "\n",
    "#counting number of elements in the list aka. the length of the list\n",
    "list_size = len(DK_population)\n",
    "\n",
    "#Finding the range of population size in the first 10 years\n",
    "min_pop1 = min(DK_population[:10])\n",
    "max_pop1 = max(DK_population[:10])\n",
    "range1 = max_pop1 - min_pop1\n",
    "\n",
    "#Finding the range of population size in the last 10 years\n",
    "min_pop2 = min(DK_population[80:90])\n",
    "max_pop2 = max(DK_population[80:90])\n",
    "range2 = max_pop2-min_pop2\n",
    "\n",
    "#Population in 1904\n",
    "pop_1904 = DK_population[3]\n",
    "\n",
    "#printing the results\n",
    "print(\"The number of years in the list is:\" + str(list_size))\n",
    "print(\"The range in the first 10 years is:\" + str(range1))\n",
    "print(\"The range 1911 to 1921 is:\" + str(range2))\n",
    "print(\"The population in 1904 was: \" + str(pop_1904))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 More Strings\n",
    "\n",
    "**Question 2.2.1**: Let `s1 = 'Chameleon`. From the string `s1` select the last four characters. What is the index of the character `a` in `s1`?\n",
    "\n",
    "*Hint*: We can selecting a substring by slicing it with the `[]` notation, from the start to end where start is included and end is excluded. Recall that Python has zero-based indexing, see explanation [here](https://softwareengineering.stackexchange.com/questions/110804/why-are-zero-based-arrays-the-norm).   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.2.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = 'Chameleon'\n",
    "\n",
    "#last four characters of s_1\n",
    "s1_chars = s1[-4:]\n",
    "\n",
    "#The index of 'a' is 2\n",
    "#Checking the answer\n",
    "s1.index('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Quesion 2.2.2**: Let `my_url` be a url of your choice. Retrieve the part of a string before a specified character. \n",
    "For example, if your URL is the link for our course: https://kurser.ku.dk/course/aana18119u/2019-2020 and specific character is '/', then you should retrieve https://kurser.ku.dk/course/aana18119u. \n",
    "\n",
    "Remember that you can consult the [documentation for strings](https://docs.python.org/2.5/lib/string-methods.html) to find relevant methods "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.2.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "https://kurser.ku.dk/course/aana18119u\n"
     ]
    }
   ],
   "source": [
    "#Original URL\n",
    "my_url = \"https://kurser.ku.dk/course/aana18119u/2019-2020\"\n",
    "\n",
    "#Using rsplit method, which splits from the right. \n",
    "#'/' indicates the character to split by, 1 indicates how many splits, and [0] retrieves the first element in the list\n",
    "#method details in string documentation\n",
    "shorter_url = my_url.rsplit('/',1)[0]\n",
    "\n",
    "#printing the url \n",
    "print(shorter_url)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Conditions and Loops\n",
    "\n",
    "**Question 2.3.1**: Revisit your script workflow from the previous assignment (Question 1.4.3). For which part of your script would you need to use a loop? What kind of loop would you use?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.3.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.3.2**: Using the list of population size `DK_population` from above, calculate the average population of Denmark from year 1901 to 2020 (the whole list) using a loop. Round to the nearest whole number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.3.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average population from 1901 to 1920 was: 4363\n"
     ]
    }
   ],
   "source": [
    "DK_pop_avg = 0\n",
    "\n",
    "#looping through elements to create a sum of all elements\n",
    "for i in DK_population:\n",
    "    DK_pop_avg += i\n",
    "\n",
    "#Dividing by the number of elements\n",
    "DK_pop_avg /= len(DK_population)\n",
    "\n",
    "#printing the results\n",
    "print(\"The average population from 1901 to 1920 was: \" + str(round(DK_pop_avg)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.3.3**: Suppose you want your population size list to show the full population, not represented in the 1000s (i.e. 2447 should really be 2447000). Using a loop, create a new list `DK_population_long` where the elements show the full population. If you used a for loop for Question 2.3.2 then use a while loop for this question, or vice versa. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to Question 2.3.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initializing variables\n",
    "count = 0\n",
    "DK_population_long = []\n",
    "\n",
    "#looping through DK_population, adding each element to DK_population_long and multiplying it by 1000\n",
    "while count < len(DK_population):\n",
    "    DK_population_long.append(DK_population[count] * 1000)\n",
    "    count += 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Dictionaries\n",
    "**Question 2.4.1**: Take the list of population size `DK_population` above and make a Dictionary called `DK_population_dict` with keys year and population (with the appropriate values). Recall that the data represents 1901 to 2020.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.4.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1901: 2447, 1902: 2477, 1903: 2506, 1904: 2532, 1905: 2560, 1906: 2589, 1907: 2621, 1908: 2652, 1909: 2687, 1910: 2722, 1911: 2757, 1912: 2788, 1913: 2820, 1914: 2851, 1915: 2886, 1916: 2921, 1917: 2958, 1918: 2991, 1919: 3027, 1920: 3061, 1921: 3265, 1922: 3306, 1923: 3340, 1924: 3372, 1925: 3406, 1926: 3439, 1927: 3467, 1928: 3487, 1929: 3510, 1930: 3531, 1931: 3557, 1932: 3590, 1933: 3620, 1934: 3651, 1935: 3683, 1936: 3711, 1937: 3738, 1938: 3765, 1939: 3794, 1940: 3826, 1941: 3849, 1942: 3882, 1943: 3926, 1944: 3973, 1945: 4023, 1946: 4075, 1947: 4123, 1948: 4168, 1949: 4211, 1950: 4252, 1951: 4285, 1952: 4315, 1953: 4349, 1954: 4389, 1955: 4424, 1956: 4454, 1957: 4479, 1958: 4501, 1959: 4532, 1960: 4566, 1961: 4601, 1962: 4630, 1963: 4666, 1964: 4703, 1965: 4741, 1966: 4779, 1967: 4820, 1968: 4855, 1969: 4879, 1970: 4907, 1971: 4951, 1972: 4976, 1973: 5008, 1974: 5036, 1975: 5054, 1976: 5065, 1977: 5080, 1978: 5097, 1979: 5112, 1980: 5122, 1981: 5124, 1982: 5119, 1983: 5116, 1984: 5112, 1985: 5111, 1986: 5116, 1987: 5125, 1988: 5129, 1989: 5130, 1990: 5135, 1991: 5146, 1992: 5162, 1993: 5181, 1994: 5197, 1995: 5216, 1996: 5251, 1997: 5275, 1998: 5295, 1999: 5314, 2000: 5330, 2001: 5349, 2002: 5368, 2003: 5384, 2004: 5398, 2005: 5411, 2006: 5427, 2007: 5447, 2008: 5476, 2009: 5511, 2010: 5535, 2011: 5561, 2012: 5581, 2013: 5603, 2014: 5627, 2015: 5660, 2016: 5707, 2017: 5749, 2018: 5781, 2019: 5806, 2020: 5823}\n"
     ]
    }
   ],
   "source": [
    "#Creating a list of years\n",
    "years = list(range(1901,2021))\n",
    "\n",
    "#Zipping together the years and population\n",
    "key_values = list(zip(years, DK_population))\n",
    "\n",
    "#Creating a dictionary\n",
    "DK_population_dict = dict(key_values)\n",
    "\n",
    "#Printing dictionary to see results\n",
    "print(DK_population_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.4.2**: What was the population in the year 1950?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.4.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4252"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DK_population_dict[1950]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.4.3**: Write a dictionary called `my_dictionary` that stores:\n",
    "- Your favourite animal\n",
    "- Your favourite colour\n",
    "- Your favourite TV Show\n",
    "- Your favourite film"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.4.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dictionary = {'animal':'cat',\n",
    "                 'colour':'green',\n",
    "                 'tv-show':'magicians',\n",
    "                 'film':'none'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.4.4**: Add a key and value to the your dictionary from 2.4.3 with your favourite band or artist. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.4.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dictionary.update({'band':'Great Big Sea'})\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.4.5**: \n",
    "1. Delete the favourite film field.\n",
    "2. Create an empty dictionary with the variable name as your favourite movie \n",
    "3. Populate the dictionary with the following keys (and give them values): \n",
    "    - Year\n",
    "    - Genre\n",
    "4. Do steps 2 and 3 for a two or three movies. \n",
    "5. Add the dictionaries of movies to a new dictionary called `favourite_movies` with the movie title as the key for each entry. \n",
    "6. Add `favourite_movies` to your `my_dictionary` under the key \"Favourite movies\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.4.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'none'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Removing favorite film field\n",
    "my_dictionary.pop('film')\n",
    "\n",
    "#Note: THis is being kept in a separate cell \n",
    "#because we only want to run this once, but testing\n",
    "#the cell below might take multiple tries!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'animal': 'cat', 'colour': 'green', 'tv-show': 'magicians', 'band': 'Great Big Sea', 'Favourite movies': {'Star Wars: Rise of Skywalker': {'Year': 2019, 'Genre': 'Sci-fi'}, 'Thor: Ragnarok': {'Year': 2017, 'Genre': 'Superhero'}}}\n"
     ]
    }
   ],
   "source": [
    "#Below shows a variety of ways to add things to dictionaries\n",
    "#Some are simpler than others!\n",
    "\n",
    "#Creating new dictionaries\n",
    "Star_Wars = {'Year': 2019,\n",
    "             'Genre': 'Sci-fi'}\n",
    "Thor_Ragnarok = {'Year': 2017,\n",
    "                 'Genre': 'Superhero'}\n",
    "\n",
    "#Creating dictionary of favourite movies\n",
    "favourite_movies={'Star Wars: Rise of Skywalker': Star_Wars,\n",
    "                 'Thor: Ragnarok': Thor_Ragnarok}\n",
    "\n",
    "#adding to my dictionary\n",
    "my_dictionary['Favourite movies'] = favourite_movies\n",
    "\n",
    "#printing the dictionary\n",
    "print(my_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2.4.6**: See if you can print out different keys and values from `my_dictionary`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Answer to question 2.4.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017\n"
     ]
    }
   ],
   "source": [
    "#printing out the year that Thor came out\n",
    "print(my_dictionary['Favourite movies']['Thor: Ragnarok']['Year'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Reflection\n",
    "**Question 2.5.1**: Write a brief paragraph reflecting on your experience learning programming today. What did you struggle with? What did you enjoy? What surprised you?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todays exercises were a bit long, but we hope you had fun! Mountain climbing Octocat says congrats on finishing!\n",
    "<img src=\"./octocat.png\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}