Warmup_Strings.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Warmup - Strings.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bundickm/Warmup_Notebooks/blob/master/Warmup_Strings.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q01dn0uZyS9Y",
        "colab_type": "text"
      },
      "source": [
        "> *Respect the building blocks, master the fundamentals, and the potential is unlimited* -PJ Ladd\n",
        "\n",
        "Pre-lecture warm-ups are all about setting you up for success - sometimes that means code challenges, sometimes it means discussing interview questions. Today it means working on fundamentals. \n",
        "\n",
        "Read through the lecture notebook with a focus on understanding. At the end of the sections are code challenges for you to practice and reinforce what you read about. After lecture ends, a team lead will post a solution notebook (with explanations) for those exercises. \n",
        "\n",
        "Should you finish early, there is additional content at the bottom to explore. If you don't complete the notebook within the hour, don't sweat it, this notebook is meant for you to build up your knowledge and skills - you can always continue working on it after lecture or when you complete the assignment."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4sHkTPgGaXCs",
        "colab_type": "text"
      },
      "source": [
        "# Strings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OhuBkBPDa6s0",
        "colab_type": "text"
      },
      "source": [
        "## Basics"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ITOzcSQleAjc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "company = 'Acme'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kQH33g80bUdw",
        "colab_type": "text"
      },
      "source": [
        "We can verify we are dealing with a string using the `type` function. This is can be helpful when dealing with items we expect to be a certain data type or when an item looks like it should be another data type (Example: `'5' does not equal 5`)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wq_pCpsjbcJ-",
        "colab_type": "code",
        "outputId": "1cfd1eaf-a0dd-47aa-fa16-5e4f0a95ab62",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "type(company)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i0z6WqZzb3oV",
        "colab_type": "code",
        "outputId": "bd158b9a-d6fb-4ab9-85a5-252c9d91259b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "type('5') == type(5)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tponPtt-fwK-",
        "colab_type": "text"
      },
      "source": [
        "So what is a string? Strings are a sequence of characters and the individual characters can be referenced with the bracket operator and the characters index number."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "INoWXzXTd-Hy",
        "colab_type": "code",
        "outputId": "ff020261-a655-4b80-d8d5-6d028afb7cb4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "company[2]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'m'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IduopPGXg6sH",
        "colab_type": "text"
      },
      "source": [
        "You can count the index number from left to right like above, or you can work backwards with negative index numbers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tspTse0SeIOV",
        "colab_type": "code",
        "outputId": "609f3fec-b6a8-4b03-e4e5-5e4ed493b96b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "company[-1]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'e'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6G85do7tgqUm",
        "colab_type": "text"
      },
      "source": [
        "Strings are immutable though, meaning you cannot change the characters in the string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OH4EYaC4fNXM",
        "colab_type": "code",
        "outputId": "ed77dda2-2c6d-4c73-e02b-e51d105ef959",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 172
        }
      },
      "source": [
        "company[2] = 'p'"
      ],
      "execution_count": 0,
      "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-33-3e89b006ba64>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcompany\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'p'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "861wWYEjcKsA",
        "colab_type": "text"
      },
      "source": [
        "Since we can't modify the string, what happens when we do change the string or combine two strings? On the surface it looks like we can change alter the string, under the hood though Python is making a new string in a new location. We can verify this by using the `id` function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O1NI8ajydTLf",
        "colab_type": "code",
        "outputId": "167966ae-7850-4472-e835-7c7ac8e4f7c2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "demo = 'word'\n",
        "print(\"Demo's Location in Memory:\", id(demo))\n",
        "\n",
        "demo += ' 2'\n",
        "print('Modified Demon:', demo)\n",
        "print('New location means new string:', id(demo))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Demo's Location in Memory: 140665396700024\n",
            "Modified Demon: word 2\n",
            "New location means new string: 140664847193288\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s9iEOQXUhNTM",
        "colab_type": "text"
      },
      "source": [
        "Often we need to know how long a string is, this can be done easily with the `len` operator."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OkVPMULxd-Cf",
        "colab_type": "code",
        "outputId": "19fa4b9e-f04c-4307-e40e-8b4e2cfbc4e4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "len(company)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y2gwVI6PgeQC",
        "colab_type": "text"
      },
      "source": [
        "We can loop over a string character-by-character as well."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J2EAv_RjevF5",
        "colab_type": "code",
        "outputId": "98afc9d5-638f-4b39-d50f-2f4c6d8402ba",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        }
      },
      "source": [
        "company = 'Acme'\n",
        "for char in company:\n",
        "  print(char)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A\n",
            "c\n",
            "m\n",
            "e\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dvf9Z1f_hsYP",
        "colab_type": "text"
      },
      "source": [
        "We can also combine strings with the `+` operator."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I9SwBMCHd976",
        "colab_type": "code",
        "outputId": "45e0df55-55c4-4799-85e9-ebe8e5baa5bb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "company = company + ' Corporation'\n",
        "company"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Acme Corporation'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5faj_d3VinKg",
        "colab_type": "text"
      },
      "source": [
        "Or duplicate a string or character quickly"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b0cVoYYQilA6",
        "colab_type": "code",
        "outputId": "af1d2016-8ef7-4bea-e985-a315a64f794f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'Wololo ' * 5"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Wololo Wololo Wololo Wololo Wololo '"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xrlq4FBIckP1",
        "colab_type": "text"
      },
      "source": [
        "## Slicing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dWI44A3Fctqu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "company = 'Acme Corporation'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YO-tto8UdBV9",
        "colab_type": "text"
      },
      "source": [
        "We have already seen how we can select a single character by referencing its index number (position in the string)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t7mbWA9Zcu-l",
        "colab_type": "code",
        "outputId": "7c3e2fd7-b54c-421d-b118-a0f4592f4380",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Negative index numbers allow us to count from the end to the start\n",
        "company[-1]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'n'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xQpJphLFdStL",
        "colab_type": "text"
      },
      "source": [
        "We can select multiple characters with slice notation. Simply add brackets with colons after the string.\n",
        "\n",
        "```\n",
        "'some string'[a:b:c]\n",
        "```\n",
        "\n",
        "- The number at `a` tells where to start the slice and the substring will include the character at that index location. If you don't put a value for `a`, it defaults to `0`.\n",
        "- The number at `b` tells where to end the slice and will not include that character in the substring. If you don't put a value for `b` it defaults to the end of the string.\n",
        "- The number at `c`, is the step value. A positive number indicates stepping through the string left to right, a negative number steps in reverse order. The size of the number tells us how many characters we step on - `1` means we visit 100% of the characters, `2` we visit every other character, `3` is every third character, etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZvCn0Fn3gyVi",
        "colab_type": "code",
        "outputId": "5b531670-90fa-4990-9423-fac84dc054c9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "company[::]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Acme Corporation'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MAAf4xpjcz_P",
        "colab_type": "code",
        "outputId": "b4670b80-830b-4695-a205-3a64fcf0449b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "company[:7]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Acme Co'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j05NdNUrc0GD",
        "colab_type": "code",
        "outputId": "685fe9a6-4d1b-4e90-ddc0-b3543b4cfbe0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "company[::2]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Am oprto'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1qm9m8HFfwXk",
        "colab_type": "code",
        "outputId": "ffe91e97-de5f-44fc-9198-a82bb8b57419",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "company[2:-2:1]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'me Corporati'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kU3J0m22f2QG",
        "colab_type": "code",
        "outputId": "b689352f-fe0d-4310-f0d2-db34ae07b610",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "company[-1:3:-2]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'niaorC'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "__5FqJJzf-9s",
        "colab_type": "code",
        "outputId": "5c9c80e5-7bed-470c-9438-af85f2c0fabe",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Slicing is useful for quite a bit, including easy reversal of a string\n",
        "company[::-1]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'noitaroproC emcA'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vTe0v7RZj-Ge",
        "colab_type": "text"
      },
      "source": [
        "We can also split on on spaces or any other character to easily make a list of substrings."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NsLe-7QYkFze",
        "colab_type": "code",
        "outputId": "9e84ee1c-bbec-4b6a-f9ff-ad973e61dd43",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "company.split()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Acme', 'Corporation']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2YaMHyWYkJQ0",
        "colab_type": "code",
        "outputId": "5596c18b-4da7-417a-dd3a-042fe6b843e2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "company.split('o')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Acme C', 'rp', 'rati', 'n']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nnmPZWXJe882",
        "colab_type": "text"
      },
      "source": [
        "## String Comparison"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HtOYdf5ufAO_",
        "colab_type": "text"
      },
      "source": [
        "Relational operators work on strings as well, but be careful because there is some behavior that might not expect."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BO8j-11yfLYc",
        "colab_type": "code",
        "outputId": "4c5ad00e-8ab1-4635-f0dd-3b168583b4c2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# apple is an apple\n",
        "'apple' == 'apple'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z58StBq5fzpa",
        "colab_type": "text"
      },
      "source": [
        "String comparisons are case sensitive. Using the `lower` function covered in the next section we can work around the case sensitivity."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zmn6X6icfuoP",
        "colab_type": "code",
        "outputId": "d2776767-3fc9-4ed0-96a8-086cb747272a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Apple isn't an apple\n",
        "'Apple' == 'apple'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aKUPhUSbgB6a",
        "colab_type": "text"
      },
      "source": [
        "You also might not expect \"aardvark\" to be less than \"banana\", since when we make alphabetical lists \"a\" is usually highger than \"b\"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4m54f7GsfP5b",
        "colab_type": "code",
        "outputId": "9bab89b6-a75d-4dab-aa18-cab512b3f7f6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'aardvark' > 'banana'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "InGU9-1Jgh92",
        "colab_type": "text"
      },
      "source": [
        "Under the hood Python is converting our string to numbers to make the letter-by-letter comparison. We can even see this is the case using the `ord` function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R7oVDjH9hIy4",
        "colab_type": "code",
        "outputId": "bcd43bf5-24a3-4a27-c746-a111a661388b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "# Now we see why 'a' is less than 'b' and how that ordering is done.\n",
        "print('a:', ord('a'))\n",
        "print('b:', ord('b'))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a: 97\n",
            "b: 98\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xH1t3Y1KGLWn",
        "colab_type": "text"
      },
      "source": [
        "The `is` operator also works on strings."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mmneDvz-HFC0",
        "colab_type": "code",
        "outputId": "3fe839b8-8439-4d81-8a42-6dc91010095d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'apple' is 'apple'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HkyRieG9HM38",
        "colab_type": "code",
        "outputId": "841fed57-2831-47a4-9ffc-638f3562cbb4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'Apple' is 'apple'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xtv74Dd3hnbF",
        "colab_type": "text"
      },
      "source": [
        "One last comparison we can make is using the `in` boolean operator. This takes two strings and returns True if the first one is a substring of the second one."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BuU4v5-6iKug",
        "colab_type": "code",
        "outputId": "3b827f4c-2133-4989-98a0-afead769ab36",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'nesting doll' in 'russian nesting doll'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LSgPi-7IiZ44",
        "colab_type": "code",
        "outputId": "0a4b712e-0118-49ed-dac3-3647ca8cc415",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'apple' in 'banana'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xh_7nmZsifvh",
        "colab_type": "text"
      },
      "source": [
        "You can even use the `not` boolean operator for additional readability."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FML2tybhiqEd",
        "colab_type": "code",
        "outputId": "6b960e06-5c4f-4cff-9aa2-ec4a3b18fb7d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'apple' not in 'banana'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qTwl2x-GdwAz",
        "colab_type": "text"
      },
      "source": [
        "## String Formatting"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rkeINJiDhAoR",
        "colab_type": "text"
      },
      "source": [
        "Often when we have strings, we want to print them to the screen in a particular way or combined with other data types. Python makes this easy with a host of string related [functions](https://docs.python.org/2/library/string.html) as well as [f-string formatting.](https://realpython.com/python-f-strings/)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Dnw1wWHeqeE",
        "colab_type": "code",
        "outputId": "327714a0-90d8-45ce-83b6-93cd2a20de78",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Convert other datatypes to string with typecasting\n",
        "str(5)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'5'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SWiByzI3iArj",
        "colab_type": "code",
        "outputId": "f0879a50-5d1d-46bd-c7fa-9307a3eefecd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        }
      },
      "source": [
        "# Change the case of a string easily. \n",
        "# Often we will cast a string to all one case to make comparisons easier.\n",
        "print('HELP'.lower())\n",
        "print('Me'.upper())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "help\n",
            "ME\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ILQUdy_dibN1",
        "colab_type": "code",
        "outputId": "f70d3f32-98c9-4bd0-a776-fb7ac89de29e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Capitalize the first letter of the first word\n",
        "temp = 'this is a test of the emergency broadcast system. this is a test.'\n",
        "print(temp.capitalize())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This is a test of the emergency broadcast system. this is a test.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XyT1LHNxjvmZ",
        "colab_type": "code",
        "outputId": "fca1e6d9-31e7-448d-93c7-8ea9fa1575a6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Capitalize the first letter of each word\n",
        "print(temp.title())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This Is A Test Of The Emergency Broadcast System. This Is A Test.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xo4tckdKkf1x",
        "colab_type": "text"
      },
      "source": [
        "f-string formatting allows us to combine variables and strings in an easy and readable way."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "879S-JlrkpZc",
        "colab_type": "code",
        "outputId": "fe5a43ee-cde9-4728-cadb-dee5049e8f67",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "name = 'Johnny Appleseed'\n",
        "amount = 5\n",
        "item = 'apple seeds'\n",
        "print(f'{name} has {amount} {item}.')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Johnny Appleseed has 5 apple seeds. 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2F8Spyb4lEp_",
        "colab_type": "text"
      },
      "source": [
        "f-strings are notated with an `f` before the string. Any variables you want to pass to the string are wrapped in curly braces at the location you want that value to appear at.\n",
        "\n",
        "f-strings can be stored in a variable of their own but are converted to a normal string, meaning if you change a variable that was passed to the f-string it won't alter the saved f-string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "euwEB1DXlqw5",
        "colab_type": "code",
        "outputId": "a78fdadb-ed3a-422b-817f-7a103682f402",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        }
      },
      "source": [
        "name = 'Johnny Appleseed'\n",
        "amount = 5\n",
        "item = 'apple seeds'\n",
        "sentence = f'{name} has {amount} {item}.'\n",
        "print(sentence)\n",
        "\n",
        "name = 'Jill'\n",
        "amount = 0\n",
        "print(sentence)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Johnny Appleseed has 5 apple seeds.\n",
            "Johnny Appleseed has 5 apple seeds.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aFaT5I_Jke9S",
        "colab_type": "text"
      },
      "source": [
        "## Find"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_XQ_o5v6kl1X",
        "colab_type": "text"
      },
      "source": [
        "There are times where you will want to know the location of a particular character or substring. This can be done with the `find` function. The function has 3 paremeters, but only the first (the substring to search for) is required. `find` is kind of the opposite of the bracket notation (`[]`)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OCKWM1rblVSk",
        "colab_type": "code",
        "outputId": "7984daa1-41c0-4ece-b0f1-be55c86c3349",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# find returns the index of the start of the substring, \n",
        "# in this case it is where the 'a' is located.\n",
        "'example'.find('amp')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wPlupQFij32f",
        "colab_type": "code",
        "outputId": "0d47de2a-4f82-497e-960e-9bd44727e9d6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'example'[2]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'a'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mVfRN_z7pwB_",
        "colab_type": "code",
        "outputId": "0e249b0d-aea8-438a-df50-7242356c463a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# find returns -1 if it can't find the substring\n",
        "'example'.find('not here')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D5IKVz_1pAbM",
        "colab_type": "text"
      },
      "source": [
        "What happens though when the substring we are searching for occurs mutliple times in the string we are searching through? Unfortunately, `find` will return the location of only the first substring it finds."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4pyLPD_1pm3C",
        "colab_type": "code",
        "outputId": "9305a9f0-fb10-4193-f3be-253c41e47a23",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'example'.find('e')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yAqqVoRyprch",
        "colab_type": "code",
        "outputId": "6783c21b-0990-428b-a9fc-425466878d8f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'example'[0]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'e'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JMGe_VUyo100",
        "colab_type": "text"
      },
      "source": [
        "The other 2 parameters hinted at above are `start` and `end`. They tell where `find` should start and stop its search for the substring."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZrWwG9p9oyMm",
        "colab_type": "code",
        "outputId": "6c63c928-9024-4bec-8d48-33602a0f3915",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'example'.find('e', 5)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8YWUTxGXqz1g",
        "colab_type": "code",
        "outputId": "e56c0dce-316b-446a-dee3-4acfca784655",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "'example'.find('p', 0, 4)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3wreS-68sFXa",
        "colab_type": "text"
      },
      "source": [
        "## String Practice"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "za_adRBjt58U",
        "colab_type": "text"
      },
      "source": [
        "### Read the Docs\n",
        "The documentation for strings can be found [here](https://docs.python.org/3/library/stdtypes.html#string-methods). Use it to complete the following tasks on the string `problem` below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gr62KmeMvqQy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "problem = '  problem 1  \\n'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YEbGZzR0v9Y0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Remove all leading and trailing whitespace. Correct output is 'problem 1'\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U82tJKY3wU5O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Replace the '1' in `problem` with a '2'. Correct output is '  problem 2  \\n'\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UZin2CY5xMaw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# How many spaces ' ' are in `problem`?\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d5FkUspDwfan",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Choose another string function and demonstrate it below using `problem`\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jFIYkcvTx8Nq",
        "colab_type": "text"
      },
      "source": [
        "### Caeser Cypher\n",
        "A Caeser cypher is a weak form of encryption that \"rotates\" each character in a string by a given number of places. Rotating means shifting the letter through the alphabet and wrapping around from 'z' to 'a'. For example, if you rotate `m` by 3 you get `p`, if you rotate `z` by 1 you get `a`.\n",
        "\n",
        "Write a function that takes a string and an integer. Convert the string to all uppercase characters and then rotate it by the given integer amount.\n",
        "\n",
        "Example:\n",
        "```python\n",
        "caeser('dog', 2)\n",
        ">>> 'FQI'\n",
        "```\n",
        "\n",
        "*Hint: If you are stuck google how to convert a character to a number, and a number to a character.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vg-l3jZYjjoR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NZqZGbFDz99D",
        "colab_type": "text"
      },
      "source": [
        "# Debugging"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jIQkQBZHpo-0",
        "colab_type": "text"
      },
      "source": [
        "So far we have looked at how to respond bugs as they crop up, but this reactive approach is not ideal. It means there is a high likelyhood that we end up with code we say is finished but has errors laying in wait for the right problem input or a useful idiot user. How do we take a more proactive approach to bugs? Test cases.\n",
        "\n",
        "We can write more robust code by purposely thinking about all the ways to cause bugs. We can modify our code to avoid those issues or, at the very least, we can make informed decisions when leaving possible bugs in.\n",
        "\n",
        "Let's take a look at some common test cases:\n",
        "1. **Sanity Check** - Testing to make sure everything is working as you expect. This is often the the toy test cases you do on the regular.\n",
        "\n",
        "2. **Edge Cases** - Test really large and really small values. For a number it could be the maximum or minimum value allowed for it's data type. For an iterable, like a list or string, try an empty one and a really long one. The idea here being that everything in between should work if the extremes work.\n",
        "\n",
        "3. **Corner Cases** - A corner case is when multiple edge cases are tested at the same time (just like a corner in real life is where multiple edges meet). Is everything still behaving when all the dials are set to the max? Any weird interactions? Often this is where you see performance impacts as multiple really big or really small things cause slow downs you didn't expect.\n",
        "\n",
        "4. **Incompatible Types** - This is when you send a data type that you shouldn't. While it is a good idea to remove all potential for bugs, we often don't enforce type. This is risky but often safe enough when there is no user interaction. As soon as you rely on user input, you should check for and enforce the correct data type.\n",
        "\n",
        "By testing our code thorougly we ensure that it holds up in production when we aren't around to fix it the moment it breaks. Robust code also makes for code that is worth reusing. If you write clean, bug free code with reusability in mind, you will start to build up a toolbox of useful code snippets that will save you time and you can slot in with confidence since you know the limits."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LnIC3hDp9XMd",
        "colab_type": "text"
      },
      "source": [
        "## Debug Practice"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PB7ct_rB9QMs",
        "colab_type": "text"
      },
      "source": [
        "Below is a function to count unique words in a string. Use the function to practice each of the test case types above."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q5lzL-A6ipPi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import string\n",
        "\n",
        "def count_unique_words(text):\n",
        "    # Strip punctuation and remove capitalization\n",
        "    text = text.translate(str.maketrans('', '', string.punctuation)).lower()\n",
        "\n",
        "    return len(set(text.split()))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I2yOcKcj-HZ_",
        "colab_type": "text"
      },
      "source": [
        "### Sanity Check\n",
        "\n",
        "Give inputs that you would expect to be common."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1GC3uOQR-Zz5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c155bf63-0bf1-42fe-f946-264ae2a1a558"
      },
      "source": [
        "# Example\n",
        "\n",
        "count_unique_words('This is a test of a moderately short string.')"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZKxsYRGS-kJP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Sanity Check 1\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mbsEToRo-z1z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Sanity Check 2\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SLioSwDk-2dn",
        "colab_type": "text"
      },
      "source": [
        "### Edge Cases\n",
        "\n",
        "Try cases at the extremes of what is expected."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LKCeGVaL_Jg_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "f17db670-d751-4a2a-9678-cc23caa45e22"
      },
      "source": [
        "# Example\n",
        "long_string = 'a couple of test words ' * 99999\n",
        "count_unique_words(long_string)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QQ3Z0BSY_Plk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Edge Case 1\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e_Wsjopz_tGx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Edge Case 2\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1v_BLoZZ_vv7",
        "colab_type": "text"
      },
      "source": [
        "### Corner Cases\n",
        "\n",
        "For this function, it only has one parameter so it doesn't have corner cases to test. Write a function with multiple parameters and then test a corner case."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8y9iigyqA_L4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Your function here\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rYhwGb45BFC5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Your corner case test here\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r245UK3FCE8Q",
        "colab_type": "text"
      },
      "source": [
        "### Incompatible Types\n",
        "\n",
        "The given function expects a string, pass it a data type it doesn't expect. Rewrite the function to prevent it from crashing when passed a non-string data type and then test the rewritten function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vpICaeALDO-I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Incompatible Type Test\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n9gXhYh0DqaN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Rewrite the function here\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zP5YiwYkDtwb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Incompatible Type Test on the corrected function\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XpQhy4h0F_PS",
        "colab_type": "text"
      },
      "source": [
        "# Further Exploration"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k_gXaghuGIPs",
        "colab_type": "text"
      },
      "source": [
        "### Regex"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wsc-eabhGcz8",
        "colab_type": "text"
      },
      "source": [
        "Regular expession is a bit of a mini-language within Python and other languages that allows for powerful and compact manipulation of strings. Regular Expression is a deep topic that takes time to master, but is extremely useful. [Here](https://www.datacamp.com/community/tutorials/python-regular-expression-tutorial) is a tutorial to walk you through the basics of regex, and below is a tutorial video as well."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jc9NmJZlEAsP",
        "colab_type": "text"
      },
      "source": [
        "## Aditional Resources"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SxnK5exsEP-2",
        "colab_type": "text"
      },
      "source": [
        "[Tutorial Video on Strings](https://www.youtube.com/watch?v=k9TUPpGqYTo)\n",
        "\n",
        "[Tutorial Video on String Formatting](https://www.youtube.com/watch?v=nghuHvKLhJA)\n",
        "\n",
        "[Tutorial Video on Regular Expression](https://www.youtube.com/watch?v=K8L6KVGG-7o)\n",
        "\n",
        "[Regex Tutorial](https://www.datacamp.com/community/tutorials/python-regular-expression-tutorial)"
      ]
    }
  ]
}