ex-01-DictFilesFunc-solution-part1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter Notebook, Arrays, Lists, and Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter notebook usage\n",
    "\n",
    "Remember that you can see all the keyboard shortcut under `Help -> Keyboard Shortcut`.  Please try to memorize and use them as much as you can."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.1) Create a new code cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:** *To create a new code cell either select the correct entry in the \"Insert\" menu or use the one of the following shortcuts:*\n",
    "+ `B` (insert cell below)\n",
    "+ `A` (insert cell above).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2) Create a new Markdown cell write a sentence in it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:** *By default a new cell will be a `code cell`.  To switch to a Markdown cell use the \"Cell->Cell Type\" menu or use the `M` shortcut. You can read more about Markdown at [this link](https://daringfireball.net/projects/markdown/).*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3) Copy the previous, paste it after this one, and set the font face to bold."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:** *Use `C` to copy a cell, `V` to paste it below the selected cell, and `Shift-V` to paste it above.  A sentence surrounded by two asterisks symbols will be formatted using a bold typeface. For example: `**this sentence**` will be formatted as **this sentence**.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.4) Delete the previous cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:** *Use `D`, `D` (i.e., press `D` twice) to delete a cell.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.5) Create a new code cell and write code to print 'Hello, world' (execute it!)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:** *Use `B` to create a cell below.  To print a sentence use the `print` function and pass `\"Hello, world\"` as paramter. To execute a code cell use the `Ctrl+ENTER` shortcut.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists, Loops, Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1) Create a list named `sw_movies` and set its initial value to the sequence `[\"The Phantom Menace\", \"Attack of the Clones\", \"Revenge of the Sith\", \"A New Hope\", \"The Empire Strikes Back\", \"Return of the Jedi\", \"The Force Awakens\", \"The Last Jedi\"]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "sw_movies = [\"The Phantom Menace\", \"Attack of the Clones\",\n",
    "             \"Revenge of the Sith\", \"A New Hope\",\n",
    "             \"The Empire Strikes Back\", \"Return of the Jedi\",\n",
    "             \"The Force Awakens\", \"The Last Jedi\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2) Append `\"Unknown Title\"` to `sw_movies`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:** *It is possible to append an element to a list using the `append` method of it. It is possible to read the documentation directly in the jupyter notebook by issuing one of the following commands.*\n",
    "```python\n",
    "help(sw_movies.append)\n",
    "sw_movies.append?\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function append:\n",
      "\n",
      "append(...) method of builtins.list instance\n",
      "    L.append(object) -> None -- append object to end\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sw_movies.append)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sw_movies.append(\"Unknown Title\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The Phantom Menace', 'Attack of the Clones', 'Revenge of the Sith', 'A New Hope', 'The Empire Strikes Back', 'Return of the Jedi', 'The Force Awakens', 'The Last Jedi', 'Unknown Title']\n"
     ]
    }
   ],
   "source": [
    "print(sw_movies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3) Access (and print) the 5th element of `sw_movies`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:** *Recall that the first element of the list is in position 0.  Thus, the 5th element will be in position 4.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Empire Strikes Back\n"
     ]
    }
   ],
   "source": [
    "print(sw_movies[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4) Access (and print) the element in position 5 of `sw_movies`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Return of the Jedi\n"
     ]
    }
   ],
   "source": [
    "print(sw_movies[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.5) Print the 4th, 5th, and 6th elements of `sw_movies`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:** *There are at least 3 ways print contiguous elements of a list.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ *Print each element using a different call to `print`*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A New Hope\n",
      "The Empire Strikes Back\n",
      "Return of the Jedi\n"
     ]
    }
   ],
   "source": [
    "print(sw_movies[3])\n",
    "print(sw_movies[4])\n",
    "print(sw_movies[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ *Use a single call of `print` to print each element on the same line*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A New Hope  -  The Empire Strikes Back  -  Return of the Jedi\n"
     ]
    }
   ],
   "source": [
    "print(sw_movies[3], \" - \", sw_movies[4], \" - \", sw_movies[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ *Print the sub-list of the elements from position 3 to position 6 (excluded)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A New Hope', 'The Empire Strikes Back', 'Return of the Jedi']\n"
     ]
    }
   ],
   "source": [
    "print(sw_movies[3:6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.6) Delete the last element of the list using `pop()`.  Remember that you can access the documentation of any function using one of the following commands:\n",
    "\n",
    "```python\n",
    "sw_movies.pop?\n",
    "help(sw_movies.pop)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The Phantom Menace', 'Attack of the Clones', 'Revenge of the Sith', 'A New Hope', 'The Empire Strikes Back', 'Return of the Jedi', 'The Force Awakens']\n"
     ]
    }
   ],
   "source": [
    "sw_movies.pop()\n",
    "print(sw_movies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.7) Check the type of `sw_movies`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(sw_movies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.8) Check the type of the elements of `sw_movies`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(sw_movies[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.9) Check the type of the elements of `sw_movies`, iterating over the elements of it using a loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer::** *In Python, the most used loop is the `for` loop. Its syntax is the following*\n",
    "```python\n",
    "for my_element in my_list:\n",
    "    # Do something with my_element, for example print it\n",
    "    print(my_element)\n",
    "```\n",
    "*This for loop will pick one element from `my_list` at each iteration (in order) and will execute the code in the body of the loop.  Please note that at each iteration the value of `my_element` changes and that the indentation of the code matters.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "for movie in sw_movies:\n",
    "    print(type(movie))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:** *You can also use the for loop to loop over the indexes of `sw_movies` using the `range` function as follows.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "for movie_idx in range(len(sw_movies)):\n",
    "    print(type(sw_movies[movie_idx]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Although this for is still correct, the previous one is easier to read.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.10) Print the elements of `sw_movies` alongside their episode number (\"The Phantom Menace\" is episode number 1, \"Attack of the Clones\" is episode number 2. etc. etc.).\n",
    "\n",
    "#### 2.10b) Use [`format`](https://docs.python.org/2/library/string.html#format-string-syntax) to pretty-print the list of episodes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:** *As shown before we can iterate over the indexes of `sw_movies` using the `range` function. Let's use it to solve this exercise*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 The Phantom Menace\n",
      "2 Attack of the Clones\n",
      "3 Revenge of the Sith\n",
      "4 A New Hope\n",
      "5 The Empire Strikes Back\n",
      "6 Return of the Jedi\n",
      "7 The Force Awakens\n",
      "8 The Last Jedi\n"
     ]
    }
   ],
   "source": [
    "for movie_idx in range(len(sw_movies)):\n",
    "    print(movie_idx+1, sw_movies[movie_idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*We can also iterate over the elements of `sw_movies`, updating the episode number manually.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 The Phantom Menace\n",
      "2 Attack of the Clones\n",
      "3 Revenge of the Sith\n",
      "4 A New Hope\n",
      "5 The Empire Strikes Back\n",
      "6 Return of the Jedi\n",
      "7 The Force Awakens\n",
      "8 The Last Jedi\n"
     ]
    }
   ],
   "source": [
    "episode_number = 1\n",
    "for movie in sw_movies:\n",
    "    print(episode_number, movie)\n",
    "    episode_number = episode_number + 1 # We can also use episode_number += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*`format` is a nice function of the `string` class of Python.  It allows to print formatted text easily.  Please refer to the documentation for a more in-depth description of it.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Phantom Menace is episode number 1 of the saga.\n",
      "Attack of the Clones is episode number 2 of the saga.\n",
      "Revenge of the Sith is episode number 3 of the saga.\n",
      "A New Hope is episode number 4 of the saga.\n",
      "The Empire Strikes Back is episode number 5 of the saga.\n",
      "Return of the Jedi is episode number 6 of the saga.\n",
      "The Force Awakens is episode number 7 of the saga.\n",
      "The Last Jedi is episode number 8 of the saga.\n"
     ]
    }
   ],
   "source": [
    "for movie_idx in range(len(sw_movies)):\n",
    "    print(\"{} is episode number {} of the saga.\".format(sw_movies[movie_idx], movie_idx + 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.11) Delete the first element of `sw_movies`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.12) Put `\"The Panthom Menace\"` back in `sw_movies` (it's still canon after all...)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries, Files, Functions, and Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "A dictionary is an unordered collection of zero or more key-value pairs.\n",
    "\n",
    "The most simple dictionary is the empty dictionary and can be instantiated using `{}`.\n",
    "Given a dictionary `d` you can access its fields using the following syntax `d[<field_name>]`.\n",
    "For example, if `d` has a `\"name\"` field you can access it using `d[\"name\"]` (both in read and write).\n",
    "It is also possible to create a dictionary with values in it using the `{ <key1> : <value1> , <key2> : <value2>, ...}` syntax.\n",
    "\n",
    "Dictionaries can be nested.  This means that\n",
    "```python\n",
    "{\n",
    " 'Cristiano' : {'age' : 33, 'role' : 'forward', 'goals' : 3},\n",
    " 'Giorgio' : {'age' : 35, 'role' : 'centre-back', 'goals' : 0},\n",
    " 'Blaise' : {'age' : 31, 'role' : 'midfielder', 'goals' : 2}\n",
    "}\n",
    "```\n",
    "is valid in Python.\n",
    "\n",
    "You can iterate over the keys of a dictionary using the `for` loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1) Create a dictionary (`squares`) in which the keys are the numbers between 1 and 100 and the values are the square of the keys."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2) Iterate over `squares` and print the `(key, value)` pair if and only if `key` is either a multiple of 3 or 5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3) Create a dictionary (`roots`) in which the keys are the numbers between 1 and 100 and the values are the square roots of the keys."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.4) Merge `squares` and `roots` and create a new dictionary (`squares_and_roots`) that maps each key to another dictionary with `'square'` and `'root'` as keys (`squares_and_roots[n]['square']` contains the square of `n` and `square_and_roots[n]['root']` contains the root of `n`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5) For each key in `sqares_and_roots` print the key, the square, and the root on a single line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Files\n",
    "\n",
    "Files are objects you can *read* and *write* to.  There are 3 types of file objects (binary, buffered binary, and text) and we will focus mainly on [text files](https://docs.python.org/3/glossary.html#term-text-file).\n",
    "Text files are files objects that read and write `str` objects, that is sequences of characters.\n",
    "\n",
    "Before using a file you have to `open` a file handler using the `open` built-in function.\n",
    "Take a look at its documentation writing in a code cell one of the two following commands\n",
    "```python\n",
    "open?\n",
    "help(open)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "help(open)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please read carefully the second paragraph of the documentation (the one that starts with `mode is an optional string [...]`.  Please familiarize with modes `'r'`, `'w'`, and `'a'`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1) Read the file `PromessiSposi.txt` and save its content in a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2) Note that each element of the list ends with `\\n`.  What is that? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3) Re-read the file `PromessiSposi.txt` and use [`strip`](https://docs.python.org/2/library/string.html#string.strip) to remove the trailing character (store the lines in a list)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.4) Create a dictionary `promised_words` that maps each distinct word in `PromessiSposi.txt` to the number of times it appears in it.  Use [`split`](https://docs.python.org/2/library/stdtypes.html#str.split)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.5) Create a file 'words_occurrences.txt' and write each distinct word of 'PromessiSposi.txt' alongside the number of occurrences of such word."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries\n",
    "\n",
    "The [Python Standard Library](https://docs.python.org/3/library/) is a powerful help that provides many useful functionalities.\n",
    "Before using the functions of the Python Standard it is required to `import` the corresponding module.\n",
    "For example, if you want to use [`math.floor`](https://docs.python.org/3/library/math.html#math.floor) you'll have to import the `math` module before using it.\n",
    "\n",
    "There are (at least) three main ways to import functionalities from the Python Standard Library.\n",
    "\n",
    "1) Import the whole module\n",
    "```python\n",
    "import math\n",
    "math.floor(3/2)\n",
    "```\n",
    "2) Import the whole module and rename it\n",
    "```python\n",
    "import math as cool_stuff\n",
    "cool_stuff.floor(3/2)\n",
    "```\n",
    "\n",
    "3) Import all the functions of a module\n",
    "```python\n",
    "from math import *\n",
    "floor(3/2)\n",
    "```\n",
    "\n",
    "**Nevertheless, [it is usually NOT a good idea to `import *`](https://stackoverflow.com/questions/2386714/why-is-import-bad) so avoid using method 3.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1) The [random modules](https://docs.python.org/3/library/random.html#module-random) implements pseudo-random number generators and provides functionalities to pick random elements from a sequence.  Use this module to select 3 Star Wars movies from `sw_movies` and print them. Hint: read the documentation of `random.sample`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2) Almost nobody likes \"The Phantom Menace\", pick 3 random Star Wars movies from `sw_movies` and store them in `my_favorite_sw_movies` until \"The Phantom Menace\" is not in `my_favorite_sw_movies`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "\"In the context of programming, a function is a named sequence of statements that performs a computation. When you define a function, you specify the name and the sequence of statements. Later, you can “call” the function by name\" (see [Think in Python - Chapter 3](http://greenteapress.com/thinkpython2/html/thinkpython2004.html)).\n",
    "\n",
    "Defining and writing functions if fundamental to avoid building complex (and bug-prone!) software.\n",
    "A function looks something like this\n",
    "```python\n",
    "def func_name(x, y=3):\n",
    "\t# Do whatever we want this function to do,\n",
    "\t#  using x and y.\n",
    "\n",
    "# Use func_name to call the function.\n",
    "func_name(value_1, value_2)\n",
    "\n",
    "# Use func_name to call the function, without setting y.\n",
    "# y will be equal to 3 (default value)\n",
    "func_name(value_1)\n",
    "\n",
    "```\n",
    "\n",
    "Remember that you have to define function **before** using them or your software will crash."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.1) Complete the function `my_split_with_counts` that accepts a string `s` and returns a dictionary whose keys are the unique words in `s` and whose values are the number of occurrences of the key in `s`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_split_with_counts(sequence):\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.2) Write a function `random_sample_avoid_element` that accepts a list `L`, a number `k`, and an element `e`, and returns a list of `k` elements of `L` that does not contain `e`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_sample_avoid_element(L, k, e):\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.3) Use `random_sample_avoid_element` to solve exercise 5.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.4) Implement the `square_root_is_odd` function that returns `True` if the square root of the argument is odd, or `False` otherwise."
   ]
  }
 ],
 "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
}