Jiya_Agarwal_Assignment_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Jiya918/WordForThought/blob/main/Jiya_Agarwal_Assignment_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "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!"
      ],
      "metadata": {
        "id": "rMNaoJBIn0eW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Fork the repository and make a copy of this notebook and rename it as your name_Assignment1\n",
        "2. Generate a pull request as taught to you in the GitHub Session. The pull request message should also be yourname_Assignment1\n",
        "\n"
      ],
      "metadata": {
        "id": "dtdJ1pURn--h"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Orientation\n",
        "1. This code notebook is composed of cells. Each cell is either text or Python code.\n",
        "2. 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",
        "3. Each assert line is both an example and a test that tests for the presence and functionality of the instructed exercise."
      ],
      "metadata": {
        "id": "Y1Lrvy8eonkb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Outline\n",
        "1. Each cell starts with a problem statement that describes the\n",
        "exercise to complete.\n",
        "2. Underneath each problem statement, learners will need to write code to produce an answer.\n",
        "3. The assert lines test to see that your code solves the problem appropriately.\n",
        "4. Do not alter or delete the assertion tests, since those are providing automated testing.\n",
        "5. Many exercises will rely on previous solutions to be correctly completed\n",
        "6. The print(\"Exercise is complete\") line will only run if your solution passes the assertion test(s)\n",
        "7. 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."
      ],
      "metadata": {
        "id": "egsBMww1o-Kw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a= doing_python_right_now\n",
        "print(bool(a))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 158
        },
        "id": "yefcwdnclTCS",
        "outputId": "d48962bb-1fe8-4496-8fbe-bcc924a3ddbe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'doing_python_right_now' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-7f8e5671bab3>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mdoing_python_right_now\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'doing_python_right_now' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5cd614b8-9907-4d71-b590-305ed223a47f",
        "id": "azr75XhQpN14"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 0 is correct\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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."
      ],
      "metadata": {
        "id": "wn8-c0_hppDZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "461d048d-9645-4de0-970d-2182b2bf7962"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 0 is correct\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "on_mars_right_now = False\n",
        "a = on_mars_right_now\n",
        "print(bool(a))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fmftlHbRngEf",
        "outputId": "cb6e1de9-52da-4016-92f3-0c3d31f722b3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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.\")"
      ],
      "metadata": {
        "id": "b-U50lKCp-bF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7e7a549d-42fd-4e1a-e24d-c15cefa3545c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 1 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fruits =[\"mango\" , \"banana\", \"guava\",\"kiwi\", \"strawberry\"]\n",
        "print(fruits)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fr8LROuzthyB",
        "outputId": "b30def27-2121-4ea1-911a-47adfbcfe16c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['mango', 'banana', 'guava', 'kiwi', 'strawberry']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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.\")"
      ],
      "metadata": {
        "id": "m_7w5CKtqDGY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "18690b9d-da87-42e3-f008-a1ad91a8bb2d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 2 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "vegetables = [\"eggplant\", \"broccoli\", \"carrot\", \"cauliflower\", \"zucchini\"]\n",
        "print(vegetables)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AQwlomXBvOOX",
        "outputId": "9d6dbad2-4974-429a-d089-9eadd86b0fa5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['eggplant', 'broccoli', 'carrot', 'cauliflower', 'zucchini']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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.\")"
      ],
      "metadata": {
        "id": "13W-B4Z0qIQD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c1fff6b-119b-4fb5-daef-74ae7d088e5e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 3 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# List Operations\n",
        "Recommend finding and using built-in Python functionality whenever possible.\n",
        "Google any syntax that you do not know.\n"
      ],
      "metadata": {
        "id": "tfyYtxDxqUMY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"mango\", \"banana\", \"guava\", \"kiwi\", \"strawberry\"]\n",
        "\n",
        "fruits.append(\"tomato\")\n",
        "print(fruits)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KTDaxMTIwmAI",
        "outputId": "7b58348a-06f8-41e5-ceca-c72b1bef4361"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['mango', 'banana', 'guava', 'kiwi', 'strawberry', 'tomato']\n"
          ]
        }
      ]
    },
    {
      "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",
        "# Add \"tomato\" to the end of the list using the append method\n",
        "fruits.append(\"tomato\")\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",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M4_0dqjvJf_h",
        "outputId": "44c62904-997b-4716-c0b2-710479cdf56d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 5 is correct\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "numbers.reverse()\n",
        "print(numbers)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b3zYTGKr3Ku8",
        "outputId": "8e19653b-0ccc-4fef-a390-bf54c836694d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "source": [
        "# Exercise 6\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",
        "# Reverse the list using the reverse() method\n",
        "numbers.reverse()  # This line is added to reverse the list in-place\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 6 is correct.\")"
      ],
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ze3eSY-4JwrE",
        "outputId": "6a3e3349-b1f2-4744-b7eb-abce35a8fe12"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 6 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        " vegetables = ['broccoli', 'carrot', 'cauliflower', 'eggplant', 'tomato', 'zucchini']\n",
        " vegetables.sort()\n",
        " print(vegetables)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U1JlPh2G3m9_",
        "outputId": "8b720e2b-5f13-44ad-d258-857f6436edcb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['broccoli', 'carrot', 'cauliflower', 'eggplant', 'tomato', 'zucchini']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 7\n",
        "# Sort the vegetables in alphabetical order\n",
        "\n",
        "assert vegetables == ['broccoli', 'carrot', 'cauliflower', 'eggplant', 'tomato', 'zucchini']\n",
        "print(\"Exercise 7 is correct.\")"
      ],
      "metadata": {
        "id": "TlT-8Jmzqpb_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "476aba24-bdd0-435c-b723-0a273605c6f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 7 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fruits.sort()\n",
        "fruits.reverse()\n",
        "print(fruits)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XEDzoouPKmID",
        "outputId": "187c1e60-381a-4b00-d185-bbb07cb1c93b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['tomato', 'strawberry', 'mango', 'kiwi', 'guava', 'banana']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 8\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 8 is correct.\")"
      ],
      "metadata": {
        "id": "TZUKbNM1qulZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bebcefef-fdc5-48c7-c85d-5250dc119053"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exercise 8 is correct.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercise 9\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 9 is correct\")"
      ],
      "metadata": {
        "id": "MopnqOvpq451"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Functions\n",
        " Be sure to `return` values from your function definitions. The assert statements will call your function(s) for you.\n",
        "\n"
      ],
      "metadata": {
        "id": "oWLyvC9LrBCR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "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)"
      ],
      "metadata": {
        "id": "mOk8wKjGMHwn",
        "outputId": "dd208274-e0cb-4395-9557-42a3fd9b00e0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 211
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'random' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-18-f3abbc04d5b7>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mpositive_even_number\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m101\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mnegative_even_number\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mpositive_odd_number\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mnegative_odd_number\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m101\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'random' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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)"
      ],
      "metadata": {
        "id": "mA1EpbOcsIIO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def say_hello(name):\n",
        "   print(\"Hello,\" + name + \"!\")\n",
        "say_hello(\"Jane\")\n",
        "say_hello(\"Pat\")\n",
        "say_hello(\"Astrud\")"
      ],
      "metadata": {
        "id": "4WCH93H4Mwho"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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\")"
      ],
      "metadata": {
        "id": "HcbHpZ4trI-W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plus_two(number):\n",
        "  print (number+2)\n",
        "plus_two(3)\n",
        "plus_two(0)\n",
        "plus_two(-2)"
      ],
      "metadata": {
        "id": "uvem0_PAO9Tc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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.\")"
      ],
      "metadata": {
        "id": "BiIErtZbrQI7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def add_one(number):\n",
        " return number+1\n",
        "add_one(2)\n",
        "add_one(0)\n",
        "add_one(positive_even_number)\n",
        "add_one(negative_odd_number)"
      ],
      "metadata": {
        "collapsed": true,
        "id": "VjX6IWIJPbvE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 10\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 10 is correct.\")"
      ],
      "metadata": {
        "id": "EUGkV7nTrZbA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def is_odd(number):\n",
        "  return number % 2 == 1\n",
        "is_odd(positive_odd_number)\n",
        "is_odd(positive_even_number)\n",
        "is_odd(negative_odd_number)\n",
        "is_odd(negative_even_number)"
      ],
      "metadata": {
        "id": "1aZDJfqFQ1TZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 11\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 11 is correct.\")"
      ],
      "metadata": {
        "id": "iTQVLcarrcG3",
        "collapsed": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def is_positive_even(number):\n",
        " return number > 0 and number % 2 == 0\n",
        "is_positive_even(4)\n",
        "is_positive_even(positive_odd_number)\n",
        "is_positive_even(positive_even_number)\n",
        "is_positive_even(negative_odd_number)\n",
        "is_positive_even(negative_even_number)"
      ],
      "metadata": {
        "id": "XUs-WYvlUCWf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 12\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 12 is correct.\")"
      ],
      "metadata": {
        "id": "G6Ai1Dhrri5D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def double(number):\n",
        "  return number * 2\n",
        "double(4)\n",
        "double(5)\n",
        "double(positive_odd_number)\n",
        "double(positive_even_number)\n",
        "double(negative_odd_number)\n",
        "double(negative_even_number)\n"
      ],
      "metadata": {
        "id": "nMCM069mUzKB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 13\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 13 is correct.\")"
      ],
      "metadata": {
        "id": "tm5TrqFArsjH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_of_squares(x,y):\n",
        "  return x**2 + y**2\n",
        "sum_of_squares(3,2)\n",
        "sum_of_squares(5,2)\n",
        "sum_of_squares(2,4)"
      ],
      "metadata": {
        "id": "PMqfuDsWVzi1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 14\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 14 is correct.\")"
      ],
      "metadata": {
        "id": "GSrhmkNwr6Qn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Functions with Strings\n",
        "I recommend you go through the two google colab files I have shared if you have difficulty in this."
      ],
      "metadata": {
        "id": "PaiPvt74srzZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def has_vowels(value):\n",
        "  return \"a\" in value or \"e\" in value or \"i\" in value or \"o\" in value or \"u\" in value\n",
        "has_vowels(\"banana\")\n",
        "has_vowels(\"ubuntu\")\n",
        "has_vowels(\"QQQQ\")\n",
        "has_vowels(\"wyrd\")"
      ],
      "metadata": {
        "id": "223HFbaZWvVO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 15\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 15 is correct.\")"
      ],
      "metadata": {
        "id": "4auRgTnMsbet"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def count_vowels(value):\n",
        "  return value.count(\"a\") + value.count(\"e\") + value.count(\"i\") + value.count(\"o\") + value.count(\"u\")\n",
        "count_vowels(\"banana\")\n",
        "count_vowels(\"ubyntu\")\n",
        "count_vowels(\"mango\")\n",
        "count_vowels(\"QQQQ\")\n",
        "count_vowels(\"wyrd\")\n"
      ],
      "metadata": {
        "id": "B0Nk5p4lYGVC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 16\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 16 is correct.\")"
      ],
      "metadata": {
        "id": "QN-lkLYftB0q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def remove_vowels(value):\n",
        "  return value.replace(\"a\",\"\").replace(\"e\",\"\").replace(\"i\",\"\").replace(\"o\",\"\").replace(\"u\",\"\")\n",
        "remove_vowels(\"banana\")\n",
        "remove_vowels(\"ubuntu\")\n",
        "remove_vowels(\"mango\")\n",
        "remove_vowels(\"QQQQ\")"
      ],
      "metadata": {
        "id": "nwijAlBHaA2X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 17\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 17 is correct.\")"
      ],
      "metadata": {
        "id": "3Uswu498tGDe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def starts_and_ends_with_vowel (value):\n",
        "  return value[0] in \"aeiou\" and value[-1] in \"aeiou\"\n",
        "starts_and_ends_with_vowel(\"ubuntu\")\n",
        "starts_and_ends_with_vowel(\"banana\")\n",
        "starts_and_ends_with_vowel(\"mango\")"
      ],
      "metadata": {
        "id": "_1I743YhcTZ4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 18\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 18 is correct.\")"
      ],
      "metadata": {
        "id": "WabXu0XxtLCR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Accessing List Elements\n"
      ],
      "metadata": {
        "id": "xCqaLNfCtcgG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def first(value):\n",
        "  return value[0]\n",
        "first([1,2,3])\n",
        "first([\"python\",\"is\",\"awesome\"])"
      ],
      "metadata": {
        "id": "cfxoUNwReE6K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 19\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 19 is correct.\")"
      ],
      "metadata": {
        "id": "SA7pw41btcI-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def last(value):\n",
        "  return value[-1]\n",
        "last(\"ubuntu\")\n",
        "last([1,2,3,4])\n",
        "last([\"python\", \"is\", \"awesome\"])\n",
        "last([\"kiwi\",\"mango\",\"guava\"])"
      ],
      "metadata": {
        "id": "pPvGi49gfTBY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 20\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 20 is correct.\")"
      ],
      "metadata": {
        "id": "2LUxN5jitowc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def first_and_second(value):\n",
        "  return [value[0], value[1]]\n",
        "first_and_second([1, 2, 3, 4])\n",
        "first_and_second([\"python\", \"is\", \"awesome\"])\n",
        "first_and_second([\"strawberry\", \"kiwi\", \"mango\", \"guava\"])"
      ],
      "metadata": {
        "collapsed": true,
        "id": "szkxFKmkf6lA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 21\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 21 is correct.\")"
      ],
      "metadata": {
        "id": "gdY9_AJCttvJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def first_to_last(value):\n",
        "  return value[1:] + [value[0]]\n",
        "first_to_last([1, 2, 3, 4])\n",
        "first_to_last([\"python\", \"is\", \"awesome\"])\n",
        "first_to_last([\"strawberry\", \"kiwi\", \"mango\", \"guava\"])"
      ],
      "metadata": {
        "id": "o6d-BaNxjnJ0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 22\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 22 is correct.\")"
      ],
      "metadata": {
        "id": "cDPGhuedt0OF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Functions to Describe Data\n"
      ],
      "metadata": {
        "id": "8LRyayWlt6ZN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sum_all(value):\n",
        "  return sum(value)\n",
        "sum_all([1,2,3,4])\n",
        "sum_all([3,3,3])\n",
        "sum_all([0,5,6])"
      ],
      "metadata": {
        "id": "kSzYDyzfk3pf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 23\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 23 is correct.\")"
      ],
      "metadata": {
        "id": "m2sAHpw-t58l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def mean(value):\n",
        "  return sum(value)/len(value)\n",
        "mean([1,2,3,4,5])\n",
        "mean([1,2,3])\n",
        "mean([1,5,6])\n",
        "mean([1,2,5,6])"
      ],
      "metadata": {
        "id": "sudrYiY5lRgT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 24\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, 5]) == 3.0\n",
        "assert mean([1, 2, 3]) == 2.0\n",
        "assert mean([1, 5, 6]) == 4.0\n",
        "assert mean([1, 2, 5, 6]) == 3.5\n",
        "print(\"Exercise 24 is correct.\")"
      ],
      "metadata": {
        "id": "Mt2EeKsfuEIW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def mode(value):\n",
        "  return max(value, key=value.count)\n",
        "mode([1, 2, 2, 3, 4])\n",
        "mode([1, 1, 2, 3])\n",
        "mode([2, 2, 3, 3, 3])"
      ],
      "metadata": {
        "id": "erELKVnYlsry"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 24\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 24 is correct.\")"
      ],
      "metadata": {
        "id": "HgLdQbNTuMqz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Applying Functions to Lists\n"
      ],
      "metadata": {
        "id": "F_MVcTfIuSiy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_highest_number(value):\n",
        "  return max(value)\n",
        "get_highest_number([1,2,3,4])\n",
        "get_highest_number([3,3,3])\n",
        "get_highest_number([0,5,6])"
      ],
      "metadata": {
        "id": "o1uuUySZpcIT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 25\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 25 is correct.\")"
      ],
      "metadata": {
        "id": "KAyrqevouXow"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def only_odd_numbers(value):\n",
        "  return [x for x in value if x % 2 != 0]\n",
        "only_odd_numbers([1, 2, 3])\n",
        "only_odd_numbers([-5, -4, -3, -2, -1, 1, 2, 3, 4, 5])\n",
        "only_odd_numbers([-4, -3, 1])\n",
        "only_odd_numbers([2, 2, 2, 2, 2])"
      ],
      "metadata": {
        "id": "TbwdvlILp1FD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 26\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 26 is correct.\")"
      ],
      "metadata": {
        "id": "517qI-KmucIa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def count_evens(value):\n",
        "  return len([x for x in value if x % 2 == 0])\n",
        "count_evens([1, 2, 3])\n",
        "count_evens([2,5,5])\n",
        "count_evens([3,3,3])\n",
        "count_evens([5,6,7,8])"
      ],
      "metadata": {
        "id": "jnbwTRPrt9Rh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 27\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 27 is correct.\")"
      ],
      "metadata": {
        "id": "uCpfD1NnugoD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def shortest_string(value):\n",
        "  return min(value, key = len)\n",
        "shortest_string([\"kiwi\", \"mango\", \"strawberry\"])\n",
        "shortest_string([\"hello\", \"everybody\"])\n",
        "shortest_string([\"mary\", \"had\", \"a\", \"little\", \"lamb\"])"
      ],
      "metadata": {
        "id": "xOe_1EI8ue4J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 28\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 28 is correct.\")"
      ],
      "metadata": {
        "id": "RxqDOb7Wum-C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Working with Sets\n",
        "Take a look at the `set` function in Python, the `set` data type, and built-in `set` methods."
      ],
      "metadata": {
        "id": "D9arvRTSu482"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(set(\"kiwi\"))\n",
        "print(set([1,2,2,3,3,3,4,4,4,4]))"
      ],
      "metadata": {
        "id": "mqyAlz_gvIbf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Example set function usage\n",
        "print(set(\"kiwi\"))\n",
        "print(set([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]))"
      ],
      "metadata": {
        "id": "4XjNxjkFu4b-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_unique_values(value):\n",
        "  return set(value)\n",
        "get_unique_values([\"ant\", \"ant\", \"mosquito\", \"mosquito\", \"ladybug\"])\n",
        "get_unique_values([\"b\", \"a\", \"n\", \"a\", \"n\", \"a\", \"s\"])\n",
        "get_unique_values([\"mary\", \"had\", \"a\", \"little\", \"lamb\", \"little\", \"lamb\", \"little\", \"lamb\"])"
      ],
      "metadata": {
        "id": "b0v8NleXvXSW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 29\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 29 is correct.\")"
      ],
      "metadata": {
        "id": "D3N-ZOg6vTpM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_values_in_common(x,y):\n",
        "  return set(x).intersection(y)\n",
        "get_values_in_common([5, 1, 2, 3], [3, 4, 5, 5])\n",
        "get_values_in_common([1, 2], [2, 2, 3])\n",
        "get_values_in_common([\"tomato\", \"mango\", \"kiwi\"], [\"eggplant\", \"tomato\", \"broccoli\"])"
      ],
      "metadata": {
        "id": "6vdnqoKdwH-r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise 30\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 30 is correct.\")"
      ],
      "metadata": {
        "id": "myQNUXapvXee"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "pzrDil06vdDj"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}