101-exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Welcome to 101 Exercises for Python Fundamentals\n",
    "\n",
    "Solving these exercises will help make you a better programmer. Solve them in order, because each solution builds scaffolding, working code, and knowledge you can use on future problems. Read the directions carefully, and have fun!\n",
    "\n",
    "> \"Learning to program takes a little bit of study and a *lot* of practice\" - Luis Montealegre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting Started\n",
    "1. Go to https://colab.research.google.com/github/ryanorsinger/101-exercises/blob/main/101-exercises.ipynb\n",
    "2. To save your work to your Google Drive, go to File then \"Save Copy in Drive\".\n",
    "3. Your own work will now appear in your Google Drive account!\n",
    "\n",
    "If you need a fresh, blank copy of this document, go to https://colab.research.google.com/github/ryanorsinger/101-exercises/blob/main/101-exercises.ipynb and save a fresh copy in your Google Drive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Orientation\n",
    "- This code notebook is composed of cells. Each cell is either text or Python code.\n",
    "- To run a cell of code, click the \"play button\" icon to the left of the cell or click on the cell and press \"Shift+Enter\" on your keyboard. This will execute the Python code contained in the cell. Executing a cell that defines a variable is important before executing or authoring a cell that depends on that previously created variable assignment.\n",
    "- Each *assert* line is both an example and a test that tests for the presence and functionality of the instructed exercise. \n",
    "\n",
    "\n",
    "## Outline\n",
    "- Each cell starts with a problem statement that describes the exercise to complete.\n",
    "- Underneath each problem statement, learners will need to write code to produce an answer.\n",
    "- The **assert** lines test to see that your code solves the problem appropriately.\n",
    "- Do not alter or delete the assertion tests, since those are providing automated testing.\n",
    "- Many exercises will rely on previous solutions to be correctly completed\n",
    "- The `print(\"Exercise is complete\")` line will only run if your solution passes the assertion test(s)\n",
    "- Be sure to create programmatic solutions that will work for all inputs:\n",
    "- For example, calling the `is_even(2)` returns `True`, but your function should work for all even numbers, both positive and negative.\n",
    "\n",
    "\n",
    "## Guidance\n",
    "- Get Python to do the work for you. For example, if the exercise instructs you to reverse a list of numbers, your job is to find the \n",
    "- Save often by clicking the blue \"Save\" button.\n",
    "- If you need to clear the output or reset the notebook, go to \"Run\" then \"Restart Session\" to clear up any error messages.\n",
    "- Do not move or alter the lines of code that contain the `assert` statements. Those are what run your solution and test its actual output vs. expected outputs.\n",
    "- Seek to understand the problem before trying to solve it. Can you explain the problem to someone else in English? Can you explain the solution in English?\n",
    "- Slow down and read any error messages you encounter. Error messages provide insight into how to resolve the error. When in doubt, put your exact error into a search engine and look for results that reference an identical or similar problem.\n",
    "\n",
    "## Get Python To Do The Work For You\n",
    "One of the main jobs of a programming language is to help people solve problems programatically, so we don't have to do so much by hand. For example, it's easy for a person to manually reverse the list `[1, 2, 3]`, but imagine reversing a list of a million things or sorting a list of even a hundred things. When we write programmatic solutions in code, we are providing instructions to the computer to do a task. Computers follow the letter of the code, not the intent, and do exactly what they are told to do. In this way, Python can reverse a list of 3 numbers or 100 numbers or ten million numbers with the same instructions. Repetition is a key idea behind programming languages.\n",
    "\n",
    "This means that your task with these exercises is to determine a sequence of steps that solve the problem and then find the Python code that will run those instructions. If you're sorting or reversing things by hand, you're not doing it right!\n",
    "\n",
    "## How To Discover How To Do Something in Python\n",
    "1. The first step is to make sure you know what the problem is asking.\n",
    "2. The second step is to determine, in English (or your first spoken language), what steps you need to take.\n",
    "3. Use a search engine to look for code examples to identical or similar problems.\n",
    "\n",
    "One of the best ways to discover how to do things in Python is to use a search engine. Go to your favorite search engine and search for \"how to reverse a list in Python\" or \"how to sort a list in Python\". That's how both learners and professionals find answers and examples all the time. Search for what you want and add \"in Python\" and you'll get lots of code examples. Searching for \"How to sum a list of numbers in Python\" is a very effective way to discover exactly how to do that task."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning to Program and Code\n",
    "- You can make a new blank cell for Python code at any time in this document.\n",
    "- If you want more freedom to explore learning Python in a blank notebook, go here https://colab.research.google.com/#create=true and make yourself a blank, new notebook.\n",
    "- Programming is an intellectual activity of designing a solution. \"Coding\" means turning your programmatic solution into code w/ all the right syntax and parts of the programming language.\n",
    "- Expect to make mistakes and adopt the attitude that **the error message provides the information you need to proceed**. You will put lots of error messages into search engines to learn this craft!\n",
    "- Because computers have zero ability to read in between the lines or \"catch the drift\" or know what you mean, code only does what it is told to do.\n",
    "- Code doesn't do what you *want* it to do, code does what you've told it to do.\n",
    "- Before writing any code, figure out how you would solve the problem in spoken language to describe the sequence of steps in the solution.\n",
    "- Think about your solution in English (or your natural language). It's **critical** to solve the problem in your natural language before trying to get a programming language to do the work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Troubleshooting\n",
    "- If this entire document shows \"Name Error\" for many cells, it means you should read the \"Getting Started\" instructions above to make your own copy.\n",
    "- Be sure to commit your work to make save points, as you go.\n",
    "- If you load this page and you see your code but not the results of the code, be sure to run each cell (shift + Enter makes this quick)\n",
    "- \"Name Error\" means that you need to assign a variable or define the function as instructed.\n",
    "- \"Assertion Error\" means that your provided solution does not match the correct answer.\n",
    "- \"Type Error\" means that your data type provided is not accurate\n",
    "- If your kernel freezes, click on \"Run\" then select \"Restart Session\"\n",
    "- If you require additional troubleshooting assistance, click on \"Help\" and then \"Docs\" to access documentation for this platform.\n",
    "- If you have discoverd a bug or typo, please triple check your spelling then create a new issue at [https://github.com/ryanorsinger/101-exercises/issues](https://github.com/ryanorsinger/101-exercises/issues) to notify the author.\n",
    "\n",
    "## What to do when you don't know what to do next\n",
    "- When the exercise asks you to reverse an list, the way forward is to search for \"How to reverse a list in Python\" in your favorite search engine.\n",
    "- When the exercise asks you to check if a number is even, the way forward is to search for \"how to check if a number is even in Python\".\n",
    "- When the exercise has you calculate the area of a circle, the way forward is to search for \"how to calculate the area of a circle in Python\" or \"How to get pi in Python\".\n",
    "\n",
    "> The pattern for finding what you need in JavaScript is to rely very heavily on search engine searches so you can find examples of working code and discussions about code that speak to your questions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a"
   },
   "outputs": [],
   "source": [
    "# Example problem:\n",
    "# Uncomment the line below and run this cell.\n",
    "# The hashtag \"#\" character in a line of Python code is the comment character. \n",
    "# doing_python_right_now = True\n",
    "\n",
    "# The lines below will test your answer. If you see an error, then it means that your answer is incorrect or incomplete.\n",
    "assert doing_python_right_now == True, \"If you see a NameError, it means that the variable is not created and assigned a value. An 'Assertion Error' means that the value of the variable is incorrect.\" \n",
    "print(\"Exercise 0 is correct\") # This line will print if your solution passes the assertion above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 1\n",
    "# On the line below, create a variable named on_mars_right_now and assign it the boolean value of False\n",
    "\n",
    "assert on_mars_right_now == False, \"If you see a Name Error, be sure to create the variable and assign it a value.\"\n",
    "print(\"Exercise 1 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 2\n",
    "# Create a variable named fruits and assign it a list of fruits containing the following fruit names as strings: \n",
    "# mango, banana, guava, kiwi, and strawberry.\n",
    "\n",
    "assert fruits == [\"mango\", \"banana\", \"guava\", \"kiwi\", \"strawberry\"], \"If you see an Assert Error, ensure the variable contains all the strings in the provided order\"\n",
    "print(\"Exercise 2 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 3\n",
    "# Create a variable named vegetables and assign it a list of fruits containing the following vegetable names as strings: \n",
    "# eggplant, broccoli, carrot, cauliflower, and zucchini\n",
    "\n",
    "assert vegetables == [\"eggplant\", \"broccoli\", \"carrot\", \"cauliflower\", \"zucchini\"], \"Ensure the variable contains all the strings in the provided order\"\n",
    "print(\"Exercise 3 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 4\n",
    "# Create a variable named numbers and assign it a list of numbers, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10\n",
    "\n",
    "assert numbers == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], \"Ensure the variable contains the numbers 1-10 in order.\"\n",
    "print(\"Exercise 4 is correct.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Operations\n",
    "**Hint** Recommend finding and using built-in Python functionality whenever possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 5\n",
    "# Given the following assigment of the list of fruits, add \"tomato\" to the end of the list. \n",
    "fruits = [\"mango\", \"banana\", \"guava\", \"kiwi\", \"strawberry\"]\n",
    "\n",
    "assert fruits == [\"mango\", \"banana\", \"guava\", \"kiwi\", \"strawberry\", \"tomato\"], \"Ensure the variable contains all the strings in the right order\"\n",
    "print(\"Exercise 5 is correct\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 6\n",
    "# Given the following assignment of the vegetables list, add \"tomato\" to the end of the list.\n",
    "vegetables = [\"eggplant\", \"broccoli\", \"carrot\", \"cauliflower\", \"zucchini\"]\n",
    "\n",
    "\n",
    "assert vegetables == [\"eggplant\", \"broccoli\", \"carrot\", \"cauliflower\", \"zucchini\", \"tomato\"], \"Ensure the variable contains all the strings in the provided order\"\n",
    "print(\"Exercise 6 is correct\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 7\n",
    "# Given the list of numbers defined below, reverse the list of numbers that you created above. \n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "\n",
    "assert numbers == [10, 9, 8, 7, 6, 5, 4, 3, 2, 1], \"Assert Error means that the answer is incorrect.\" \n",
    "print(\"Exercise 7 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 8\n",
    "# Sort the vegetables in alphabetical order\n",
    "\n",
    "assert vegetables == ['broccoli', 'carrot', 'cauliflower', 'eggplant', 'tomato', 'zucchini']\n",
    "print(\"Exercise 8 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 9\n",
    "# Write the code necessary to sort the fruits in reverse alphabetical order\n",
    "\n",
    "assert fruits == ['tomato', 'strawberry', 'mango', 'kiwi', 'guava', 'banana']\n",
    "print(\"Exercise 9 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 10\n",
    "# Write the code necessary to produce a single list that holds all fruits then all vegetables in the order as they were sorted above.\n",
    "\n",
    "assert fruits_and_veggies == ['tomato', 'strawberry', 'mango', 'kiwi', 'guava', 'banana', 'broccoli', 'carrot', 'cauliflower', 'eggplant', 'tomato', 'zucchini']\n",
    "print(\"Exercise 10 is correct\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Functions\n",
    "![](http://)**Hint** Be sure to `return` values from your function definitions. The assert statements will call your function(s) for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell in order to generate some numbers to use in our functions after this.\n",
    "import random\n",
    "    \n",
    "positive_even_number = random.randrange(2, 101, 2)\n",
    "negative_even_number = random.randrange(-100, -1, 2)\n",
    "\n",
    "positive_odd_number = random.randrange(1, 100, 2)\n",
    "negative_odd_number = random.randrange(-101, 0, 2)\n",
    "print(\"We now have some random numbers available for future exercises.\")\n",
    "print(\"The random positive even number is\", positive_even_number)\n",
    "print(\"The random positive odd nubmer is\", positive_odd_number)\n",
    "print(\"The random negative even number\", negative_even_number)\n",
    "print(\"The random negative odd number\", negative_odd_number)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example function defintion:\n",
    "# Write a say_hello function that adds the string \"Hello, \" to the beginning and \"!\" to the end of any given input.\n",
    "def say_hello(name):\n",
    "    return \"Hello, \" + name + \"!\"\n",
    "\n",
    "assert say_hello(\"Jane\") == \"Hello, Jane!\", \"Double check the inputs and data types\"\n",
    "assert say_hello(\"Pat\") == \"Hello, Pat!\", \"Double check the inputs and data types\"\n",
    "assert say_hello(\"Astrud\") == \"Hello, Astrud!\", \"Double check the inputs and data types\"\n",
    "print(\"The example function definition ran appropriately\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another example function definition:\n",
    "# This plus_two function takes in a variable and adds 2 to it.\n",
    "def plus_two(number):\n",
    "    return number + 2\n",
    "\n",
    "assert plus_two(3) == 5\n",
    "assert plus_two(0) == 2\n",
    "assert plus_two(-2) == 0\n",
    "print(\"The plus_two assertions executed appropriately... The second function definition example executed appropriately.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 11\n",
    "# Write a function definition for a function named add_one that takes in a number and returns that number plus one.\n",
    "\n",
    "    \n",
    "assert add_one(2) == 3, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert add_one(0) == 1, \"Zero plus one is one.\"\n",
    "assert add_one(positive_even_number) == positive_even_number + 1, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert add_one(negative_odd_number) == negative_odd_number + 1, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "print(\"Exercise 11 is correct.\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 12\n",
    "# Write a function definition named is_positive that takes in a number and returns True or False if that number is positive.\n",
    "\n",
    "assert is_positive(positive_odd_number) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_positive(positive_even_number) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_positive(negative_odd_number) == False, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_positive(negative_even_number) == False, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_positive(0) == False, \"Zero is not a positive number.\"\n",
    "print(\"Exercise 12 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 13\n",
    "# Write a function definition named is_negative that takes in a number and returns True or False if that number is negative.\n",
    "\n",
    "assert is_negative(positive_odd_number) == False, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_negative(positive_even_number) == False, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_negative(negative_odd_number) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_negative(negative_even_number) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_negative(0) == False, \"Zero is not a negative number.\"\n",
    "print(\"Exercise 13 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 14\n",
    "# Write a function definition named is_odd that takes in a number and returns True or False if that number is odd.\n",
    "\n",
    "assert is_odd(positive_odd_number) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_odd(positive_even_number) == False, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_odd(negative_odd_number) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_odd(negative_even_number) == False, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "print(\"Exercise 14 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 15\n",
    "# Write a function definition named is_even that takes in a number and returns True or False if that number is even.\n",
    "\n",
    "assert is_even(2) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_even(positive_odd_number) == False, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_even(positive_even_number) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_even(negative_odd_number) == False, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert is_even(negative_even_number) == True, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "print(\"Exercise 15 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 16\n",
    "# Write a function definition named identity that takes in any argument and returns that argument's value. Don't overthink this one!\n",
    "\n",
    "assert identity(fruits) == fruits, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert identity(vegetables) == vegetables, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert identity(positive_odd_number) == positive_odd_number, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert identity(positive_even_number) == positive_even_number, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert identity(negative_odd_number) == negative_odd_number, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "assert identity(negative_even_number) == negative_even_number, \"Ensure that the function is defined, named properly, and returns the correct value\"\n",
    "print(\"Exercise 16 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 17\n",
    "# Write a function definition named is_positive_odd that takes in a number and returns True or False if the value is both greater than zero and odd\n",
    "\n",
    "assert is_positive_odd(3) == True, \"Double check your syntax and logic\" \n",
    "assert is_positive_odd(positive_odd_number) == True, \"Double check your syntax and logic\"\n",
    "assert is_positive_odd(positive_even_number) == False, \"Double check your syntax and logic\"\n",
    "assert is_positive_odd(negative_odd_number) == False, \"Double check your syntax and logic\"\n",
    "assert is_positive_odd(negative_even_number) == False, \"Double check your syntax and logic\"\n",
    "print(\"Exercise 17 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 18\n",
    "# Write a function definition named is_positive_even that takes in a number and returns True or False if the value is both greater than zero and even\n",
    "\n",
    "assert is_positive_even(4) == True, \"Double check your syntax and logic\" \n",
    "assert is_positive_even(positive_odd_number) == False, \"Double check your syntax and logic\"\n",
    "assert is_positive_even(positive_even_number) == True, \"Double check your syntax and logic\"\n",
    "assert is_positive_even(negative_odd_number) == False, \"Double check your syntax and logic\"\n",
    "assert is_positive_even(negative_even_number) == False, \"Double check your syntax and logic\"\n",
    "print(\"Exercise 18 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 19\n",
    "# Write a function definition named is_negative_odd that takes in a number and returns True or False if the value is both less than zero and odd.\n",
    "\n",
    "assert is_negative_odd(-3) == True, \"Double check your syntax and logic\" \n",
    "assert is_negative_odd(positive_odd_number) == False, \"Double check your syntax and logic\"\n",
    "assert is_negative_odd(positive_even_number) == False, \"Double check your syntax and logic\"\n",
    "assert is_negative_odd(negative_odd_number) == True, \"Double check your syntax and logic\"\n",
    "assert is_negative_odd(negative_even_number) == False, \"Double check your syntax and logic\"\n",
    "print(\"Exercise 19 is correct.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 20\n",
    "# Write a function definition named is_negative_even that takes in a number and returns True or False if the value is both less than zero and even.\n",
    "\n",
    "assert is_negative_even(-4) == True, \"Double check your syntax and logic\" \n",
    "assert is_negative_even(positive_odd_number) == False, \"Double check your syntax and logic\"\n",
    "assert is_negative_even(positive_even_number) == False, \"Double check your syntax and logic\"\n",
    "assert is_negative_even(negative_odd_number) == False, \"Double check your syntax and logic\"\n",
    "assert is_negative_even(negative_even_number) == True, \"Double check your syntax and logic\"\n",
    "print(\"Exercise 20 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 21\n",
    "# Write a function definition named half that takes in a number and returns half the provided number.\n",
    "\n",
    "assert half(4) == 2\n",
    "assert half(5) == 2.5\n",
    "assert half(positive_odd_number) == positive_odd_number / 2\n",
    "assert half(positive_even_number) == positive_even_number / 2\n",
    "assert half(negative_odd_number) == negative_odd_number / 2\n",
    "assert half(negative_even_number) == negative_even_number / 2\n",
    "print(\"Exercise 21 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 22\n",
    "# Write a function definition named double that takes in a number and returns double the provided number.\n",
    "\n",
    "assert double(4) == 8\n",
    "assert double(5) == 10\n",
    "assert double(positive_odd_number) == positive_odd_number * 2\n",
    "assert double(positive_even_number) == positive_even_number * 2\n",
    "assert double(negative_odd_number) == negative_odd_number * 2\n",
    "assert double(negative_even_number) == negative_even_number * 2\n",
    "print(\"Exercise 22 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 23\n",
    "# Write a function definition named triple that takes in a number and returns triple the provided number.\n",
    "\n",
    "assert triple(4) == 12\n",
    "assert triple(5) == 15\n",
    "assert triple(positive_odd_number) == positive_odd_number * 3\n",
    "assert triple(positive_even_number) == positive_even_number * 3\n",
    "assert triple(negative_odd_number) == negative_odd_number * 3\n",
    "assert triple(negative_even_number) == negative_even_number * 3\n",
    "print(\"Exercise 23 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 24\n",
    "# Write a function definition named reverse_sign that takes in a number and returns the provided number but with the sign reversed.\n",
    "\n",
    "assert reverse_sign(4) == -4\n",
    "assert reverse_sign(-5) == 5\n",
    "assert reverse_sign(positive_odd_number) == positive_odd_number * -1\n",
    "assert reverse_sign(positive_even_number) == positive_even_number * -1\n",
    "assert reverse_sign(negative_odd_number) == negative_odd_number * -1\n",
    "assert reverse_sign(negative_even_number) == negative_even_number * -1\n",
    "print(\"Exercise 24 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 25\n",
    "# Write a function definition named absolute_value that takes in a number and returns the absolute value of the provided number\n",
    "\n",
    "assert absolute_value(4) == 4\n",
    "assert absolute_value(-5) == 5\n",
    "assert absolute_value(positive_odd_number) == positive_odd_number\n",
    "assert absolute_value(positive_even_number) == positive_even_number\n",
    "assert absolute_value(negative_odd_number) == negative_odd_number * -1\n",
    "assert absolute_value(negative_even_number) == negative_even_number * -1\n",
    "print(\"Exercise 25 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 26\n",
    "# Write a function definition named is_multiple_of_three that takes in a number and returns True or False if the number is evenly divisible by 3.\n",
    "\n",
    "assert is_multiple_of_three(3) == True\n",
    "assert is_multiple_of_three(15) == True\n",
    "assert is_multiple_of_three(9) == True\n",
    "assert is_multiple_of_three(4) == False\n",
    "assert is_multiple_of_three(10) == False\n",
    "print(\"Exercise 26 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 27\n",
    "# Write a function definition named is_multiple_of_five that takes in a number and returns True or False if the number is evenly divisible by 5.\n",
    "\n",
    "assert is_multiple_of_five(3) == False\n",
    "assert is_multiple_of_five(15) == True\n",
    "assert is_multiple_of_five(9) == False\n",
    "assert is_multiple_of_five(4) == False\n",
    "assert is_multiple_of_five(10) == True\n",
    "print(\"Exercise 27 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 28\n",
    "# Write a function definition named is_multiple_of_both_three_and_five that takes in a number and returns True or False if the number is evenly divisible by both 3 and 5.\n",
    "\n",
    "assert is_multiple_of_both_three_and_five(15) == True\n",
    "assert is_multiple_of_both_three_and_five(45) == True\n",
    "assert is_multiple_of_both_three_and_five(3) == False\n",
    "assert is_multiple_of_both_three_and_five(9) == False\n",
    "assert is_multiple_of_both_three_and_five(4) == False\n",
    "print(\"Exercise 28 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 29\n",
    "# Write a function definition named square that takes in a number and returns the number times itself.\n",
    "\n",
    "assert square(3) == 9\n",
    "assert square(2) == 4\n",
    "assert square(9) == 81\n",
    "assert square(positive_odd_number) == positive_odd_number * positive_odd_number\n",
    "print(\"Exercise 29 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 30\n",
    "# Write a function definition named add that takes in two numbers and returns the sum.\n",
    "\n",
    "assert add(3, 2) == 5\n",
    "assert add(10, -2) == 8\n",
    "assert add(5, 7) == 12\n",
    "print(\"Exercise 30 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 31\n",
    "# Write a function definition named cube that takes in a number and returns the number times itself, times itself.\n",
    "\n",
    "assert cube(3) == 27\n",
    "assert cube(2) == 8\n",
    "assert cube(5) == 125\n",
    "assert cube(positive_odd_number) == positive_odd_number * positive_odd_number * positive_odd_number\n",
    "print(\"Exercise 31 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 32\n",
    "# Write a function definition named square_root that takes in a number and returns the square root of the provided number\n",
    "\n",
    "assert square_root(4) == 2.0\n",
    "assert square_root(64) == 8.0\n",
    "assert square_root(81) == 9.0\n",
    "print(\"Exercise 32 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 33\n",
    "# Write a function definition named subtract that takes in two numbers and returns the first minus the second argument.\n",
    "\n",
    "assert subtract(8, 6) == 2\n",
    "assert subtract(27, 4) == 23\n",
    "assert subtract(12, 2) == 10\n",
    "print(\"Exercise 33 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 34\n",
    "# Write a function definition named multiply that takes in two numbers and returns the first times the second argument.\n",
    "\n",
    "assert multiply(2, 1) == 2\n",
    "assert multiply(3, 5) == 15\n",
    "assert multiply(5, 2) == 10\n",
    "print(\"Exercise 34 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 35\n",
    "# Write a function definition named divide that takes in two numbers and returns the first argument divided by the second argument.\n",
    "\n",
    "assert divide(27, 9) == 3\n",
    "assert divide(15, 3) == 5\n",
    "assert divide(5, 2) == 2.5\n",
    "assert divide(10, 2) == 5\n",
    "print(\"Exercise 35 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 36\n",
    "# Write a function definition named quotient that takes in two numbers and returns only the quotient from dividing the first argument by the second argument.\n",
    "\n",
    "assert quotient(27, 9) == 3\n",
    "assert quotient(5, 2) == 2\n",
    "assert quotient(10, 3) == 3\n",
    "print(\"Exercise 36 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 37\n",
    "# Write a function definition named remainder that takes in two numbers and returns the remainder of first argument divided by the second argument.\n",
    "\n",
    "assert remainder(3, 3) == 0\n",
    "assert remainder(5, 2) == 1\n",
    "assert remainder(7, 5) == 2\n",
    "print(\"Exercise 37 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 38\n",
    "# Write a function definition named sum_of_squares that takes in two numbers, squares each number, then returns the sum of both squares.\n",
    "\n",
    "assert sum_of_squares(3, 2) == 13\n",
    "assert sum_of_squares(5, 2) == 29\n",
    "assert sum_of_squares(2, 4) == 20\n",
    "print(\"Exercise 38 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 39\n",
    "# Write a function definition named times_two_plus_three that takes in a number, multiplies it by two, adds 3 and returns the result.\n",
    "\n",
    "assert times_two_plus_three(0) == 3\n",
    "assert times_two_plus_three(1) == 5\n",
    "assert times_two_plus_three(2) == 7\n",
    "assert times_two_plus_three(3) == 9\n",
    "assert times_two_plus_three(5) == 13\n",
    "print(\"Exercise 39 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 40\n",
    "# Write a function definition named area_of_rectangle that takes in two numbers and returns the product.\n",
    "\n",
    "assert area_of_rectangle(1, 3) == 3\n",
    "assert area_of_rectangle(5, 2) == 10\n",
    "assert area_of_rectangle(2, 7) == 14\n",
    "assert area_of_rectangle(5.3, 10.3) == 54.59\n",
    "print(\"Exercise 40 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "# Exercise 41\n",
    "# Write a function definition named area_of_circle that takes in a number representing a circle's radius and returns the area of the circl\n",
    "\n",
    "assert area_of_circle(3) == 28.274333882308138\n",
    "assert area_of_circle(5) == 78.53981633974483\n",
    "assert area_of_circle(7) == 153.93804002589985\n",
    "print(\"Exercise 41 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "# Exercise 42\n",
    "# Write a function definition named circumference that takes in a number representing a circle's radius and returns the circumference.\n",
    "\n",
    "assert circumference(3) == 18.84955592153876\n",
    "assert circumference(5) == 31.41592653589793\n",
    "assert circumference(7) == 43.982297150257104\n",
    "print(\"Exercise 42 is correct.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions working with strings\n",
    "If you need some guidance working with the next few problems, recommend reading through [this example code](https://gist.github.com/ryanorsinger/f758599c886549e7615ec43488ae514c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 43\n",
    "# Write a function definition named is_vowel that takes in value and returns True if the value is a, e, i, o, u in upper or lower case.\n",
    "\n",
    "\n",
    "assert is_vowel(\"a\") == True\n",
    "assert is_vowel(\"e\") == True\n",
    "assert is_vowel(\"i\") == True\n",
    "assert is_vowel(\"o\") == True\n",
    "assert is_vowel(\"u\") == True\n",
    "assert is_vowel(\"A\") == True\n",
    "assert is_vowel(\"E\") == True\n",
    "assert is_vowel(\"I\") == True\n",
    "assert is_vowel(\"O\") == True\n",
    "assert is_vowel(\"U\") == True\n",
    "assert is_vowel(\"banana\") == False\n",
    "assert is_vowel(\"Q\") == False\n",
    "assert is_vowel(\"y\") == False\n",
    "assert is_vowel(\"aei\") == False\n",
    "assert is_vowel(\"iou\") == False\n",
    "print(\"Exercise 43 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 44\n",
    "# Write a function definition named has_vowels that takes in value and returns True if the string contains any vowels.\n",
    "\n",
    "assert has_vowels(\"banana\") == True\n",
    "assert has_vowels(\"ubuntu\") == True\n",
    "assert has_vowels(\"QQQQ\") == False\n",
    "assert has_vowels(\"wyrd\") == False\n",
    "print(\"Exercise 44 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 45\n",
    "# Write a function definition named count_vowels that takes in value and returns the count of the nubmer of vowels in a sequence.\n",
    "\n",
    "assert count_vowels(\"banana\") == 3\n",
    "assert count_vowels(\"ubuntu\") == 3\n",
    "assert count_vowels(\"mango\") == 2\n",
    "assert count_vowels(\"QQQQ\") == 0\n",
    "assert count_vowels(\"wyrd\") == 0\n",
    "print(\"Exercise 45 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 46\n",
    "# Write a function definition named remove_vowels that takes in string and returns the string without any vowels\n",
    "\n",
    "assert remove_vowels(\"banana\") == \"bnn\"\n",
    "assert remove_vowels(\"ubuntu\") == \"bnt\"\n",
    "assert remove_vowels(\"mango\") == \"mng\"\n",
    "assert remove_vowels(\"QQQQ\") == \"QQQQ\"\n",
    "print(\"Exercise 46 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 47\n",
    "# Write a function definition named starts_with_vowel that takes in string and True if the string starts with a vowel\n",
    "\n",
    "assert starts_with_vowel(\"ubuntu\") == True\n",
    "assert starts_with_vowel(\"banana\") == False\n",
    "assert starts_with_vowel(\"mango\") == False\n",
    "print(\"Exercise 47 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 48\n",
    "# Write a function definition named ends_with_vowel that takes in string and True if the string ends with a vowel\n",
    "\n",
    "assert ends_with_vowel(\"ubuntu\") == True\n",
    "assert ends_with_vowel(\"banana\") == True\n",
    "assert ends_with_vowel(\"mango\") == True\n",
    "assert ends_with_vowel(\"spinach\") == False\n",
    "print(\"Exercise 48 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 49\n",
    "# Write a function definition named starts_and_ends_with_vowel that takes in string and returns True if the string starts and ends with a vowel\n",
    "\n",
    "assert starts_and_ends_with_vowel(\"ubuntu\") == True\n",
    "assert starts_and_ends_with_vowel(\"banana\") == False\n",
    "assert starts_and_ends_with_vowel(\"mango\") == False\n",
    "print(\"Exercise 49 is correct.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing List Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 50\n",
    "# Write a function definition named first that takes in sequence and returns the first value of that sequence.\n",
    "\n",
    "assert first(\"ubuntu\") == \"u\"\n",
    "assert first([1, 2, 3]) == 1\n",
    "assert first([\"python\", \"is\", \"awesome\"]) == \"python\"\n",
    "print(\"Exercise 50 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 51\n",
    "# Write a function definition named second that takes in sequence and returns the second value of that sequence.\n",
    "\n",
    "assert second(\"ubuntu\") == \"b\"\n",
    "assert second([1, 2, 3]) == 2\n",
    "assert second([\"python\", \"is\", \"awesome\"]) == \"is\"\n",
    "print(\"Exercise 51 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 52\n",
    "# Write a function definition named third that takes in sequence and returns the third value of that sequence.\n",
    "\n",
    "assert third(\"ubuntu\") == \"u\"\n",
    "assert third([1, 2, 3]) == 3\n",
    "assert third([\"python\", \"is\", \"awesome\"]) == \"awesome\"\n",
    "print(\"Exercise 52 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 53\n",
    "# Write a function definition named forth that takes in sequence and returns the forth value of that sequence.\n",
    "\n",
    "assert forth(\"ubuntu\") == \"n\"\n",
    "assert forth([1, 2, 3, 4]) == 4\n",
    "assert forth([\"python\", \"is\", \"awesome\", \"right?\"]) == \"right?\"\n",
    "print(\"Exercise 53 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 54\n",
    "# Write a function definition named last that takes in sequence and returns the last value of that sequence.\n",
    "\n",
    "assert last(\"ubuntu\") == \"u\"\n",
    "assert last([1, 2, 3, 4]) == 4\n",
    "assert last([\"python\", \"is\", \"awesome\"]) == \"awesome\"\n",
    "assert last([\"kiwi\", \"mango\", \"guava\"]) == \"guava\"\n",
    "print(\"Exercise 54 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 55\n",
    "# Write a function definition named second_to_last that takes in sequence and returns the second to last value of that sequence.\n",
    "\n",
    "assert second_to_last(\"ubuntu\") == \"t\"\n",
    "assert second_to_last([1, 2, 3, 4]) == 3\n",
    "assert second_to_last([\"python\", \"is\", \"awesome\"]) == \"is\"\n",
    "assert second_to_last([\"kiwi\", \"mango\", \"guava\"]) == \"mango\"\n",
    "print(\"Exercise 55 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 56\n",
    "# Write a function definition named third_to_last that takes in sequence and returns the third to last value of that sequence.\n",
    "\n",
    "assert third_to_last(\"ubuntu\") == \"n\"\n",
    "assert third_to_last([1, 2, 3, 4]) == 2\n",
    "assert third_to_last([\"python\", \"is\", \"awesome\"]) == \"python\"\n",
    "assert third_to_last([\"strawberry\", \"kiwi\", \"mango\", \"guava\"]) == \"kiwi\"\n",
    "print(\"Exercise 56 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 57\n",
    "# Write a function definition named first_and_second that takes in sequence and returns the first and second value of that sequence as a list\n",
    "\n",
    "assert first_and_second([1, 2, 3, 4]) == [1, 2]\n",
    "assert first_and_second([\"python\", \"is\", \"awesome\"]) == [\"python\", \"is\"]\n",
    "assert first_and_second([\"strawberry\", \"kiwi\", \"mango\", \"guava\"]) == [\"strawberry\", \"kiwi\"]\n",
    "print(\"Exercise 57 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 58\n",
    "# Write a function definition named first_and_last that takes in sequence and returns the first and last value of that sequence as a list\n",
    "\n",
    "assert first_and_last([1, 2, 3, 4]) == [1, 4]\n",
    "assert first_and_last([\"python\", \"is\", \"awesome\"]) == [\"python\", \"awesome\"]\n",
    "assert first_and_last([\"strawberry\", \"kiwi\", \"mango\", \"guava\"]) == [\"strawberry\", \"guava\"]\n",
    "print(\"Exercise 58 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 59\n",
    "# Write a function definition named first_to_last that takes in sequence and returns the sequence with the first value moved to the end of the sequence.\n",
    "\n",
    "assert first_to_last([1, 2, 3, 4]) == [2, 3, 4, 1]\n",
    "assert first_to_last([\"python\", \"is\", \"awesome\"]) == [\"is\", \"awesome\", \"python\"]\n",
    "assert first_to_last([\"strawberry\", \"kiwi\", \"mango\", \"guava\"]) == [\"kiwi\", \"mango\", \"guava\", \"strawberry\"]\n",
    "print(\"Exercise 59 is correct.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions to describe data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 60\n",
    "# Write a function definition named sum_all that takes in sequence of numbers and returns all the numbers added together.\n",
    "\n",
    "assert sum_all([1, 2, 3, 4]) == 10\n",
    "assert sum_all([3, 3, 3]) == 9\n",
    "assert sum_all([0, 5, 6]) == 11\n",
    "print(\"Exercise 60 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 61\n",
    "# Write a function definition named mean that takes in sequence of numbers and returns the average value\n",
    "\n",
    "assert mean([1, 2, 3, 4]) == 2.5\n",
    "assert mean([3, 3, 3]) == 3\n",
    "assert mean([1, 5, 6]) == 4\n",
    "print(\"Exercise 61 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 62\n",
    "# Write a function definition named median that takes in sequence of numbers and returns the average value\n",
    "\n",
    "assert median([1, 2, 3, 4, 5]) == 3.0\n",
    "assert median([1, 2, 3]) == 2.0\n",
    "assert median([1, 5, 6]) == 5.0\n",
    "assert median([1, 2, 5, 6]) == 3.5\n",
    "print(\"Exercise 62 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 63\n",
    "# Write a function definition named mode that takes in sequence of numbers and returns the most commonly occuring value\n",
    "\n",
    "assert mode([1, 2, 2, 3, 4]) == 2\n",
    "assert mode([1, 1, 2, 3]) == 1\n",
    "assert mode([2, 2, 3, 3, 3]) == 3\n",
    "print(\"Exercise 63 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 64\n",
    "# Write a function definition named product_of_all that takes in sequence of numbers and returns the product of multiplying all the numbers together\n",
    "\n",
    "assert product_of_all([1, 2, 3]) == 6\n",
    "assert product_of_all([3, 4, 5]) == 60\n",
    "assert product_of_all([2, 2, 3, 0]) == 0\n",
    "print(\"Exercise 64 is correct.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Applying functions to lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 65\n",
    "# Write a function definition named get_highest_number that takes in sequence of numbers and returns the largest number.\n",
    "\n",
    "assert get_highest_number([1, 2, 3]) == 3\n",
    "assert get_highest_number([-5, -4, -3, -2, -1, 1, 2, 3, 4, 5]) == 5\n",
    "assert get_highest_number([-5, -3, 1]) == 1\n",
    "print(\"Exercise 65 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 66\n",
    "# Write a function definition named get_smallest_number that takes in sequence of numbers and returns the smallest number.\n",
    "\n",
    "assert get_smallest_number([1, 3, 2]) == 1\n",
    "assert get_smallest_number([5, -5, -4, -3, -2, -1, 1, 2, 3, 4]) == -5\n",
    "assert get_smallest_number([-4, -3, 1, -10]) == -10\n",
    "print(\"Exercise 66 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 67\n",
    "# Write a function definition named only_odd_numbers that takes in sequence of numbers and returns the odd numbers in a list.\n",
    "\n",
    "assert only_odd_numbers([1, 2, 3]) == [1, 3]\n",
    "assert only_odd_numbers([-5, -4, -3, -2, -1, 1, 2, 3, 4, 5]) == [-5, -3, -1, 1, 3, 5]\n",
    "assert only_odd_numbers([-4, -3, 1]) == [-3, 1]\n",
    "assert only_odd_numbers([2, 2, 2, 2, 2]) == []\n",
    "print(\"Exercise 67 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 68\n",
    "# Write a function definition named only_even_numbers that takes in sequence of numbers and returns the even numbers in a list.\n",
    "\n",
    "assert only_even_numbers([1, 2, 3]) == [2]\n",
    "assert only_even_numbers([-5, -4, -3, -2, -1, 1, 2, 3, 4, 5]) == [-4, -2, 2, 4]\n",
    "assert only_even_numbers([-4, -3, 1]) == [-4]\n",
    "assert only_even_numbers([1, 1, 1, 1, 1, 1]) == []\n",
    "print(\"Exercise 68 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 69\n",
    "# Write a function definition named only_positive_numbers that takes in sequence of numbers and returns the positive numbers in a list.\n",
    "\n",
    "assert only_positive_numbers([1, 2, 3]) == [1, 2, 3]\n",
    "assert only_positive_numbers([-5, -4, -3, -2, -1, 1, 2, 3, 4, 5]) == [1, 2, 3, 4, 5]\n",
    "assert only_positive_numbers([-4, -3, 1]) == [1]\n",
    "print(\"Exercise 69 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 70\n",
    "# Write a function definition named only_negative_numbers that takes in sequence of numbers and returns the negative numbers in a list.\n",
    "\n",
    "assert only_negative_numbers([1, 2, 3]) == []\n",
    "assert only_negative_numbers([-5, -4, -3, -2, -1, 1, 2, 3, 4, 5]) == [-5, -4, -3, -2, -1]\n",
    "assert only_negative_numbers([-4, -3, 1]) == [-4, -3]\n",
    "print(\"Exercise 70 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 71\n",
    "# Write a function definition named has_evens that takes in sequence of numbers and returns True if there are any even numbers in the sequence\n",
    "\n",
    "assert has_evens([1, 2, 3]) == True\n",
    "assert has_evens([2, 5, 6]) == True\n",
    "assert has_evens([3, 3, 3]) == False\n",
    "assert has_evens([]) == False\n",
    "print(\"Exercise 71 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 72\n",
    "# Write a function definition named count_evens that takes in sequence of numbers and returns the number of even numbers\n",
    "\n",
    "assert count_evens([1, 2, 3]) == 1\n",
    "assert count_evens([2, 5, 6]) == 2\n",
    "assert count_evens([3, 3, 3]) == 0\n",
    "assert count_evens([5, 6, 7, 8] ) == 2\n",
    "print(\"Exercise 72 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 73\n",
    "# Write a function definition named has_odds that takes in sequence of numbers and returns True if there are any odd numbers in the sequence\n",
    "\n",
    "assert has_odds([1, 2, 3]) == True\n",
    "assert has_odds([2, 5, 6]) == True\n",
    "assert has_odds([3, 3, 3]) == True\n",
    "assert has_odds([2, 4, 6]) == False\n",
    "print(\"Exercise 73 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 74\n",
    "# Write a function definition named count_odds that takes in sequence of numbers and returns True if there are any odd numbers in the sequence\n",
    "\n",
    "assert count_odds([1, 2, 3]) == 2\n",
    "assert count_odds([2, 5, 6]) == 1\n",
    "assert count_odds([3, 3, 3]) == 3\n",
    "assert count_odds([2, 4, 6]) == 0\n",
    "print(\"Exercise 74 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 75\n",
    "# Write a function definition named count_negatives that takes in sequence of numbers and returns a count of the number of negative numbers\n",
    "\n",
    "assert count_negatives([1, -2, 3]) == 1\n",
    "assert count_negatives([2, -5, -6]) == 2\n",
    "assert count_negatives([3, 3, 3]) == 0\n",
    "print(\"Exercise 75 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 76\n",
    "# Write a function definition named count_positives that takes in sequence of numbers and returns a count of the number of positive numbers\n",
    "\n",
    "assert count_positives([1, -2, 3]) == 2\n",
    "assert count_positives([2, -5, -6]) == 1\n",
    "assert count_positives([3, 3, 3]) == 3\n",
    "assert count_positives([-2, -1, -5]) == 0\n",
    "print(\"Exercise 76 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 77\n",
    "# Write a function definition named only_positive_evens that takes in sequence of numbers and returns a list containing all the positive evens from the sequence\n",
    "\n",
    "assert only_positive_evens([1, -2, 3]) == []\n",
    "assert only_positive_evens([2, -5, -6]) == [2]\n",
    "assert only_positive_evens([3, 3, 4, 6]) == [4, 6]\n",
    "assert only_positive_evens([2, 3, 4, -1, -5]) == [2, 4]\n",
    "print(\"Exercise 77 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 78\n",
    "# Write a function definition named only_positive_odds that takes in sequence of numbers and returns a list containing all the positive odd numbers from the sequence\n",
    "\n",
    "assert only_positive_odds([1, -2, 3]) == [1, 3]\n",
    "assert only_positive_odds([2, -5, -6]) == []\n",
    "assert only_positive_odds([3, 3, 4, 6]) == [3, 3]\n",
    "assert only_positive_odds([2, 3, 4, -1, -5]) == [3]\n",
    "print(\"Exercise 78 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 79\n",
    "# Write a function definition named only_negative_evens that takes in sequence of numbers and returns a list containing all the negative even numbers from the sequence\n",
    "\n",
    "assert only_negative_evens([1, -2, 3]) == [-2]\n",
    "assert only_negative_evens([2, -5, -6]) == [-6]\n",
    "assert only_negative_evens([3, 3, 4, 6]) == []\n",
    "assert only_negative_evens([-2, 3, 4, -1, -4]) == [-2, -4]\n",
    "print(\"Exercise 79 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 80\n",
    "# Write a function definition named only_negative_odds that takes in sequence of numbers and returns a list containing all the negative odd numbers from the sequence\n",
    "\n",
    "assert only_negative_odds([1, -2, 3]) == []\n",
    "assert only_negative_odds([2, -5, -6]) == [-5]\n",
    "assert only_negative_odds([3, 3, 4, 6]) == []\n",
    "assert only_negative_odds([2, -3, 4, -1, -4]) == [-3, -1]\n",
    "print(\"Exercise 80 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 81\n",
    "# Write a function definition named shortest_string that takes in a list of strings and returns the shortest string in the list.\n",
    "\n",
    "assert shortest_string([\"kiwi\", \"mango\", \"strawberry\"]) == \"kiwi\"\n",
    "assert shortest_string([\"hello\", \"everybody\"]) == \"hello\"\n",
    "assert shortest_string([\"mary\", \"had\", \"a\", \"little\", \"lamb\"]) == \"a\"\n",
    "print(\"Exercise 81 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 82\n",
    "# Write a function definition named longest_string that takes in sequence of strings and returns the longest string in the list.\n",
    "\n",
    "assert longest_string([\"kiwi\", \"mango\", \"strawberry\"]) == \"strawberry\"\n",
    "assert longest_string([\"hello\", \"everybody\"]) == \"everybody\"\n",
    "assert longest_string([\"mary\", \"had\", \"a\", \"little\", \"lamb\"]) == \"little\"\n",
    "print(\"Exercise 82 is correct.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with sets\n",
    "**Hint** Take a look at the `set` function in Python, the `set` data type, and built-in `set` methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example set function usage\n",
    "print(set(\"kiwi\"))\n",
    "print(set([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 83\n",
    "# Write a function definition named get_unique_values that takes in a list and returns a set with only the unique values from that list.\n",
    "\n",
    "assert get_unique_values([\"ant\", \"ant\", \"mosquito\", \"mosquito\", \"ladybug\"]) == {\"ant\", \"mosquito\", \"ladybug\"}\n",
    "assert get_unique_values([\"b\", \"a\", \"n\", \"a\", \"n\", \"a\", \"s\"]) == {\"b\", \"a\", \"n\", \"s\"}\n",
    "assert get_unique_values([\"mary\", \"had\", \"a\", \"little\", \"lamb\", \"little\", \"lamb\", \"little\", \"lamb\"]) == {\"mary\", \"had\", \"a\", \"little\", \"lamb\"}\n",
    "print(\"Exercise 83 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 84\n",
    "# Write a function definition named get_unique_values_from_two_lists that takes two lists and returns a single set with only the unique values\n",
    "\n",
    "assert get_unique_values_from_two_lists([5, 1, 2, 3], [3, 4, 5, 5]) == {1, 2, 3, 4, 5}\n",
    "assert get_unique_values_from_two_lists([1, 1], [2, 2, 3]) == {1, 2, 3}\n",
    "assert get_unique_values_from_two_lists([\"tomato\", \"mango\", \"kiwi\"], [\"eggplant\", \"tomato\", \"broccoli\"]) == {\"tomato\", \"mango\", \"kiwi\", \"eggplant\", \"broccoli\"}\n",
    "print(\"Exercise 84 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 85\n",
    "# Write a function definition named get_values_in_common that takes two lists and returns a single set with the values that each list has in common\n",
    "\n",
    "assert get_values_in_common([5, 1, 2, 3], [3, 4, 5, 5]) == {3, 5}\n",
    "assert get_values_in_common([1, 2], [2, 2, 3]) == {2}\n",
    "assert get_values_in_common([\"tomato\", \"mango\", \"kiwi\"], [\"eggplant\", \"tomato\", \"broccoli\"]) == {\"tomato\"}\n",
    "print(\"Exercise 85 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 86\n",
    "# Write a function definition named get_values_not_in_common that takes two lists and returns a single set with the values that each list does not have in common\n",
    "\n",
    "assert get_values_not_in_common([5, 1, 2, 3], [3, 4, 5, 5]) == {1, 2, 4}\n",
    "assert get_values_not_in_common([1, 1], [2, 2, 3]) == {1, 2, 3}\n",
    "assert get_values_not_in_common([\"tomato\", \"mango\", \"kiwi\"], [\"eggplant\", \"tomato\", \"broccoli\"]) == {\"mango\", \"kiwi\", \"eggplant\", \"broccoli\"}\n",
    "print(\"Exercise 86 is correct.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with Dictionaries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell in order to have these two dictionary variables defined.\n",
    "tukey_paper = {\n",
    "    \"title\": \"The Future of Data Analysis\",\n",
    "    \"author\": \"John W. Tukey\",\n",
    "    \"link\": \"https://projecteuclid.org/euclid.aoms/1177704711\",\n",
    "    \"year_published\": 1962\n",
    "}\n",
    "\n",
    "thomas_paper = {\n",
    "    \"title\": \"A mathematical model of glutathione metabolism\",\n",
    "    \"author\": \"Rachel Thomas\",\n",
    "    \"link\": \"https://www.ncbi.nlm.nih.gov/pubmed/18442411\",\n",
    "    \"year_published\": 2008\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 87\n",
    "# Write a function named get_paper_title that takes in a dictionary and returns the title property\n",
    "\n",
    "assert get_paper_title(tukey_paper) == \"The Future of Data Analysis\"\n",
    "assert get_paper_title(thomas_paper) == \"A mathematical model of glutathione metabolism\"\n",
    "print(\"Exercise 87 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 88\n",
    "# Write a function named get_year_published that takes in a dictionary and returns the value behind the \"year_published\" key.\n",
    "\n",
    "assert get_year_published(tukey_paper) == 1962\n",
    "assert get_year_published(thomas_paper) == 2008\n",
    "print(\"Exercise 88 is correct.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this code to create data for the next two questions\n",
    "book = {\n",
    "    \"title\": \"Genetic Algorithms and Machine Learning for Programmers\",\n",
    "    \"price\": 36.99,\n",
    "    \"author\": \"Frances Buontempo\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 89\n",
    "# Write a function named get_price that takes in a dictionary and returns the price\n",
    "\n",
    "assert get_price(book) == 36.99\n",
    "print(\"Exercise 89 is complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 90\n",
    "# Write a function named get_book_author that takes in a dictionary (the above declared book variable) and returns the author's name\n",
    "\n",
    "\n",
    "assert get_book_author(book) == \"Frances Buontempo\"\n",
    "print(\"Exercise 90 is complete.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with Lists of Dictionaries\n",
    "**Hint** If you need an example of lists of dictionaries, see \n",
    "- [Getting Started With a List of Dictionaries](https://colab.research.google.com/github/ryanorsinger/list_of_dictionaries/blob/main/getting_started.ipynb)\n",
    "- [Practice Exercises for List of Dictionaries](https://colab.research.google.com/github/ryanorsinger/list_of_dictionaries/blob/main/exercises.ipynb)\n",
    "- [Companion Video](https://www.youtube.com/watch?v=pPdEahZgv8U)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell in order to have some setup data for the next exercises\n",
    "books = [\n",
    "    {\n",
    "        \"title\": \"Genetic Algorithms and Machine Learning for Programmers\",\n",
    "        \"price\": 36.99,\n",
    "        \"author\": \"Frances Buontempo\"\n",
    "    },\n",
    "    {\n",
    "        \"title\": \"The Visual Display of Quantitative Information\",\n",
    "        \"price\": 38.00,\n",
    "        \"author\": \"Edward Tufte\"\n",
    "    },\n",
    "    {\n",
    "        \"title\": \"Practical Object-Oriented Design\",\n",
    "        \"author\": \"Sandi Metz\",\n",
    "        \"price\": 30.47\n",
    "    },\n",
    "    {\n",
    "        \"title\": \"Weapons of Math Destruction\",\n",
    "        \"author\": \"Cathy O'Neil\",\n",
    "        \"price\": 17.44\n",
    "    }\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 91\n",
    "# Write a function named get_number_of_books that takes in a list of objects and returns the number of dictionaries in that list.\n",
    "\n",
    "assert get_number_of_books(books) == 4\n",
    "print(\"Exercise 91 is complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 92\n",
    "# Write a function named total_of_book_prices that takes in a list of dictionaries and returns the sum total of all the book prices added together\n",
    "\n",
    "assert total_of_book_prices(books) == 122.9\n",
    "print(\"Exercise 92 is complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 93\n",
    "# Write a function named get_average_book_price that takes in a list of dictionaries and returns the average book price.\n",
    "\n",
    "assert get_average_book_price(books) == 30.725\n",
    "print(\"Exercise 93 is complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 94\n",
    "# Write a function called highest_price_book that takes in the above defined list of dictionaries \"books\" and returns the dictionary containing the title, price, and author of the book with the highest priced book.\n",
    "# Hint: Much like sometimes start functions with a variable set to zero, you may want to create a dictionary with the price set to zero to compare to each dictionary's price in the list\n",
    "\n",
    "assert highest_price_book(books) == {\n",
    "    \"title\": \"The Visual Display of Quantitative Information\",\n",
    "    \"price\": 38.00,\n",
    "    \"author\": \"Edward Tufte\"\n",
    "}\n",
    "\n",
    "print(\"Exercise 94 is complete\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 95\n",
    "# Write a function called lowest_priced_book that takes in the above defined list of dictionaries \"books\" and returns the dictionary containing the title, price, and author of the book with the lowest priced book.\n",
    "# Hint: Much like sometimes start functions with a variable set to zero or float('inf'), you may want to create a dictionary with the price set to float('inf') to compare to each dictionary in the list\n",
    "\n",
    "\n",
    "assert lowest_price_book(books) == {\n",
    "    \"title\": \"Weapons of Math Destruction\",\n",
    "    \"author\": \"Cathy O'Neil\",\n",
    "    \"price\": 17.44\n",
    "}\n",
    "print(\"Exercise 95 is complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shopping_cart = {\n",
    "    \"tax\": .08,\n",
    "    \"items\": [\n",
    "        {\n",
    "            \"title\": \"orange juice\",\n",
    "            \"price\": 3.99,\n",
    "            \"quantity\": 1\n",
    "        },\n",
    "        {\n",
    "            \"title\": \"rice\",\n",
    "            \"price\": 1.99,\n",
    "            \"quantity\": 3\n",
    "        },\n",
    "        {\n",
    "            \"title\": \"beans\",\n",
    "            \"price\": 0.99,\n",
    "            \"quantity\": 3\n",
    "        },\n",
    "        {\n",
    "            \"title\": \"chili sauce\",\n",
    "            \"price\": 2.99,\n",
    "            \"quantity\": 1\n",
    "        },\n",
    "        {\n",
    "            \"title\": \"chocolate\",\n",
    "            \"price\": 0.75,\n",
    "            \"quantity\": 9\n",
    "        }\n",
    "    ]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 96\n",
    "# Write a function named get_tax_rate that takes in the above shopping cart as input and returns the tax rate.\n",
    "# Hint: How do you access a key's value on a dictionary? The tax rate is one key of the entire shopping_cart dictionary.\n",
    "\n",
    "assert get_tax_rate(shopping_cart) == .08\n",
    "print(\"Exercise 96 is complete\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 97\n",
    "# Write a function named number_of_item_types that takes in the shopping cart as input and returns the number of unique item types in the shopping cart. \n",
    "# We're not yet using the quantity of each item, but rather focusing on determining how many different types of items are in the cart.\n",
    "\n",
    "assert number_of_item_types(shopping_cart) == 5\n",
    "print(\"Exercise 97 is complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 98\n",
    "# Write a function named total_number_of_items that takes in the shopping cart as input and returns the total number all item quantities.\n",
    "# This should return the sum of all of the quantities from each item type\n",
    "\n",
    "assert total_number_of_items(shopping_cart) == 17\n",
    "print(\"Exercise 98 is complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 99\n",
    "# Write a function named get_average_item_price that takes in the shopping cart as an input and returns the average of all the item prices.\n",
    "# Hint - This should determine the total price divided by the number of types of items. This does not account for each item type's quantity.\n",
    "assert get_average_item_price(shopping_cart) == 2.1420000000000003\n",
    "print(\"Exercise 99 is complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 100\n",
    "# Write a function named get_average_spent_per_item that takes in the shopping cart and returns the average of summing each item's quanties times that item's price.\n",
    "# Hint: You may need to set an initial total price and total total quantity to zero, then sum up and divide that total price by the total quantity\n",
    "\n",
    "assert get_average_spent_per_item(shopping_cart) == 1.333529411764706\n",
    "print(\"Exercise 100 is complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise 101\n",
    "# Write a function named most_spent_on_item that takes in the shopping cart as input and returns the dictionary associated with the item that has the highest price*quantity.\n",
    "# Be sure to do this as programmatically as possible. \n",
    "# Hint: Similarly to how we sometimes begin a function with setting a variable to zero, we need a starting place:\n",
    "# Hint: Consider creating a variable that is a dictionary with the keys \"price\" and \"quantity\" both set to 0. You can then compare each item's price and quantity total to the one from \"most\"\n",
    "\n",
    "assert most_spent_on_item(shopping_cart) == {\n",
    "    \"title\": \"chocolate\",\n",
    "    \"price\": 0.75,\n",
    "    \"quantity\": 9\n",
    "}\n",
    "print(\"Exercise 101 is complete.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Created by [Ryan Orsinger](https://ryanorsinger.com)\n",
    "\n",
    "Source code on [https://github.com/ryanorsinger/101-exercises](https://github.com/ryanorsinger/101-exercises)"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}