Python_MiniCourse_on_Kaggle.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python MiniCourse on Kaggle.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "hXxT_RD1f2Mh",
        "-pwVSPMelUk1",
        "uKg9kY57c0ap",
        "-6l06a3yjj7n",
        "pfD6rn6fzVJz",
        "0GJgqlZa-at9"
      ],
      "authorship_tag": "ABX9TyNy0FyUisryKQ+ODHS13uPC",
      "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/Daniel-Benson-Poe/66DaysOfData/blob/main/Python_MiniCourse_on_Kaggle.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Today we will be learning the ins and outs of basic Python and how we begin to tie Python into the vast world that is Data Science"
      ],
      "metadata": {
        "id": "wWlks3Huftjh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Hello, Python"
      ],
      "metadata": {
        "id": "hXxT_RD1f2Mh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Variable Assignment Numbers\n",
        "spam_amount = 0"
      ],
      "metadata": {
        "id": "McIoQ7Osf6ci"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# How do we output data?\n",
        "print(spam_amount)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gmlG_xwahJjA",
        "outputId": "49a732b9-8c90-4cd7-b7b2-8fc3082be4a2"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RGeib2ayfXc2",
        "outputId": "ca6c466e-ee95-4035-b7f7-1f362bcd6b03"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "# Learning a new data type - it's not just a number!\n",
        "type(spam_amount)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "An integer is a whole number; notice the lack of decimal places. It can be things like 1, 2, 5, 87, 12332, 6724235234, etc."
      ],
      "metadata": {
        "id": "0mmqDVfxg8Pz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Another number type\n",
        "type(19.95)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rSG9OII-gmT1",
        "outputId": "2fbd3060-abe8-4a31-f9ae-0703e9181a16"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A float is a partial number, or a number with a decimal. Things like 12.2, 44.1, or even 5.0."
      ],
      "metadata": {
        "id": "rQMwWjemgxin"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can even perform calculations! How else did you think a calculator worked? We can do the following arithmetic:"
      ],
      "metadata": {
        "id": "ipjEvfRqhcks"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Addition - a + b\n",
        "\n",
        "Subtraction = a - b\n",
        "\n",
        "Multiplication - a * b\n",
        "\n",
        "True Division - a / b\n",
        "\n",
        "Floor Division - a // b\n",
        "\n",
        "Modulus - a % b\n",
        "\n",
        "Exponentiation - a ** b\n",
        "\n",
        "Negation - -a"
      ],
      "metadata": {
        "id": "kMX8vIBahozX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's take a closer look at the difference of true division and floor division\n",
        "# True division will always return a float\n",
        "# Floor division will always return an integer rounded down\n",
        "print(5 / 2)\n",
        "print(6 / 2)\n",
        "print(5 // 2)\n",
        "print(6 // 2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "68qFeQSDgo7K",
        "outputId": "bb53ea00-7425-4aa3-efeb-513b06574f9a"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.5\n",
            "3.0\n",
            "2\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Built-in Functions for working with numbers:\n",
        "min()\n",
        "max()\n",
        "abs()"
      ],
      "metadata": {
        "id": "Vc5xe_6Fior7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# We can receive the minimum of a group of numbers\n",
        "print(min(1, 2, 3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LjPf6by-iKhZ",
        "outputId": "4900a63f-2536-4932-f764-bde913f95176"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can receive the maximum of a group of numbers\n",
        "print(max(1, 2, 3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XIyov7cRiyKo",
        "outputId": "be81860c-0a3d-4f1d-a8ae-c91448ff5916"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can receieve the absolute value of a given number\n",
        "print(abs(32))\n",
        "print(abs(-32))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HVrq_3AAizg2",
        "outputId": "40dcb640-10a0-4be6-c8ec-148d39b057f4"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "32\n",
            "32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "int and float functions can be called to convert to the corresponding data type"
      ],
      "metadata": {
        "id": "u6_TydqdjIM0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(float(10))\n",
        "print(int(3.33))\n",
        "# EVEN STRINGS!\n",
        "print(int('807') + 1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tzNQ_oMvi3Zk",
        "outputId": "7ef2e9e6-91db-4009-e693-17eee2518caf"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10.0\n",
            "3\n",
            "808\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Your Turn\n",
        "We are going to be writing some of our own code now. Are you ready?"
      ],
      "metadata": {
        "id": "S5KGeJSBjmBO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create a variable called color with an appropriate value on the line below\n",
        "# (Remember, strings in Python must be enclosed in 'single' or \"double\" quotes)\n",
        "color = \"Green\"\n",
        "print(color)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZjdxX--HjY_i",
        "outputId": "eb6251ea-b8fc-434a-ec07-29a4703126a9"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Green\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pi = 3.14159 # approximate\n",
        "diameter = 3\n",
        "# Create a variable called 'radius' equal to half the diameter\n",
        "radius = diameter / 2\n",
        "print(radius)\n",
        "\n",
        "# Create a variable called 'area', using the formula for the area of a circle: pi times the radius squared\n",
        "area = pi * (radius ** 2)\n",
        "print(area)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IXFp19Drjstu",
        "outputId": "6c9a456e-7110-4e0e-c0b4-e701dcb72826"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.5\n",
            "7.0685775\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "########### Setup code - don't touch this part ######################\n",
        "# If you're curious, these are examples of lists. We'll talk about \n",
        "# them in depth a few lessons from now. For now, just know that they're\n",
        "# yet another type of Python object, like int or float.\n",
        "a = [1, 2, 3]\n",
        "b = [3, 2, 1]\n",
        "\n",
        "######################################################################\n",
        "\n",
        "# Your code goes here. Swap the values to which a and b refer.\n",
        "# If you get stuck, you can always uncomment one or both of the lines in\n",
        "# the next cell for a hint, or to peek at the solution.\n",
        "print(a, b)\n",
        "a,b = b,a\n",
        "\n",
        "print(a, b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BBgqvP6Bj5Qv",
        "outputId": "a44cb38e-71b7-4efe-9058-6042091c4255"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3] [3, 2, 1]\n",
            "[3, 2, 1] [1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4. Alice, Bob and Carol have agreed to pool their Halloween candy and split it evenly among themselves. For the sake of their friendship, any candies left over will be smashed. For example, if they collectively bring home 91 candies, they'll take 30 each and smash 1.\n",
        "Write an arithmetic expression below to calculate how many candies they must smash for a given haul."
      ],
      "metadata": {
        "id": "DxYQCztnkLKg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "total_candies = 91\n",
        "DIVIDE_BY = 3\n",
        "print(total_candies % DIVIDE_BY)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qGkbV6bRj_N-",
        "outputId": "92e19cf3-2548-4240-b81c-639000f5accd"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Functions"
      ],
      "metadata": {
        "id": "-pwVSPMelUk1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python has a built-in help function that allows you to get a closer look at what you are trying to do"
      ],
      "metadata": {
        "id": "IREtgxAElZap"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "help(round)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aufheS7tlV9y",
        "outputId": "ad6e4a9a-b2e2-4e7b-f7ec-077395d7be5c"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on built-in function round in module builtins:\n",
            "\n",
            "round(number, ndigits=None)\n",
            "    Round a number to a given precision in decimal digits.\n",
            "    \n",
            "    The return value is an integer if ndigits is omitted or None.  Otherwise\n",
            "    the return value has the same type as the number.  ndigits may be negative.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "help(print)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aKN9xqkMlfl7",
        "outputId": "b3724152-86da-47f4-ed86-516dadfb0cb3"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on built-in function print in module builtins:\n",
            "\n",
            "print(...)\n",
            "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
            "    \n",
            "    Prints the values to a stream, or to sys.stdout by default.\n",
            "    Optional keyword arguments:\n",
            "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
            "    sep:   string inserted between values, default a space.\n",
            "    end:   string appended after the last value, default a newline.\n",
            "    flush: whether to forcibly flush the stream.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Defining Functions\n",
        "\n",
        "We will create a function called least_difference that takes three arguments. A function is built with the format:\n",
        "\n",
        "header introduced by def keyword\n",
        "indented block of code following : is what runs when the function is called\n",
        "return is a keyword that exits the function immediately and passes the value on the right hand side to the calling context\n",
        "docstring, surrounded by three qutations (\"\"\" \"\"\") can be added in to explain the function and allow the help() function to return this explanation"
      ],
      "metadata": {
        "id": "glxM-3rFlo1G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def least_difference(a, b, c):\n",
        "  \"\"\"Return the smallest difference between any two numbers among a, b, and c.\n",
        "\n",
        "  >>> least_difference(1, 5, -5)\n",
        "  4\n",
        "  \"\"\"\n",
        "  diff1 = abs(a-b)\n",
        "  diff2 = abs(b-c)\n",
        "  diff3 = abs(a-c)\n",
        "  return min(diff1, diff2, diff3)"
      ],
      "metadata": {
        "id": "mj5IT-K8ll67"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\n",
        "    least_difference(1, 10, 100),\n",
        "    least_difference(1, 10, 10),\n",
        "    least_difference(5, 6, 7)\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FrtkUBIomQbV",
        "outputId": "9b802c56-f7c6-40f9-9bb8-15476294f55b"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9 0 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "help(least_difference)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K0iybuMZmZ86",
        "outputId": "6ad38910-592f-4c17-93b2-39dcf40ac038"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on function least_difference in module __main__:\n",
            "\n",
            "least_difference(a, b, c)\n",
            "    Return the smallest difference between any two numbers among a, b, and c.\n",
            "    \n",
            "    >>> least_difference(1, 5, -5)\n",
            "    4\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can pass in default arguments when creating our function"
      ],
      "metadata": {
        "id": "lESEG2bDnOoo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def greet(who=\"Colin\"):\n",
        "  print(\"Hello,\", who)\n",
        "\n",
        "greet()\n",
        "greet(who=\"Kaggle\")\n",
        "greet(\"world\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OA61e9Ctm1Xm",
        "outputId": "a6826f54-9659-488a-bdd4-b5950beb4dd5"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Colin\n",
            "Hello, Kaggle\n",
            "Hello, world\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can even have functions applied to functions!"
      ],
      "metadata": {
        "id": "6luyQivfnjEm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def mult_by_five(x):\n",
        "  return 5 * x\n",
        "\n",
        "def call(fn, arg):\n",
        "  \"\"\"Call fn on arg\"\"\"\n",
        "  return fn(arg)\n",
        "\n",
        "def squared_call(fn, arg):\n",
        "  \"\"\"Call fn on the result of calling fn on arg\"\"\"\n",
        "  return fn(fn(arg))\n",
        "\n",
        "print(\n",
        "    call(mult_by_five, 1),\n",
        "    squared_call(mult_by_five, 1),\n",
        "    sep='\\n', # \\n is newline character that starts a new lin e\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Ndpb2q4naYz",
        "outputId": "122afde7-ec01-4c75-822a-b51bc367e52c"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def mod_5(x):\n",
        "  \"\"\"Return the remainder of x after dividing by 5\"\"\"\n",
        "  return x % 5\n",
        "\n",
        "print(\n",
        "    \"Which number is biggest?\",\n",
        "    max(100, 51, 14),\n",
        "    \"Which number is the biggest modulo 5?\",\n",
        "    max(100, 51, 14, key=mod_5),\n",
        "    sep='\\n',\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_2hPqe-mn9_K",
        "outputId": "f05d278f-568b-4c99-a665-3c1d719e83f7"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Which number is biggest?\n",
            "100\n",
            "Which number is the biggest modulo 5?\n",
            "14\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Your Turn!"
      ],
      "metadata": {
        "id": "RocES1cEosWm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def round_to_two_places(num):\n",
        "    \"\"\"Return the given number rounded to two decimal places. \n",
        "    \n",
        "    >>> round_to_two_places(3.14159)\n",
        "    3.14\n",
        "    \"\"\"\n",
        "    # Replace this body with your own code.\n",
        "    # (\"pass\" is a keyword that does literally nothing. We used it as a placeholder\n",
        "    # because after we begin a code block, Python requires at least one line of code)\n",
        "    return round(num, 2)"
      ],
      "metadata": {
        "id": "cic8yjE1oVg8"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(round_to_two_places(3.14159))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PQLlcLX8o2HZ",
        "outputId": "85046d6e-1535-4b8c-90c0-15d541056630"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.14\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def to_smash(total_candies, friends=3):\n",
        "    \"\"\"Return the number of leftover candies that must be smashed after distributing\n",
        "    the given number of candies evenly between 3 friends.\n",
        "    \n",
        "    >>> to_smash(91)\n",
        "    1\n",
        "    \"\"\"\n",
        "    return(total_candies % friends)"
      ],
      "metadata": {
        "id": "H8mx2mC_onHP"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(to_smash(91))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SS0ISUYipCYH",
        "outputId": "db3a4b95-69f7-4682-85ed-3e7ac9a9c1d3"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "Zf9IC4DGpGFE"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Booleans"
      ],
      "metadata": {
        "id": "uKg9kY57c0ap"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A bool is a datatype with two possible values, True and False"
      ],
      "metadata": {
        "id": "jSiOzWHcc437"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = True\n",
        "print(x)\n",
        "print(type(x))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U1bZg3HTc1v5",
        "outputId": "0f91dc41-2ecd-43ad-f844-3da93cccea83"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "<class 'bool'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Comparison Operations\n",
        "\n",
        "We can compare bits of data \n",
        "\n",
        "a == b - a equal to b\n",
        "\n",
        "a < b - a less than b\n",
        "\n",
        "a <= b - a less than or equal to b\n",
        "\n",
        "a != b - a not equal to b\n",
        "\n",
        "a > b - a greater than b\n",
        "\n",
        "a >= b - a greater than or equal to b"
      ],
      "metadata": {
        "id": "3nrLugFOdNuw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Example function using comparison operations"
      ],
      "metadata": {
        "id": "LVSLnM8idooD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def can_run_for_president(age):\n",
        "  \"\"\"Can someone of the given age run for president in the US?\"\"\"\n",
        "  # The US Constitution says you must be at least 35 years old\n",
        "  return age >= 35"
      ],
      "metadata": {
        "id": "zPO0YzcTdBff"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Can a 19-year-old run for president?\", can_run_for_president(19))\n",
        "print(\"Can a 45-year-old run for president?\", can_run_for_president(45))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ssk7EuoFd3m5",
        "outputId": "9df7280e-6ca2-4e38-c4ce-a5025cbd5f8d"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Can a 19-year-old run for president? False\n",
            "Can a 45-year-old run for president? True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def is_odd(n):\n",
        "  return (n % 2) == 1"
      ],
      "metadata": {
        "id": "HgY3CoaUeDQL"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Is 100 odd?\", is_odd(100))\n",
        "print(\"Is -1 odd?\", is_odd(-1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zxWucJfMemWA",
        "outputId": "18d03b06-d7ea-4bef-f01d-843e35c6520e"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Is 100 odd? False\n",
            "Is -1 odd? True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can combine boolean values to check even more conditional statements"
      ],
      "metadata": {
        "id": "uph7JKSiewdR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def can_run_for_president(age, is_natural_born_citizen):\n",
        "  \"\"\"Can someone of the given age and citizenship status run for president in the US?\"\"\"\n",
        "  return is_natural_born_citizen and (age >= 35)"
      ],
      "metadata": {
        "id": "Q7Ag7xwiesfQ"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(can_run_for_president(19, True))\n",
        "print(can_run_for_president(55, False))\n",
        "print(can_run_for_president(55, True))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6xEQCGOue-hx",
        "outputId": "48337b41-8026-4d9d-f180-9e1a008c2e98"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Conditional Statements (If-Else)"
      ],
      "metadata": {
        "id": "Gt9wsOAgfXWR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def inspect(x):\n",
        "  if x == 0:\n",
        "    print(x, \"is zero\")\n",
        "  elif x > 0:\n",
        "    print(x, \"is positive\")\n",
        "  elif x < 0:\n",
        "    print(x, \"is negative\")\n",
        "  else:\n",
        "    print(x, \"is unlike anything I've ever seen...\")"
      ],
      "metadata": {
        "id": "gVUla4X0fGmy"
      },
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "inspect(0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FXPGdC56foJJ",
        "outputId": "9478722a-1b36-4490-c899-de436ae6aa55"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 is zero\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "inspect(-15)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WqmgQqzyfpdv",
        "outputId": "41b60236-b758-4e8e-f688-cd63f6bfeabf"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-15 is negative\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Your Turn"
      ],
      "metadata": {
        "id": "k5hS6MedgDXf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "define a function called sign which takes a numerical argument and returns -1 if it's negative, 1 if it's positive, and 0 if it's 0."
      ],
      "metadata": {
        "id": "97G5y_hLgI7K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sign(num):\n",
        "  if num == 0:\n",
        "    return 0\n",
        "  elif num > 0:\n",
        "    return 1\n",
        "  else:\n",
        "    return -1"
      ],
      "metadata": {
        "id": "8cMUtHz4hFAh"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def to_smash(total_candies):\n",
        "    \"\"\"Return the number of leftover candies that must be smashed after distributing\n",
        "    the given number of candies evenly between 3 friends.\n",
        "    \n",
        "    >>> to_smash(91)\n",
        "    1\n",
        "    \"\"\"\n",
        "    if total_candies == 1:\n",
        "        candy = \"candy\"\n",
        "    else:\n",
        "        candy = \"candies\"\n",
        "    print(\"Splitting\", total_candies, candy)\n",
        "    return total_candies % 3\n",
        "\n",
        "to_smash(91)\n",
        "to_smash(1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NX2ZS25pfqdH",
        "outputId": "c842598b-9503-4fa5-8892-1a0894abbbd1"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Splitting 91 candies\n",
            "Splitting 1 candy\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this problem we'll be working with a simplified version of blackjack (aka twenty-one). In this version there is one player (who you'll control) and a dealer. Play proceeds as follows:\n",
        "\n",
        "The player is dealt two face-up cards. The dealer is dealt one face-up card.\n",
        "The player may ask to be dealt another card ('hit') as many times as they wish. If the sum of their cards exceeds 21, they lose the round immediately.\n",
        "The dealer then deals additional cards to himself until either:\n",
        "the sum of the dealer's cards exceeds 21, in which case the player wins the round\n",
        "the sum of the dealer's cards is greater than or equal to 17. If the player's total is greater than the dealer's, the player wins. Otherwise, the dealer wins (even in case of a tie).\n",
        "When calculating the sum of cards, Jack, Queen, and King count for 10. Aces can count as 1 or 11 (when referring to a player's \"total\" above, we mean the largest total that can be made without exceeding 21. So e.g. A+8 = 19, A+8+8 = 17)\n",
        "\n",
        "For this problem, you'll write a function representing the player's decision-making strategy in this game. We've provided a very unintelligent implementation below:"
      ],
      "metadata": {
        "id": "Y-o2tacygvWi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def should_hit(dealer_total, player_total, player_low_aces, player_high_aces):\n",
        "    \"\"\"Return True if the player should hit (request another card) given the current game\n",
        "    state, or False if the player should stay.\n",
        "    When calculating a hand's total value, we count aces as \"high\" (with value 11) if doing so\n",
        "    doesn't bring the total above 21, otherwise we count them as low (with value 1). \n",
        "    For example, if the player's hand is {A, A, A, 7}, we will count it as 11 + 1 + 1 + 7,\n",
        "    and therefore set player_total=20, player_low_aces=2, player_high_aces=1.\n",
        "    \"\"\"\n",
        "    return (player_total < 17) or (player_total < dealer_total) "
      ],
      "metadata": {
        "id": "1tKSSvvdgTcJ"
      },
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Lists"
      ],
      "metadata": {
        "id": "-6l06a3yjj7n"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lists can be numeric:"
      ],
      "metadata": {
        "id": "F7jb9zGNjqwK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "primes = [2, 3, 5, 7]"
      ],
      "metadata": {
        "id": "T44zSzwxjknb"
      },
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lists can be strings:"
      ],
      "metadata": {
        "id": "cjcOEAdcjvQT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "planets = [\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\", \"Uranus\", \"Neptune\"]"
      ],
      "metadata": {
        "id": "w_N_-2S4jt_r"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lists can be made of lists!"
      ],
      "metadata": {
        "id": "4_jg8orqj49M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hands = [\n",
        "         ['J', 'Q', 'K'],\n",
        "         ['2', '2', '2'],\n",
        "         ['6', 'A', 'K'],\n",
        "]"
      ],
      "metadata": {
        "id": "bTeNpUXTj3Sj"
      },
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lists can contain a mix of different things"
      ],
      "metadata": {
        "id": "Ryrp7FErkLBz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_favorite_things = [32, \"raindrops on roses\", help]"
      ],
      "metadata": {
        "id": "igvgkqyqkFXb"
      },
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We use indexing to access individual elements from a list"
      ],
      "metadata": {
        "id": "GlZcYq0KkSPS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "planets[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "X_QI3iFRkP5b",
        "outputId": "eb949a84-b3ad-4198-cc55-efbf0e0ae703"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Mercury'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "planets[-1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "YzMIRqEbkVSj",
        "outputId": "96e22b27-a9aa-4276-9980-5534581549fa"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Neptune'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use slicing to access groups of elements from a list"
      ],
      "metadata": {
        "id": "75hvKvNqkZwu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "planets[0:3]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eRoGL3JZkXgj",
        "outputId": "f167da5c-d9d7-4e40-a363-b24522ed6aaf"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Mercury', 'Venus', 'Earth']"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "planets[:3]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8qHPcY5kkdTT",
        "outputId": "5d69dcad-95c8-4560-fce0-337f0e136a51"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Mercury', 'Venus', 'Earth']"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "planets[3:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pjIZKs1ZkfTT",
        "outputId": "5fcc5636-86b3-4367-c399-6265d6ea6c65"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "planets[1:-1]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eNzhrSlykg5D",
        "outputId": "192bb941-9442-453e-f142-59b6f680d952"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus']"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "planets[-3:]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RkzUvFKnkj1r",
        "outputId": "f98c96bc-5bd9-4326-9be6-5def41f24e72"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Saturn', 'Uranus', 'Neptune']"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can change individual items in a list"
      ],
      "metadata": {
        "id": "l_GO2uvekpF1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(planets)\n",
        "planets[3] = \"Malacandra\"\n",
        "print(planets)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AW67hsBPkmyj",
        "outputId": "56e26839-9c51-439f-dc57-09c56369657e"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
            "['Mercury', 'Venus', 'Earth', 'Malacandra', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lists have their own functions as well!"
      ],
      "metadata": {
        "id": "zF-Ss1D0k2pq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# We can find the length of a list\n",
        "len(planets)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "787SlnrpkvyL",
        "outputId": "55c52400-a031-4b91-b85a-2890ef3a55ee"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can sort a list\n",
        "print(planets)\n",
        "print(sorted(planets))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hPcLN25sk7Rz",
        "outputId": "5dc99e01-0ced-44e4-faf5-34efabc784be"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Mercury', 'Venus', 'Earth', 'Malacandra', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
            "['Earth', 'Jupiter', 'Malacandra', 'Mercury', 'Neptune', 'Saturn', 'Uranus', 'Venus']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can sum up a list of numbers\n",
        "primes = [2, 3, 5, 7]\n",
        "sum(primes)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vsP6ko0jlBiz",
        "outputId": "be13dfda-17da-42c1-b0d0-c9d6764e0ddd"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "17"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can find the max number in a list of numbers\n",
        "max(primes)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OR4ujdyglLkk",
        "outputId": "fd7d561d-099c-4060-b861-7c1d92024ded"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "wF53h_UBllO7"
      },
      "execution_count": 54,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Loops and List Comprehension"
      ],
      "metadata": {
        "id": "pfD6rn6fzVJz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can use loops to repeatedly execute code"
      ],
      "metadata": {
        "id": "fG3diwR8zbgJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
        "for planet in planets:\n",
        "  print(planet, end=' ') # print all on same line"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C7YqL0aLzX7A",
        "outputId": "c29a3eca-af48-451c-9508-ba11ae11db90"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Loops can be used for iteration as well!"
      ],
      "metadata": {
        "id": "esylBlfwzst1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "multiplicands = (2, 2, 2, 3, 3, 5)\n",
        "product = 1\n",
        "for mult in multiplicands:\n",
        "  product = product * mult\n",
        "product"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MeFg0krNzlnW",
        "outputId": "f42e2e1c-3649-4157-8e07-4f7dbef35348"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "360"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can use loops to loop through each character in a string"
      ],
      "metadata": {
        "id": "zCAGLqvaz6zU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = 'steganograpHy is the practicE of conceaLing a file, message, image, or video within another fiLe, message, image, Or video.'\n",
        "msg = ''\n",
        "# print all the upercase letters in s, one at a time\n",
        "for char in s:\n",
        "  if char.isupper():\n",
        "    print(char, end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FrtfFERLz5AO",
        "outputId": "64317024-8e8b-4f1b-e026-330c0cdf0615"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "HELLO"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use a range to determine sequence of numbers"
      ],
      "metadata": {
        "id": "Q_TyYaDZ0L84"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(5):\n",
        "  print(\"Doing important work. i =\", i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qGQtzn_20HBY",
        "outputId": "6996698f-5e66-4dd8-a023-284ec3137ad6"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Doing important work. i = 0\n",
            "Doing important work. i = 1\n",
            "Doing important work. i = 2\n",
            "Doing important work. i = 3\n",
            "Doing important work. i = 4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "While loops can be used to iterate through code repeatedly until a condition is met"
      ],
      "metadata": {
        "id": "_d0Ra1OO0VUd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "i = 0\n",
        "while i < 10:\n",
        "  print(i, end=' ')\n",
        "  i += 1 #increase the value of i by 1 or our code will run forever"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NuNz1vlV0Tw2",
        "outputId": "4b6f0bb5-8bcf-439b-89fb-e2e01b108202"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 1 2 3 4 5 6 7 8 9 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here are some list comprehension examples now!"
      ],
      "metadata": {
        "id": "7gHUNBuD0krX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "squares = [n**2 for n in range(10)]\n",
        "squares"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xAHPFd1s0f5-",
        "outputId": "1dd4da8a-e28b-4e0e-8cda-e7a065bcaafe"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "List comprehension with an if condition!"
      ],
      "metadata": {
        "id": "WuJWZBS40tkh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "short_planets = [planet for planet in planets if len(planet) < 6]\n",
        "short_planets"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cG1THYPD0qCO",
        "outputId": "6edb6e9f-1370-4592-cca9-d0e6a4dcafdf"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Venus', 'Earth', 'Mars']"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "List comprehension with some if condition filtering and some transformation"
      ],
      "metadata": {
        "id": "7Izy5jBY05sZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# str.upper() returns an all-caps version of a string\n",
        "loud_short_planets = [planet.upper() + '!' for planet in planets if len(planet) < 6]\n",
        "loud_short_planets"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7tmNKLxw00x9",
        "outputId": "8f2b32f2-b058-4abe-ac7f-8ab2bf34db37"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['VENUS!', 'EARTH!', 'MARS!']"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Your Turn"
      ],
      "metadata": {
        "id": "MTGNWl451aHf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def has_lucky_number(nums):\n",
        "    \"\"\"Return whether the given list of numbers is lucky. A lucky list contains\n",
        "    at least one number divisible by 7.\"\"\"\n",
        "    for num in nums:\n",
        "      if num % 7 == 0:\n",
        "        return True\n",
        "    \n",
        "    return False\n",
        "\n",
        "nums1 = [0, 1, 2, 3, 4, 5, 6, 8]\n",
        "nums2 = [234, 1234, 75346, 12345, 8356]\n",
        "nums3 = [2134, 623465, 87456, 7, 324]\n",
        "print(has_lucky_number(nums1))\n",
        "print(has_lucky_number(nums2))\n",
        "print(has_lucky_number(nums3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NdRvvQF_1GLv",
        "outputId": "3cb82f60-e2e5-41c0-dab1-b2f4dffa24ea"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Run the code below to see what happens"
      ],
      "metadata": {
        "id": "yw1bK0BW1wyd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "[1, 2, 3, 4] > 2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 165
        },
        "id": "Sfh7eTJz1vPd",
        "outputId": "efe580d0-eb4f-4c75-c630-26d1a627ec88"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-64-6f064fcfe2b9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \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;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: '>' not supported between instances of 'list' and 'int'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def elementwise_greater_than(L, thresh):\n",
        "    \"\"\"Return a list with the same length as L, where the value at index i is \n",
        "    True if L[i] is greater than thresh, and False otherwise.\n",
        "    \n",
        "    >>> elementwise_greater_than([1, 2, 3, 4], 2)\n",
        "    [False, False, True, True]\n",
        "    \"\"\"\n",
        "    isGreaterThan = []\n",
        "    for i in range(len(L)):\n",
        "      if L[i] > thresh:\n",
        "        isGreaterThan.append(True)\n",
        "      else:\n",
        "        isGreaterThan.append(False)\n",
        "    return isGreaterThan\n",
        "\n",
        "print(elementwise_greater_than([1, 2, 3, 4], 2))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "406hd1fo119g",
        "outputId": "0f413024-92f1-4aac-c3eb-d60e09eab5ec"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[False, False, True, True]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def menu_is_boring(meals):\n",
        "    \"\"\"Given a list of meals served over some period of time, return True if the\n",
        "    same meal has ever been served two days in a row, and False otherwise.\n",
        "    \"\"\"\n",
        "    for i in range(len(meals) - 1):\n",
        "      if meals[i] == meals[i+1]:\n",
        "        return True\n",
        "\n",
        "    return False\n",
        "\n",
        "menu_is_boring([\"Cottage Cheese\", \"Pancakes\", \"Pancakes\", \"Sausage\", \"Eggs\", \"Brownie\", \"Cake\"])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lUerYEl-15II",
        "outputId": "b0fa054e-b5c1-41c1-946e-94bc46b7eed4"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "def play_slot_machine():\n",
        "  result = random.randrange(1, 10000)\n",
        "  if result < 10:\n",
        "    return 1\n",
        "  elif result < 5:\n",
        "    return 10\n",
        "  elif result == 1:\n",
        "    return 100\n",
        "  else:\n",
        "    return 0"
      ],
      "metadata": {
        "id": "8aILU7fb5Z3Y"
      },
      "execution_count": 67,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def estimate_average_slot_payout(n_runs):\n",
        "    \"\"\"Run the slot machine n_runs times and return the average net profit per run.\n",
        "    Example calls (note that return value is nondeterministic!):\n",
        "    >>> estimate_average_slot_payout(1)\n",
        "    -1\n",
        "    >>> estimate_average_slot_payout(1)\n",
        "    0.5\n",
        "    \"\"\"\n",
        "    net_total = 0\n",
        "    for _ in range(n_runs):\n",
        "      net_total -= 1\n",
        "      net_total += play_slot_machine()\n",
        "    return net_total/n_runs\n",
        "\n",
        "estimate_average_slot_payout(999999)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dzh5EnsQ19X6",
        "outputId": "7274bcc0-502c-4a13-de72-2b82f332feef"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-0.9990629990629991"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Strings and Dictionaries"
      ],
      "metadata": {
        "id": "0GJgqlZa-at9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The backslash character is used as an escape sequence allowing the program to ignore what would otherwise be an important symbol"
      ],
      "metadata": {
        "id": "XaXiCnrxGrDj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('what\\'s up?') # \\'\n",
        "print(\"That's \\\"cool\\\"\") # \\\"\n",
        "print(\"Look, a mountain: /\\\\\") # \\\\\n",
        "print(\"1\\n2 3\") # \\n"
      ],
      "metadata": {
        "id": "GMooYcFe6b4H",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "64a0b4c6-4c54-491a-ca58-779aff010666"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "what's up?\n",
            "That's \"cool\"\n",
            "Look, a mountain: /\\\n",
            "1\n",
            "2 3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "hello = \"hello\\nworld\"\n",
        "print(hello)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HFUNGJbMHHJB",
        "outputId": "e30067b7-77df-406b-a11d-3b707fb53c09"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n",
            "world\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Triple quote strings allow us to use newlines literally - by pressing enter on the keybaord"
      ],
      "metadata": {
        "id": "4lSW6uY6HXf1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "triplequoted_hello = \"\"\"hello\n",
        "world\"\"\"\n",
        "print(triplequoted_hello)\n",
        "triplequoted_hello == hello"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DSdi4l_tHTjy",
        "outputId": "cb9af748-71c2-4925-d21c-f1b561cc8dfe"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n",
            "world\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The print function automatically creates a newline character unless we specify a value for the end keyword argument"
      ],
      "metadata": {
        "id": "RAx2oMOdKBcV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"hello\")\n",
        "print(\"world\")\n",
        "print(\"hello\", end='')\n",
        "print(\"pluto\", end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1d5f6kkuHi2y",
        "outputId": "e83c2e47-a9d0-4b87-df6c-600b6526f008"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n",
            "world\n",
            "hellopluto"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Strings contain methods much like lists do."
      ],
      "metadata": {
        "id": "GxZ1zCXSKTkZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# We can uppercase the whole string\n",
        "claim = \"Pluto is a planet!\"\n",
        "print(claim)\n",
        "claim.upper()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "JNsJN__gKNKe",
        "outputId": "c1e2cb22-c1f2-4e8c-98e7-eb4cc413cbbd"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Pluto is a planet!\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'PLUTO IS A PLANET!'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can lowercase the whole string\n",
        "print(claim)\n",
        "claim.lower()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "hGSOWUG5Kej1",
        "outputId": "c4606f68-78c2-47e6-94f8-e3e65c78f6ab"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Pluto is a planet!\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'pluto is a planet!'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can search a string for the first index of an ocurring substring"
      ],
      "metadata": {
        "id": "ORppQjqbL-xp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "claim.index('plan') \n",
        "# the substring 'plan' starts at index 11 of claim and goes to index 14"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3BCaqWPAKlgt",
        "outputId": "ca0318e8-4038-408b-b2ac-945b93988228"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can check to see if the claim string starts with the value of planet\n",
        "planet = \"Pluto\"\n",
        "print(planet)\n",
        "claim.startswith(planet)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bpq9ZCUnME3r",
        "outputId": "36f36b27-7247-4313-c7a9-6f27922ee35e"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Pluto\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can check if the string ends with a particular substring\n",
        "print(claim.endswith('planet'))\n",
        "# Note this is false because it does not include the exclamation mark\n",
        "print(claim.endswith('planet!'))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mDs_bH36MegR",
        "outputId": "f7a99b81-5073-4991-f5ef-bca606ac02a9"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can split a string up into seperate parts and create a list out of those parts"
      ],
      "metadata": {
        "id": "nc1Img3-ND2h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "words = claim.split()\n",
        "words"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3wyjJhklM_oM",
        "outputId": "e6c26ef5-e5bd-4e23-ada8-8e8826d85c32"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Pluto', 'is', 'a', 'planet!']"
            ]
          },
          "metadata": {},
          "execution_count": 78
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can also choose to split on something other than whitespace, which is the default"
      ],
      "metadata": {
        "id": "kZwcIDr2NL0e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "datestr = '1056-01-31'\n",
        "year, month, day = datestr.split('-')\n",
        "print(year, month, day)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nrximcNZNKS6",
        "outputId": "370f8128-22b0-40e6-8b16-99763707eccd"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1056 01 31\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use the join method to join a list of strings together to make one longer string"
      ],
      "metadata": {
        "id": "h83jvUOGNX-0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'/'.join([month, day, year])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "A_g9I2DMNVhk",
        "outputId": "6ef6b7b8-cfd0-456f-9189-f712b3421541"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'01/31/1056'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can format our strings"
      ],
      "metadata": {
        "id": "baPqj4dvNsNU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# We can concatenate strings together\n",
        "planet + ', we miss you.'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "C7FExfMuNgRc",
        "outputId": "1b969243-611a-4530-e3e5-f1ff51ed696a"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Pluto, we miss you.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We have to make sure when we are concatenating that all content is of the string type\n",
        "position = 9\n",
        "planet + \", you'll always be the \" + str(position) + \"th planet to me.\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "eXgk7AKINww7",
        "outputId": "acf36857-c6eb-44f1-f5bb-b07506f7962d"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"Pluto, you'll always be the 9th planet to me.\""
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "str.format() can make formating much easier"
      ],
      "metadata": {
        "id": "PmQXwdC-ODB_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"{}, you'll always be the {}th planet to me.\".format(planet, position)\n",
        "# Note the position of the brackets must be in the same order as the variables we want to format into the string"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "d2z05AxEN_Ys",
        "outputId": "31928a0d-53ac-467d-e8fd-a89f959f0375"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"Pluto, you'll always be the 9th planet to me.\""
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Here's a better look into what .format() can do\n",
        "pluto_mass = 1.303 * 10**22\n",
        "earth_mass = 5.9722 * 10**24\n",
        "population = 52910390\n",
        "#         2 decimal points    3 decimal points, format as percent      Seperate with commas\n",
        "\"{} weighs about {:.2} kilograms ({:.3%} of Earth's mass). It is home to {:,} Plutonians.\".format(planet, pluto_mass, pluto_mass/earth_mass, population,)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "6vOXY4ShOW7X",
        "outputId": "ee16d531-60a6-4d28-d980-69b5c1926cfd"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"Pluto weighs about 1.3e+22 kilograms (0.218% of Earth's mass). It is home to 52,910,390 Plutonians.\""
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can specify the format() arguments using their index\n",
        "s = \"\"\"Pluto's a {0}.\n",
        "No, it's a {1}.\n",
        "{0}!\n",
        "{1}!\"\"\".format('planet', 'dwarf planet')\n",
        "print(s)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aYF6XThSPEj7",
        "outputId": "0f238606-7021-4b41-e633-64a70bd09470"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Pluto's a planet.\n",
            "No, it's a dwarf planet.\n",
            "planet!\n",
            "dwarf planet!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Dictionaries\n",
        "These are structures that are used to map keys to values"
      ],
      "metadata": {
        "id": "BNx38SZUPkUj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "numbers = {'one':1, 'two':2, 'three':3}\n",
        "# 'one', 'two', and 'three' are the keys and 1, 2, and 3 are the values"
      ],
      "metadata": {
        "id": "jCYljUmZPfe5"
      },
      "execution_count": 86,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "numbers['one']\n",
        "# We search for the value of the 'one' key"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mW-FnQZgPtWq",
        "outputId": "de0e498e-713b-408c-9746-f7864817562b"
      },
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can add a new key, value pair using the same syntax\n",
        "numbers['eleven'] = 11\n",
        "numbers"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9MiOJrmNP1Z8",
        "outputId": "5e826953-4539-4d5e-aa9f-be103385be0a"
      },
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'eleven': 11, 'one': 1, 'three': 3, 'two': 2}"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# We can also change the value associated with an existing key\n",
        "numbers['one'] = 'Pluto'\n",
        "numbers"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C6qlLLQLQDG7",
        "outputId": "a590795d-f2c6-4e5c-e408-f8e86f298a3d"
      },
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'eleven': 11, 'one': 'Pluto', 'three': 3, 'two': 2}"
            ]
          },
          "metadata": {},
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "With dictionaries we can use dictionary comprehension just like list comprehension!"
      ],
      "metadata": {
        "id": "9RFhx36rQWe9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
        "planet_to_initial = {planet: planet[0] for planet in planets}\n",
        "planet_to_initial"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2QKrUAURQJZb",
        "outputId": "9985a74f-ac18-4427-898b-8060f1feb117"
      },
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Earth': 'E',\n",
              " 'Jupiter': 'J',\n",
              " 'Mars': 'M',\n",
              " 'Mercury': 'M',\n",
              " 'Neptune': 'N',\n",
              " 'Saturn': 'S',\n",
              " 'Uranus': 'U',\n",
              " 'Venus': 'V'}"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use the in operator to see if something is a key in a dictionary"
      ],
      "metadata": {
        "id": "7tyCkstmQxfA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'Saturn' in planet_to_initial"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Iw8yP4bXQsiJ",
        "outputId": "6061d500-a508-4d0c-8572-acc3fe1bf1c7"
      },
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'Betelgeuse' in planet_to_initial"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C9SFY17BQ2CU",
        "outputId": "1d7f4e7c-a207-4bb0-e99a-9838ae4a7c04"
      },
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use a for loop to loop over a dictionary's keys"
      ],
      "metadata": {
        "id": "w_RH-qGJQ6L5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for k in numbers:\n",
        "  print(\"{} = {}\".format(k, numbers[k]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5qeFY4mIQ4vt",
        "outputId": "13193200-6c35-4d18-d1d9-7470aa457f77"
      },
      "execution_count": 93,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "one = Pluto\n",
            "two = 2\n",
            "three = 3\n",
            "eleven = 11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can access the entire collection of keys or values of a dictionary using dict.keys() and dict.values()"
      ],
      "metadata": {
        "id": "HZHWWeDHRGif"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Get all the initials, sort them alphabetically, and put them in a space-seperated string\n",
        "' '.join(sorted(planet_to_initial.values()))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "icojglP0RCI9",
        "outputId": "66d13c42-5205-416a-d013-676767482a58"
      },
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'E J M M N S U V'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can use dict.items() to iterate over both the keys AND values of a dictionary simultaneously"
      ],
      "metadata": {
        "id": "lAwQvIHYRXNh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Notice we have to include two variables when using .items()\n",
        "# The first variable always correlates to the key\n",
        "# The second variable always correlates to the value\n",
        "for planet, initial in planet_to_initial.items():\n",
        "  print(\"{} begins with \\\"{}\\\"\".format(planet.rjust(10), initial))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f4-92MN0RUJ_",
        "outputId": "1792cc57-d311-4064-9ca5-e3236643b50c"
      },
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   Mercury begins with \"M\"\n",
            "     Venus begins with \"V\"\n",
            "     Earth begins with \"E\"\n",
            "      Mars begins with \"M\"\n",
            "   Jupiter begins with \"J\"\n",
            "    Saturn begins with \"S\"\n",
            "    Uranus begins with \"U\"\n",
            "   Neptune begins with \"N\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Your Turn"
      ],
      "metadata": {
        "id": "Q6g54PlHR8rf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "There is a saying that \"Data scientists spend 80% of their time cleaning data, and 20% of their time complaining about cleaning data.\" Let's see if you can write a function to help clean US zip code data. Given a string, it should return whether or not that string represents a valid zip code. For our purposes, a valid zip code is any string consisting of exactly 5 digits."
      ],
      "metadata": {
        "id": "IjPsU0ULSInF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "help(str)"
      ],
      "metadata": {
        "id": "U0MQdBiYSNbz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "79930863-2e29-44b0-aecd-472ffbf0705b"
      },
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on class str in module builtins:\n",
            "\n",
            "class str(object)\n",
            " |  str(object='') -> str\n",
            " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
            " |  \n",
            " |  Create a new string object from the given object. If encoding or\n",
            " |  errors is specified, then the object must expose a data buffer\n",
            " |  that will be decoded using the given encoding and error handler.\n",
            " |  Otherwise, returns the result of object.__str__() (if defined)\n",
            " |  or repr(object).\n",
            " |  encoding defaults to sys.getdefaultencoding().\n",
            " |  errors defaults to 'strict'.\n",
            " |  \n",
            " |  Methods defined here:\n",
            " |  \n",
            " |  __add__(self, value, /)\n",
            " |      Return self+value.\n",
            " |  \n",
            " |  __contains__(self, key, /)\n",
            " |      Return key in self.\n",
            " |  \n",
            " |  __eq__(self, value, /)\n",
            " |      Return self==value.\n",
            " |  \n",
            " |  __format__(self, format_spec, /)\n",
            " |      Return a formatted version of the string as described by format_spec.\n",
            " |  \n",
            " |  __ge__(self, value, /)\n",
            " |      Return self>=value.\n",
            " |  \n",
            " |  __getattribute__(self, name, /)\n",
            " |      Return getattr(self, name).\n",
            " |  \n",
            " |  __getitem__(self, key, /)\n",
            " |      Return self[key].\n",
            " |  \n",
            " |  __getnewargs__(...)\n",
            " |  \n",
            " |  __gt__(self, value, /)\n",
            " |      Return self>value.\n",
            " |  \n",
            " |  __hash__(self, /)\n",
            " |      Return hash(self).\n",
            " |  \n",
            " |  __iter__(self, /)\n",
            " |      Implement iter(self).\n",
            " |  \n",
            " |  __le__(self, value, /)\n",
            " |      Return self<=value.\n",
            " |  \n",
            " |  __len__(self, /)\n",
            " |      Return len(self).\n",
            " |  \n",
            " |  __lt__(self, value, /)\n",
            " |      Return self<value.\n",
            " |  \n",
            " |  __mod__(self, value, /)\n",
            " |      Return self%value.\n",
            " |  \n",
            " |  __mul__(self, value, /)\n",
            " |      Return self*value.\n",
            " |  \n",
            " |  __ne__(self, value, /)\n",
            " |      Return self!=value.\n",
            " |  \n",
            " |  __repr__(self, /)\n",
            " |      Return repr(self).\n",
            " |  \n",
            " |  __rmod__(self, value, /)\n",
            " |      Return value%self.\n",
            " |  \n",
            " |  __rmul__(self, value, /)\n",
            " |      Return value*self.\n",
            " |  \n",
            " |  __sizeof__(self, /)\n",
            " |      Return the size of the string in memory, in bytes.\n",
            " |  \n",
            " |  __str__(self, /)\n",
            " |      Return str(self).\n",
            " |  \n",
            " |  capitalize(self, /)\n",
            " |      Return a capitalized version of the string.\n",
            " |      \n",
            " |      More specifically, make the first character have upper case and the rest lower\n",
            " |      case.\n",
            " |  \n",
            " |  casefold(self, /)\n",
            " |      Return a version of the string suitable for caseless comparisons.\n",
            " |  \n",
            " |  center(self, width, fillchar=' ', /)\n",
            " |      Return a centered string of length width.\n",
            " |      \n",
            " |      Padding is done using the specified fill character (default is a space).\n",
            " |  \n",
            " |  count(...)\n",
            " |      S.count(sub[, start[, end]]) -> int\n",
            " |      \n",
            " |      Return the number of non-overlapping occurrences of substring sub in\n",
            " |      string S[start:end].  Optional arguments start and end are\n",
            " |      interpreted as in slice notation.\n",
            " |  \n",
            " |  encode(self, /, encoding='utf-8', errors='strict')\n",
            " |      Encode the string using the codec registered for encoding.\n",
            " |      \n",
            " |      encoding\n",
            " |        The encoding in which to encode the string.\n",
            " |      errors\n",
            " |        The error handling scheme to use for encoding errors.\n",
            " |        The default is 'strict' meaning that encoding errors raise a\n",
            " |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and\n",
            " |        'xmlcharrefreplace' as well as any other name registered with\n",
            " |        codecs.register_error that can handle UnicodeEncodeErrors.\n",
            " |  \n",
            " |  endswith(...)\n",
            " |      S.endswith(suffix[, start[, end]]) -> bool\n",
            " |      \n",
            " |      Return True if S ends with the specified suffix, False otherwise.\n",
            " |      With optional start, test S beginning at that position.\n",
            " |      With optional end, stop comparing S at that position.\n",
            " |      suffix can also be a tuple of strings to try.\n",
            " |  \n",
            " |  expandtabs(self, /, tabsize=8)\n",
            " |      Return a copy where all tab characters are expanded using spaces.\n",
            " |      \n",
            " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
            " |  \n",
            " |  find(...)\n",
            " |      S.find(sub[, start[, end]]) -> int\n",
            " |      \n",
            " |      Return the lowest index in S where substring sub is found,\n",
            " |      such that sub is contained within S[start:end].  Optional\n",
            " |      arguments start and end are interpreted as in slice notation.\n",
            " |      \n",
            " |      Return -1 on failure.\n",
            " |  \n",
            " |  format(...)\n",
            " |      S.format(*args, **kwargs) -> str\n",
            " |      \n",
            " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
            " |      The substitutions are identified by braces ('{' and '}').\n",
            " |  \n",
            " |  format_map(...)\n",
            " |      S.format_map(mapping) -> str\n",
            " |      \n",
            " |      Return a formatted version of S, using substitutions from mapping.\n",
            " |      The substitutions are identified by braces ('{' and '}').\n",
            " |  \n",
            " |  index(...)\n",
            " |      S.index(sub[, start[, end]]) -> int\n",
            " |      \n",
            " |      Return the lowest index in S where substring sub is found, \n",
            " |      such that sub is contained within S[start:end].  Optional\n",
            " |      arguments start and end are interpreted as in slice notation.\n",
            " |      \n",
            " |      Raises ValueError when the substring is not found.\n",
            " |  \n",
            " |  isalnum(self, /)\n",
            " |      Return True if the string is an alpha-numeric string, False otherwise.\n",
            " |      \n",
            " |      A string is alpha-numeric if all characters in the string are alpha-numeric and\n",
            " |      there is at least one character in the string.\n",
            " |  \n",
            " |  isalpha(self, /)\n",
            " |      Return True if the string is an alphabetic string, False otherwise.\n",
            " |      \n",
            " |      A string is alphabetic if all characters in the string are alphabetic and there\n",
            " |      is at least one character in the string.\n",
            " |  \n",
            " |  isascii(self, /)\n",
            " |      Return True if all characters in the string are ASCII, False otherwise.\n",
            " |      \n",
            " |      ASCII characters have code points in the range U+0000-U+007F.\n",
            " |      Empty string is ASCII too.\n",
            " |  \n",
            " |  isdecimal(self, /)\n",
            " |      Return True if the string is a decimal string, False otherwise.\n",
            " |      \n",
            " |      A string is a decimal string if all characters in the string are decimal and\n",
            " |      there is at least one character in the string.\n",
            " |  \n",
            " |  isdigit(self, /)\n",
            " |      Return True if the string is a digit string, False otherwise.\n",
            " |      \n",
            " |      A string is a digit string if all characters in the string are digits and there\n",
            " |      is at least one character in the string.\n",
            " |  \n",
            " |  isidentifier(self, /)\n",
            " |      Return True if the string is a valid Python identifier, False otherwise.\n",
            " |      \n",
            " |      Use keyword.iskeyword() to test for reserved identifiers such as \"def\" and\n",
            " |      \"class\".\n",
            " |  \n",
            " |  islower(self, /)\n",
            " |      Return True if the string is a lowercase string, False otherwise.\n",
            " |      \n",
            " |      A string is lowercase if all cased characters in the string are lowercase and\n",
            " |      there is at least one cased character in the string.\n",
            " |  \n",
            " |  isnumeric(self, /)\n",
            " |      Return True if the string is a numeric string, False otherwise.\n",
            " |      \n",
            " |      A string is numeric if all characters in the string are numeric and there is at\n",
            " |      least one character in the string.\n",
            " |  \n",
            " |  isprintable(self, /)\n",
            " |      Return True if the string is printable, False otherwise.\n",
            " |      \n",
            " |      A string is printable if all of its characters are considered printable in\n",
            " |      repr() or if it is empty.\n",
            " |  \n",
            " |  isspace(self, /)\n",
            " |      Return True if the string is a whitespace string, False otherwise.\n",
            " |      \n",
            " |      A string is whitespace if all characters in the string are whitespace and there\n",
            " |      is at least one character in the string.\n",
            " |  \n",
            " |  istitle(self, /)\n",
            " |      Return True if the string is a title-cased string, False otherwise.\n",
            " |      \n",
            " |      In a title-cased string, upper- and title-case characters may only\n",
            " |      follow uncased characters and lowercase characters only cased ones.\n",
            " |  \n",
            " |  isupper(self, /)\n",
            " |      Return True if the string is an uppercase string, False otherwise.\n",
            " |      \n",
            " |      A string is uppercase if all cased characters in the string are uppercase and\n",
            " |      there is at least one cased character in the string.\n",
            " |  \n",
            " |  join(self, iterable, /)\n",
            " |      Concatenate any number of strings.\n",
            " |      \n",
            " |      The string whose method is called is inserted in between each given string.\n",
            " |      The result is returned as a new string.\n",
            " |      \n",
            " |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n",
            " |  \n",
            " |  ljust(self, width, fillchar=' ', /)\n",
            " |      Return a left-justified string of length width.\n",
            " |      \n",
            " |      Padding is done using the specified fill character (default is a space).\n",
            " |  \n",
            " |  lower(self, /)\n",
            " |      Return a copy of the string converted to lowercase.\n",
            " |  \n",
            " |  lstrip(self, chars=None, /)\n",
            " |      Return a copy of the string with leading whitespace removed.\n",
            " |      \n",
            " |      If chars is given and not None, remove characters in chars instead.\n",
            " |  \n",
            " |  partition(self, sep, /)\n",
            " |      Partition the string into three parts using the given separator.\n",
            " |      \n",
            " |      This will search for the separator in the string.  If the separator is found,\n",
            " |      returns a 3-tuple containing the part before the separator, the separator\n",
            " |      itself, and the part after it.\n",
            " |      \n",
            " |      If the separator is not found, returns a 3-tuple containing the original string\n",
            " |      and two empty strings.\n",
            " |  \n",
            " |  replace(self, old, new, count=-1, /)\n",
            " |      Return a copy with all occurrences of substring old replaced by new.\n",
            " |      \n",
            " |        count\n",
            " |          Maximum number of occurrences to replace.\n",
            " |          -1 (the default value) means replace all occurrences.\n",
            " |      \n",
            " |      If the optional argument count is given, only the first count occurrences are\n",
            " |      replaced.\n",
            " |  \n",
            " |  rfind(...)\n",
            " |      S.rfind(sub[, start[, end]]) -> int\n",
            " |      \n",
            " |      Return the highest index in S where substring sub is found,\n",
            " |      such that sub is contained within S[start:end].  Optional\n",
            " |      arguments start and end are interpreted as in slice notation.\n",
            " |      \n",
            " |      Return -1 on failure.\n",
            " |  \n",
            " |  rindex(...)\n",
            " |      S.rindex(sub[, start[, end]]) -> int\n",
            " |      \n",
            " |      Return the highest index in S where substring sub is found,\n",
            " |      such that sub is contained within S[start:end].  Optional\n",
            " |      arguments start and end are interpreted as in slice notation.\n",
            " |      \n",
            " |      Raises ValueError when the substring is not found.\n",
            " |  \n",
            " |  rjust(self, width, fillchar=' ', /)\n",
            " |      Return a right-justified string of length width.\n",
            " |      \n",
            " |      Padding is done using the specified fill character (default is a space).\n",
            " |  \n",
            " |  rpartition(self, sep, /)\n",
            " |      Partition the string into three parts using the given separator.\n",
            " |      \n",
            " |      This will search for the separator in the string, starting at the end. If\n",
            " |      the separator is found, returns a 3-tuple containing the part before the\n",
            " |      separator, the separator itself, and the part after it.\n",
            " |      \n",
            " |      If the separator is not found, returns a 3-tuple containing two empty strings\n",
            " |      and the original string.\n",
            " |  \n",
            " |  rsplit(self, /, sep=None, maxsplit=-1)\n",
            " |      Return a list of the words in the string, using sep as the delimiter string.\n",
            " |      \n",
            " |        sep\n",
            " |          The delimiter according which to split the string.\n",
            " |          None (the default value) means split according to any whitespace,\n",
            " |          and discard empty strings from the result.\n",
            " |        maxsplit\n",
            " |          Maximum number of splits to do.\n",
            " |          -1 (the default value) means no limit.\n",
            " |      \n",
            " |      Splits are done starting at the end of the string and working to the front.\n",
            " |  \n",
            " |  rstrip(self, chars=None, /)\n",
            " |      Return a copy of the string with trailing whitespace removed.\n",
            " |      \n",
            " |      If chars is given and not None, remove characters in chars instead.\n",
            " |  \n",
            " |  split(self, /, sep=None, maxsplit=-1)\n",
            " |      Return a list of the words in the string, using sep as the delimiter string.\n",
            " |      \n",
            " |      sep\n",
            " |        The delimiter according which to split the string.\n",
            " |        None (the default value) means split according to any whitespace,\n",
            " |        and discard empty strings from the result.\n",
            " |      maxsplit\n",
            " |        Maximum number of splits to do.\n",
            " |        -1 (the default value) means no limit.\n",
            " |  \n",
            " |  splitlines(self, /, keepends=False)\n",
            " |      Return a list of the lines in the string, breaking at line boundaries.\n",
            " |      \n",
            " |      Line breaks are not included in the resulting list unless keepends is given and\n",
            " |      true.\n",
            " |  \n",
            " |  startswith(...)\n",
            " |      S.startswith(prefix[, start[, end]]) -> bool\n",
            " |      \n",
            " |      Return True if S starts with the specified prefix, False otherwise.\n",
            " |      With optional start, test S beginning at that position.\n",
            " |      With optional end, stop comparing S at that position.\n",
            " |      prefix can also be a tuple of strings to try.\n",
            " |  \n",
            " |  strip(self, chars=None, /)\n",
            " |      Return a copy of the string with leading and trailing whitespace removed.\n",
            " |      \n",
            " |      If chars is given and not None, remove characters in chars instead.\n",
            " |  \n",
            " |  swapcase(self, /)\n",
            " |      Convert uppercase characters to lowercase and lowercase characters to uppercase.\n",
            " |  \n",
            " |  title(self, /)\n",
            " |      Return a version of the string where each word is titlecased.\n",
            " |      \n",
            " |      More specifically, words start with uppercased characters and all remaining\n",
            " |      cased characters have lower case.\n",
            " |  \n",
            " |  translate(self, table, /)\n",
            " |      Replace each character in the string using the given translation table.\n",
            " |      \n",
            " |        table\n",
            " |          Translation table, which must be a mapping of Unicode ordinals to\n",
            " |          Unicode ordinals, strings, or None.\n",
            " |      \n",
            " |      The table must implement lookup/indexing via __getitem__, for instance a\n",
            " |      dictionary or list.  If this operation raises LookupError, the character is\n",
            " |      left untouched.  Characters mapped to None are deleted.\n",
            " |  \n",
            " |  upper(self, /)\n",
            " |      Return a copy of the string converted to uppercase.\n",
            " |  \n",
            " |  zfill(self, width, /)\n",
            " |      Pad a numeric string with zeros on the left, to fill a field of the given width.\n",
            " |      \n",
            " |      The string is never truncated.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Static methods defined here:\n",
            " |  \n",
            " |  __new__(*args, **kwargs) from builtins.type\n",
            " |      Create and return a new object.  See help(type) for accurate signature.\n",
            " |  \n",
            " |  maketrans(x, y=None, z=None, /)\n",
            " |      Return a translation table usable for str.translate().\n",
            " |      \n",
            " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
            " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
            " |      Character keys will be then converted to ordinals.\n",
            " |      If there are two arguments, they must be strings of equal length, and\n",
            " |      in the resulting dictionary, each character in x will be mapped to the\n",
            " |      character at the same position in y. If there is a third argument, it\n",
            " |      must be a string, whose characters will be mapped to None in the result.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def is_valid_zip(zip_code):\n",
        "    \"\"\"Returns whether the input string is a valid (5 digit) zip code\n",
        "    \"\"\"\n",
        "    return (zip_code.isnumeric()) and (len(zip_code) == 5)"
      ],
      "metadata": {
        "id": "XP3XbA-qRsxX"
      },
      "execution_count": 97,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "is_valid_zip('84044')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IXamZDyCS6om",
        "outputId": "6fbc2c61-ae61-46f7-997c-812f5f9f87b1"
      },
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 98
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "is_valid_zip('A234')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fqrz6sZ-S6gC",
        "outputId": "fa0e64e4-3cfb-4033-ea6b-09492ccd7145"
      },
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 99
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A researcher has gathered thousands of news articles. But she wants to focus her attention on articles including a specific word. Complete the function below to help her filter her list of articles.\n",
        "\n",
        "Your function should meet the following criteria:\n",
        "\n",
        "Do not include documents where the keyword string shows up only as a part of a larger word. For example, if she were looking for the keyword “closed”, you would not include the string “enclosed.”\n",
        "She does not want you to distinguish upper case from lower case letters. So the phrase “Closed the case.” would be included when the keyword is “closed”\n",
        "Do not let periods or commas affect what is matched. “It is closed.” would be included when the keyword is “closed”. But you can assume there are no other types of punctuation."
      ],
      "metadata": {
        "id": "LoV-ZcbMSRhy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def word_search(doc_list, keyword):\n",
        "    \"\"\"\n",
        "    Takes a list of documents (each document is a string) and a keyword. \n",
        "    Returns list of the index values into the original list for all documents \n",
        "    containing the keyword.\n",
        "\n",
        "    Example:\n",
        "    doc_list = [\"The Learn Python Challenge Casino.\", \"They bought a car\", \"Casinoville\"]\n",
        "    >>> word_search(doc_list, 'casino')\n",
        "    >>> [0]\n",
        "    \"\"\"\n",
        "    index_list = []\n",
        "    for i in range(len(doc_list)):\n",
        "      if keyword in doc_list[i] or keyword.capitalize() in doc_list[i]:\n",
        "        temp_list = doc_list[i].split()\n",
        "        for word in temp_list:\n",
        "          word = word.strip(',').strip('.')\n",
        "          if word.lower() == keyword:\n",
        "            index_list.append(i)\n",
        "            break\n",
        "    \n",
        "    return index_list"
      ],
      "metadata": {
        "id": "-GP7pUhVSSIE"
      },
      "execution_count": 100,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "doc_list = [\"The Learn Python Challenge Casino.\", \"They bought a car\", \"Casinoville\"]\n",
        "word_search(doc_list, 'casino')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HPXz3fx2TuXy",
        "outputId": "ff66520c-60b9-44b6-ccf7-cacdbaa2d19b"
      },
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0]"
            ]
          },
          "metadata": {},
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "doc_list = [\"The Learn Python Challenge Casino.\", \"They bought a car from the casino\", \"Casinoville\"]\n",
        "word_search(doc_list, 'casino')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_UgihNKhT6vf",
        "outputId": "f7435b74-961c-435e-a4e2-c03a283a1166"
      },
      "execution_count": 102,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1]"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now the researcher wants to supply multiple keywords to search for. Complete the function below to help her.\n",
        "\n",
        "(You're encouraged to use the word_search function you just wrote when implementing this function. Reusing code in this way makes your programs more robust and readable - and it saves typing!)"
      ],
      "metadata": {
        "id": "AZ4KUCIBSVcv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def multi_word_search(doc_list, keywords):\n",
        "    \"\"\"\n",
        "    Takes list of documents (each document is a string) and a list of keywords.  \n",
        "    Returns a dictionary where each key is a keyword, and the value is a list of indices\n",
        "    (from doc_list) of the documents containing that keyword\n",
        "\n",
        "    >>> doc_list = [\"The Learn Python Challenge Casino.\", \"They bought a car and a casino\", \"Casinoville\"]\n",
        "    >>> keywords = ['casino', 'they']\n",
        "    >>> multi_word_search(doc_list, keywords)\n",
        "    {'casino': [0, 1], 'they': [1]}\n",
        "    \"\"\"\n",
        "    key_doc_dict = {}\n",
        "    for key in keywords:\n",
        "      key_doc_dict[key] = []\n",
        "      for i in range(len(doc_list)):\n",
        "        if key in doc_list[i] or key.capitalize() in doc_list[i]:\n",
        "          temp_list = doc_list[i].split()\n",
        "          for word in temp_list:\n",
        "            word = word.strip(',').strip('.')\n",
        "            if word.lower() == key:\n",
        "              key_doc_dict[key].append(i)\n",
        "              break\n",
        "\n",
        "    return key_doc_dict"
      ],
      "metadata": {
        "id": "XsNpzGj2SXGZ"
      },
      "execution_count": 103,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "doc_list = [\"The Learn Python Challenge Casino.\", \"They bought a car and a casino\", \"Casinoville\"]\n",
        "keywords = ['casino', 'they']\n",
        "multi_word_search(doc_list, keywords)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bPMKDdncUjXH",
        "outputId": "a27251a0-94e1-4720-ec10-f068be63c9ea"
      },
      "execution_count": 104,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'casino': [0, 1], 'they': [1]}"
            ]
          },
          "metadata": {},
          "execution_count": 104
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "Q_1UWYccUqCt"
      },
      "execution_count": 104,
      "outputs": []
    }
  ]
}