python_data_manipulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "# Data Manipulation in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# No imports today\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Objectives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "- Write functions to transform data\n",
    "- Construct list and dictionary comprehensions\n",
    "- Extract data from nested data structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "This aspect of Python is _incredibly_ useful! Writing your own functions can save you a TON of work - by _automating_ it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Creating Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "The first line will read:\n",
    "\n",
    "```python\n",
    "\n",
    "'def' function_name() ':'\n",
    "\n",
    "```\n",
    "\n",
    "Any arguments to the function will go in the parentheses.\n",
    "\n",
    "Let's try building a function that will automate the task of finding how many times a given number can be evenly divided by 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "heading_collapsed": true
   },
   "outputs": [],
   "source": [
    "# Let's code it!\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Calling Functions\n",
    "\n",
    "To _call_ a function, simply type its name, along with any necessary arguments in parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "heading_collapsed": true
   },
   "outputs": [],
   "source": [
    "# Let's call it!\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Default Argument Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "Sometimes we'll want the argument(s) of our function to have default values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "heading_collapsed": true
   },
   "outputs": [],
   "source": [
    "def cheers(person='aaron', job='data scientist', age=30):\n",
    "    return f'Hooray for {person}. You\\'re a {job} and you\\'re {age}!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "heading_collapsed": true
   },
   "outputs": [],
   "source": [
    "cheers('greg', 'scientist', 130)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cheers(job='scientist', age=130, person='greg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "heading_collapsed": true
   },
   "outputs": [],
   "source": [
    "cheers('cristian', 'git enthusiast')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "heading_collapsed": true
   },
   "outputs": [],
   "source": [
    "cheers()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## List Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Make sure you're comfortable with the following list methods:\n",
    "\n",
    "- `.append()`: adds the input element to the end of a list\n",
    "- `.pop()`: removes and returns the element with input index from the list\n",
    "- `.extend()`: adds the elements in the input iterable to the end of a list\n",
    "- `.index()`: returns the first place in a list where the argument is found\n",
    "- `.remove()`: removes element by value\n",
    "- `.count()`: returns the number of occurrences of the input element in a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Question: What's the difference between `.remove()` and `del`?\n",
    "\n",
    "<details>\n",
    "    <summary>\n",
    "        Answer here\n",
    "    </summary>\n",
    "    .remove() removes an element by value;<br/>\n",
    "    del removes an element by position"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "List comprehension is a handy way of generating a new list from existing iterables.\n",
    "\n",
    "Suppose I start with a simple list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "primes = [2, 3, 5, 7, 11, 13, 17, 19]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "What I want now to do is to build a new list that comprises doubles of primes. I can do this with list comprehension!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "The syntax is: `[ f(x) for x in <iterable> if <condition>]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "prime_doubles = [x*2 for x in primes]\n",
    "prime_triples = [x*3 for x in primes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "prime_doubles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "##### Aside: List Comprehensions Vs. `for`-Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Yes, I could do the same work with `for`-loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "prime_doubles2 = []\n",
    "for prime in primes:\n",
    "    prime_doubles2.append(prime*2)\n",
    "prime_doubles2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prime_doubles == prime_doubles2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "But list comprehensions are more efficient: The syntax is simpler, and they're also faster. Also, you'll see them in other people's code, so you'll have to know how to work with them!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Another List Comprehension Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "I can use list comprehension to build a list from objects other than lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "names = ('Alan Turing', 'Charles Babbage', 'Ada Lovelace',\n",
    "        'Anita Borg', 'Steve Wozniak', 'Andrew Ng')\n",
    "\n",
    "splits = [name.split() for name in names]\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "[name1[0]+'. '+name2[0]+'.' for (name1, name2) in splits]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "1. Use a list comprehension to extract the odd numbers from this set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "nums = set(range(1000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "<details>\n",
    "    <summary>Answer\n",
    "    </summary>\n",
    "    <code>[num for num in nums if num % 2 == 1]</code>\n",
    "    </details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "2. Use a list comprehension to take the first character of each string from the following list of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "words = ['carbon', 'osmium', 'mercury', 'potassium', 'rhenium', 'einsteinium',\n",
    "        'hydrogen', 'erbium', 'nitrogen', 'sulfur', 'iodine', 'oxygen', 'niobium']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "<details>\n",
    "    <summary>Answer\n",
    "    </summary>\n",
    "    <code>[word[0] for word in words]</code>\n",
    "    </details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "3. Use a list comprehension to build a list of all the names that start with 'R' from the following list. Add a '?' to the end of each name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "names = ['Randy', 'Robert', 'Alex', 'Ranjit', 'Charlie', 'Richard', 'Ravdeep',\n",
    "        'Vimal', 'Wu', 'Nelson']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "<details>\n",
    "<summary>Answer\n",
    "    </summary>\n",
    "    <code>[name+'?' for name in names if name[0] == 'R']</code>\n",
    "    </details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Dictionary Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Make sure you're comfortable with the following dictionary methods:\n",
    "\n",
    "- `.keys()`: returns an array of the dictionary's keys\n",
    "- `.values()`: returns an array of the dictionary's values\n",
    "- `.items()`: returns an array of key-value tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Dictionary Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Much like list comprehension, I can use dictionary comprehension to build dictionaries from existing iterables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "my_dict = {'who': 'flatiron school', 'what': 'data science',\n",
    "           'when': 'now', 'where': 'here', 'why': '$',\n",
    "           'how': 'python'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Remember that the `.items()` method will return a collection of doubles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "my_dict.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "So I can use a pair of variables to range over it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "{k: v + '!' for k, v in my_dict.items() if k.startswith('w')}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "The same thing works for any collections of doubles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "{k**2: v**2 for k, v in [(0, 1), (2, 3), (4, 5)]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### `zip`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Remember that `zip` is a handy way of pairing up two or more iterables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "dict(zip(range(5), ['apple', 'orange', 'banana', 'lime', 'blueberry']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Zipping multiple iterables together\n",
    "tuple(zip(range(1, 5), 'a'*4, 'b'*4, 'c'*4, 'd'*4, 'e'*4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### Dictionary Comprehension Using `zip`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "{k: v for k, v in zip(range(5), range(0, 10, 2))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "scores = [.858, .873, .868]\n",
    "{'model' + str(j+1): scores[j] for j in range(3)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "1. Use a dictionary comprehension to pair up the countries in the first list with their corresponding capitals in the second list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "list1 = ['USA', 'France', 'Canada', 'Thailand']\n",
    "list2 = ['Washington', 'Paris', 'Ottawa', 'Bangkok']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "<details>\n",
    "<summary>Answer\n",
    "    </summary>\n",
    "    <code>{country: capital for (country, capital) in zip(list1, list2)}</code> <br/> OR <br/>\n",
    "    <code>dict(zip(list1, list2))</code>\n",
    "    </details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "2. Use a dictionary comprehension to make each of the characters in the following list a key with the value 'fictional character'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "chars = ['Pinocchio', 'Gilgamesh', 'Kumar Patel', 'Toby Flenderson']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "<details>\n",
    "    <summary>Answer</summary>\n",
    "    <code>{char: 'fictional character' for char in chars}</code>\n",
    "    </details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Nesting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Just as we can put lists and dictionaries inside of other lists and dictionaries, we can also put comprehensions inside of other comprehensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "lists = [['morning', 'afternoon', 'night'], ['read', 'code', 'sleep']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "[[item[0] for item in small_list] for small_list in lists]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Nested Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "It will be well worth your while to practice accessing data in complex structures. Consider the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "customers = {\n",
    "    'bill': {'purchases': {'movies': ['Terminator', 'Elf'],\n",
    "                     'books': []}, 'id': 1},\n",
    "            'dolph': {'purchases': {'movies': ['It Happened One Night'],\n",
    "                     'books': ['The Far Side Gallery']}, 'id': 2},\n",
    "            'pat': {'purchases': {'movies': [],\n",
    "                   'books': ['Seinfeld and Philosophy', 'I Am a Bunny']},\n",
    "                   'id': 3}\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**Q**: How would we access 'I Am a Bunny'?\n",
    "<br/>\n",
    "**A**: The outermost \"layer\" has a name: 'customers', and that object is a dictionary:\n",
    "<br/>\n",
    "`customers`\n",
    "<br/>\n",
    "The key we are interested in is 'pat', since that's where 'I Am a Bunny' is located:\n",
    "<br/>\n",
    "`customers['pat']`\n",
    "<br/>\n",
    "The value corresponding to the key 'pat' is also a dictionary, and in this \"lower-down\" dictionary, the key we are interested in is 'purchases':\n",
    "<br/>\n",
    "`customers['pat']['purchases']`\n",
    "<br/>\n",
    "The value corresponding to the key 'purchases' is yet another dictionary, and here the key of interest is `books`:\n",
    "<br/>\n",
    "`customers['pat']['purchases']['books']`\n",
    "<br/>\n",
    "The value corresponding to the key 'books' is a list, and 'I Am a Bunny' is the second element in that list:\n",
    "<br/>\n",
    "`customers['pat']['purchases']['books'][1]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "customers['pat']['purchases']['books'][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "1. From the list below, make a list of dictionaries where the key is the person's name and the value is the person's home phone number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "phone_nos = [{'name': 'greg', 'nums': {'home': 1234567, 'work': 7654321}},\n",
    "          {'name': 'max', 'nums': {'home': 9876543, 'work': 1010001}},\n",
    "            {'name': 'erin', 'nums': {'home': 3333333, 'work': 4444444}},\n",
    "            {'name': 'joél', 'nums': {'home': 2222222, 'work': 5555555}},\n",
    "            {'name': 'sean', 'nums': {'home': 9999999, 'work': 8888888}}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "<details>\n",
    "    <summary>Answer</summary>\n",
    "    <code>[{item['name']: item['nums']['home']} for item in phone_nos]</code>\n",
    "    </details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "2. From the customers dictionary above, build a dictionary where the customers' names are the keys and the movies they've bought are the values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "<details>\n",
    "    <summary>Answer</summary>\n",
    "    <code>{customer: customers[customer]['purchases']['movies'] for customer in customers.keys()}</code> <br/>\n",
    "    OR <br/>\n",
    "    <code>{k: v['purchases']['movies'] for k, v in customers.items()}</code>\n",
    "    </details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "# More Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "1. Build a function that will return $2^n$ for an input $n$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "<details>\n",
    "    <summary>Answer</summary>\n",
    "    <code>\n",
    "def expo(n):\n",
    "    return 2**n</code>\n",
    "    </details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "2. Build a function that will take in a list of phone numbers as strings and return the same as integers, removing any parentheses ('(' and ')'), hyphens ('-'), and spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "<details>\n",
    "    <summary>Answer</summary>\n",
    "    <code>\n",
    "def int_phone(string_list):\n",
    "    return [int(string.replace('(', '').replace(')', '').replace('-', '').replace(' ', ''))\\\n",
    "    for string in string_list]</code>\n",
    "    </details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "3. Build a function that returns the mode of a list of numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "<details>\n",
    "    <summary>Answer</summary>\n",
    "        <code>\n",
    "def mode(lst):\n",
    "    counts = {num: lst.count(num) for num in lst}\n",
    "    return [num for num in counts.keys() if counts[num] == max(counts.values())]</code>\n",
    "    </details>"
   ]
  }
 ],
 "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.2"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "384px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}