basics/Python_Intro_and_Object_Oriented_Programming.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python Intro and Object Oriented Programming.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyO6bst2NIw3/+0+KjTNvqCq",
      "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/BreakoutMentors/Data-Science-and-Machine-Learning/blob/main/basics/Python_Intro_and_Object_Oriented_Programming.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xjsJN2jauqi2"
      },
      "source": [
        "# Python Introduction with Object Oriented Programming\n",
        "\n",
        "Here gives you the information you need to understand how to use Python!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "exmMS3unrVhM"
      },
      "source": [
        "# Variables\n",
        "\n",
        "Variables are containers for storing values in Python, and they are very important in understanding python and programming in general!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VKCTK_txzKXb",
        "outputId": "a5ab0769-0509-485f-d747-bfeb494c18ea"
      },
      "source": [
        "# Assigning the number 5 to the variable x\n",
        "print(\"Assigning the number 5 to the variable x\")\n",
        "x = 5\n",
        "print('x equals', x)\n",
        "\n",
        "# Changing x to be assigned to the number 3\n",
        "print(\"\\nChanging x to be assigned to the number 3\")\n",
        "x = 3\n",
        "print('x =', x)\n",
        "\n",
        "# Initializing the variable y to have the number 1 assigned to it\n",
        "print('\\nInitializing the variable y to have the number 1 assigned to it')\n",
        "y = 1\n",
        "print('y =', y)\n",
        "\n",
        "# Assigning the value of x to y\n",
        "print('\\nAssigning the value of x to y')\n",
        "y = x\n",
        "print('y =', y)\n",
        "\n",
        "# Incrementing y by +3\n",
        "print('\\nIncrementing y by +3')\n",
        "y = y + 3\n",
        "print('y =', y)\n",
        "\n",
        "# Checking if x was changed, since we wrote y = x\n",
        "print('\\nChecking if x was changed, since we wrote y = x')\n",
        "print('x =', x)\n",
        "print('You can see when we used y = x; x was not changed when we changed y, therefore the value of x is copied and assigned to y')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Assigning the number 5 to the variable x\n",
            "x equals 5\n",
            "\n",
            "Changing x to be assigned to the number 3\n",
            "x = 3\n",
            "\n",
            "Initializing the variable y to have the number 1 assigned to it\n",
            "y = 1\n",
            "\n",
            "Assigning the value of x to y\n",
            "y = 3\n",
            "\n",
            "Incrementing y by +3\n",
            "y = 6\n",
            "\n",
            "Checking if x was changed, since we wrote y = x\n",
            "x = 3\n",
            "You can see when we used y = x; x was not changed when we changed y, therefore the value of x is copied and assigned to y\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YpTZYJva1PDt"
      },
      "source": [
        "# Strings\n",
        "\n",
        "Strings is a datatype that holds text in our variables."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OSWDf63J1nST"
      },
      "source": [
        "## String Usage"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4SMIlvTX1kkp",
        "outputId": "ce88852c-feec-474c-a281-3a1cb76b4a5b"
      },
      "source": [
        "# String section\n",
        "\n",
        "# Initalizing variables first_name and last_name; Please enter your own\n",
        "first_name = 'John' # Replace this with your own name\n",
        "last_name = \"Rivera\" # Replace this with your own name\n",
        "\n",
        "# Adding strings\n",
        "name = first_name + \" \" + last_name\n",
        "print(name)\n",
        "\n",
        "# Indexing characters in a string\n",
        "print('First letter of your first name:', first_name[0])\n",
        "\n",
        "# Looping strings\n",
        "print('\\nLooping through a string a character at a time')\n",
        "for character in name:\n",
        "    print(character)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "John Rivera\n",
            "First letter of your first name: J\n",
            "\n",
            "Looping through a string a character at a time\n",
            "J\n",
            "o\n",
            "h\n",
            "n\n",
            " \n",
            "R\n",
            "i\n",
            "v\n",
            "e\n",
            "r\n",
            "a\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R7MIScbt1vur"
      },
      "source": [
        "## Python Built-in String methods\n",
        "\n",
        "Python has built-in string methods that allow us to do many useful changes to the strings. I will show some popular methods, but [here is a full list](https://www.w3schools.com/python/python_ref_string.asp)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_QtTjmTC0bHr",
        "outputId": "f9c7060d-bacf-4038-8782-c23689a087be"
      },
      "source": [
        "# Captilize Method; Capitlizes first letter\n",
        "lower_case_sentence = \"adam is the person writing this code\"\n",
        "upper_case_sentence = lower_case_sentence.capitalize()\n",
        "print('Capitalize Method:', upper_case_sentence)\n",
        "\n",
        "# Split method; Splits the string by a character into a list with different values\n",
        "print('\\nName Before Split:', name)\n",
        "split_name = name.split(' ')\n",
        "print('Splitting Name with a space:', split_name)\n",
        "\n",
        "# Join method; Joins items in a list by a character\n",
        "print('\\nJoining items in split_name by a space:', ' '.join(split_name))\n",
        "\n",
        "# Stripping whitespace of a string; whitespace means empty space values before and after a string\n",
        "white_space = '       lots of spaces   '\n",
        "print('\\nThis is a string with lots of white space:', white_space)\n",
        "print('\\nThis is the same string with white space removed:', white_space.strip())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Capitalize Method: Adam is the person writing this code\n",
            "\n",
            "Name Before Split: John Rivera\n",
            "Splitting Name with a space: ['John', 'Rivera']\n",
            "\n",
            "Joining items in split_name by a space: John Rivera\n",
            "\n",
            "This is a string with lots of white space:        lots of spaces   \n",
            "\n",
            "This is the same string with white space removed: lots of spaces\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jwLrRC-q5cpo"
      },
      "source": [
        "# Integers\n",
        "\n",
        "Integers is a datatype that holds whole numbers (e.g. 1, 10, 15).\n",
        "\n",
        "You are able to do mathematical operations with integers.\n",
        "1. Addition (+)\n",
        "2. Subtraction (-)\n",
        "3. Multiplication (*)\n",
        "4. Division (/)\n",
        "5. Floor Division (//)\n",
        "6. Exponents (**)\n",
        "7. [Modulo](https://www.freecodecamp.org/news/the-python-modulo-operator-what-does-the-symbol-mean-in-python-solved/) (%):\n",
        "  - This gives you the remainder of division, for example `10%3` gives 1 since 3 divides into 10 only 3 times, so the remainder is 1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_S4CbrkXfkGd",
        "outputId": "d4febacd-33e0-48df-f458-09f207600a2c"
      },
      "source": [
        "# Assigning the number 15 to x\n",
        "x = 15\n",
        "\n",
        "# Adding 3 to x\n",
        "print('Adding 3 to x to become 18')\n",
        "x = x + 3\n",
        "print('x:', x)\n",
        "\n",
        "# Subtracting 3 from x\n",
        "print('\\nSubtracting 3 from x to become 15')\n",
        "x = x - 3\n",
        "print('x:', x)\n",
        "\n",
        "# Multipling 2 times x\n",
        "print('\\nMultiplying x by 2 to become 30')\n",
        "x = 2 * x\n",
        "print('x:', x)\n",
        "\n",
        "# Dividing x by 3\n",
        "print('\\nDividing x by 3 to become 10')\n",
        "x = x / 3\n",
        "print('x:', x)\n",
        "\n",
        "print('\\nUsing Floor Division to divide x by 3')\n",
        "print('First using regular division which will give a decimal(x):', x/3)\n",
        "x = x // 3\n",
        "print('Floor division rounds the result to the lower whole number')\n",
        "print('x:', x)\n",
        "\n",
        "# Squaring x or giving the power of 2 to x\n",
        "print('\\nSquaring x to become 9')\n",
        "x = x ** 2\n",
        "print('x:', x)\n",
        "\n",
        "# Getting the remainder of dividing x by 2\n",
        "print('\\nRemainder of dividing x by 2')\n",
        "x = x % 2\n",
        "print('x:', x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Adding 3 to x to become 18\n",
            "x: 18\n",
            "\n",
            "Subtracting 3 from x to become 15\n",
            "x: 15\n",
            "\n",
            "Multiplying x by 2 to become 30\n",
            "x: 30\n",
            "\n",
            "Dividing x by 3 to become 10\n",
            "x: 10.0\n",
            "\n",
            "Using Floor Division to divide x by 3\n",
            "First using regular division which will give a decimal(x): 3.3333333333333335\n",
            "Floor division rounds the result to the lower whole number\n",
            "x: 3.0\n",
            "\n",
            "Squaring x to become 9\n",
            "x: 9.0\n",
            "\n",
            "Remainder of dividing x by 2\n",
            "x: 1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bs2R77HQi9gv"
      },
      "source": [
        "# Floats\n",
        "\n",
        "Floats is a datatype that holds decimal values along with whole numbers (e.g. 1.5, 10.11, -12.33, -5.0)\n",
        "\n",
        "All of the same mathematical operations can be used on floats."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9XIBJi7Dkzb6",
        "outputId": "be6423d5-b05f-470a-dfda-497964f8ac48"
      },
      "source": [
        "# Assigning the number 12.5 to x\n",
        "x = 12.5\n",
        "\n",
        "# Adding 3 to x\n",
        "print('Adding 3 to x to become 15.5')\n",
        "x = x + 3\n",
        "print('x:', x)\n",
        "\n",
        "# Subtracting 3 from x\n",
        "print('\\nSubtracting 3 from x to become 12.5')\n",
        "x = x - 3\n",
        "print('x:', x)\n",
        "\n",
        "# Multipling 2 times x\n",
        "print('\\nMultiplying x by 2 to become 25')\n",
        "x = 2 * x\n",
        "print('x:', x)\n",
        "\n",
        "# Dividing x by 3\n",
        "print('\\nDividing x by 3 to become 8.333')\n",
        "x = x / 3\n",
        "print('x:', x)\n",
        "\n",
        "print('\\nUsing Floor Division to divide x by 3')\n",
        "print('First using regular division which will give a decimal(x):', x/3)\n",
        "x = x // 3\n",
        "print('Floor division rounds the result to the lower whole number')\n",
        "print('x:', x)\n",
        "\n",
        "# Squaring x or giving the power of 2 to x\n",
        "print('\\nSquaring x to become 4')\n",
        "x = x ** 2\n",
        "print('x:', x)\n",
        "\n",
        "# Getting the remainder of dividing x by 3\n",
        "print('\\nRemainder of dividing x by 3')\n",
        "x = x % 3\n",
        "print('x:', x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Adding 3 to x to become 15.5\n",
            "x: 15.5\n",
            "\n",
            "Subtracting 3 from x to become 12.5\n",
            "x: 12.5\n",
            "\n",
            "Multiplying x by 2 to become 25\n",
            "x: 25.0\n",
            "\n",
            "Dividing x by 3 to become 8.333\n",
            "x: 8.333333333333334\n",
            "\n",
            "Using Floor Division to divide x by 3\n",
            "First using regular division which will give a decimal(x): 2.777777777777778\n",
            "Floor division rounds the result to the lower whole number\n",
            "x: 2.0\n",
            "\n",
            "Squaring x to become 4\n",
            "x: 4.0\n",
            "\n",
            "Remainder of dividing x by 3\n",
            "x: 1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PmNUYFYTlqOY"
      },
      "source": [
        "# Lists\n",
        "\n",
        "Lists are a built-in data structure into Python that are able to store data of different datatypes. What is great about lists are that they are expandable, changeable, and ordered.\n",
        "\n",
        "Below show examples of how to use a list, but there are many other great uses so [here is a resource](https://www.w3schools.com/python/python_lists.asp)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CeJRQTqGkzZb",
        "outputId": "1123c594-a932-4f71-be68-c8bf1221ab77"
      },
      "source": [
        "# Creating a list named a with items with different datatypes\n",
        "a = [1, 10, 'book', 1.3, 'chair']\n",
        "\n",
        "# Selecting individual items\n",
        "print('You are able to get single items from list using their index')\n",
        "print('Grabbing the first item:', a[0])\n",
        "print('Grabbing the third item:', a[2])\n",
        "print('Grabbing the last item:', a[-1])\n",
        "print('The index is a number that is given to match the item in the list, it starts from 0 and ends at 4 because there are 5 items in list a')\n",
        "\n",
        "# Slicing list\n",
        "print('\\nYou are able to select multiple items in the list using slicing')\n",
        "print('Grabbing the first three items:', a[0:3])\n",
        "print('Grabbing the last three items:', a[-3:])\n",
        "print('This works by using a[x(inclusive):y(exclusive)] where item at index x is included and item at index y is not included, so it goes from x to (y-1)')\n",
        "\n",
        "# Adding items to a list, using the append method\n",
        "print('\\nAdding 101.33 to the list a')\n",
        "a.append(101.33)\n",
        "print('a:', a)\n",
        "\n",
        "# Replacing items by index\n",
        "print(\"\\nReplacing item at index 4; replacing 'chair' with 'couch'\")\n",
        "print('a[4] before replacement:', a[4])\n",
        "a[4] = 'couch'\n",
        "print('a[4] after replacement:', a[4])\n",
        "print('a after replacement:', a)\n",
        "\n",
        "# Removing an item in the list using the remove method\n",
        "print('\\nRemoving the number 10 from the list a')\n",
        "a.remove(10)\n",
        "print('a:', a)\n",
        "\n",
        "# Getting length of a\n",
        "print('\\nYou can get the length of list a using the len() function')\n",
        "print('Length of a:', len(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "You are able to get single items from list using their index\n",
            "Grabbing the first item: 1\n",
            "Grabbing the third item: book\n",
            "Grabbing the last item: chair\n",
            "The index is a number that is given to match the item in the list, it starts from 0 and ends at 4 because there are 5 items in list a\n",
            "\n",
            "You are able to select multiple items in the list using slicing\n",
            "Grabbing the first three items: [1, 10, 'book']\n",
            "Grabbing the last three items: ['book', 1.3, 'chair']\n",
            "This works by using a[x(inclusive):y(exclusive)] where item at index x is included and item at index y is not included, so it goes from x to (y-1)\n",
            "\n",
            "Adding 101.33 to the list a\n",
            "a: [1, 10, 'book', 1.3, 'chair', 101.33]\n",
            "\n",
            "Replacing item at index 4; replacing 'chair' with 'couch'\n",
            "a[4] before replacement: chair\n",
            "a[4] after replacement: couch\n",
            "a after replacement: [1, 10, 'book', 1.3, 'couch', 101.33]\n",
            "\n",
            "Removing the number 10 from the list a\n",
            "a: [1, 'book', 1.3, 'couch', 101.33]\n",
            "\n",
            "You can get the length of list a using the len() function\n",
            "Length of a: 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nZlW_Yx2phta"
      },
      "source": [
        "# Tuples\n",
        "\n",
        "Tuples are a built-in data structure into Python that are able to store data of different datatypes. They are very similar to lists that they are ordered but they are NOT changeable, so you cannot add more items and cannot change individual items by index.\n",
        "\n",
        "Below show examples of how to use a tuple, but there are many other great uses so [here is a resource](https://www.w3schools.com/python/python_tuples.asp)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VG2ikWdQnuEt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa195316-ecd3-4bc4-812c-83976b2e37f9"
      },
      "source": [
        "# Creating tuple\n",
        "tuple_b = ('backpack', 2, 'desk', 'pencil', 10.5)\n",
        "\n",
        "# Selecting individual items\n",
        "print('You are able to get single items from tuples using their index')\n",
        "print('Grabbing the first item:', tuple_b[0])\n",
        "print('Grabbing the third item:', tuple_b[2])\n",
        "print('Grabbing the last item:', tuple_b[-1])\n",
        "print('The index is a number that is given to match the item in the tuple, it starts from 0 and ends at 4 because there are 5 items in tuple_b')\n",
        "\n",
        "# Slicing list\n",
        "print('\\nYou are able to select multiple items in the tuple using slicing')\n",
        "print('Grabbing the first three items:', tuple_b[0:3])\n",
        "print('Grabbing the last three items:', tuple_b[-3:])\n",
        "print('This works by using a[x(inclusive):y(exclusive)] where item at index x is included and item at index y is not included, so it goes from x to (y-1)')"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "You are able to get single items from tuples using their index\n",
            "Grabbing the first item: backpack\n",
            "Grabbing the third item: desk\n",
            "Grabbing the last item: 10.5\n",
            "The index is a number that is given to match the item in the list, it starts from 0 and ends at 4 because there are 5 items in list a\n",
            "\n",
            "You are able to select multiple items in the list using slicing\n",
            "Grabbing the first three items: ('backpack', 2, 'desk')\n",
            "Grabbing the last three items: ('desk', 'pencil', 10.5)\n",
            "This works by using a[x(inclusive):y(exclusive)] where item at index x is included and item at index y is not included, so it goes from x to (y-1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d_4nbdwS6zlT"
      },
      "source": [
        "# Sets\n",
        "\n",
        "![img](https://www.onlinemathlearning.com/image-files/set-operations-venn-diagrams.png)\n",
        "\n",
        "Sets are another built-in Python data structure that comes from [mathematical set theory](https://en.wikipedia.org/wiki/Set_theory), which holds objects of different datatypes just like list and tuples but they cannot hold replicates. Sets are used to find objects that overlap between sets (intersection), join objects from both sets (union), or find differences between sets (difference). Sets are both unordered and unindexed, so you cannot access items by an index.\n",
        "\n",
        "[Click here for more information on sets.](https://www.w3schools.com/python/python_sets.asp)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iDPAuQhW6zY4",
        "outputId": "a413c81f-0a94-4720-c5cf-6c2f21a779e8"
      },
      "source": [
        "# Creating a set of fruits with repeated fruits\n",
        "fruits = {\"apple\", \"banana\", \"banana\", \"guava\"}\n",
        "print(\"Fruit Set:\", fruits)\n",
        "print(\"Banana was placed twice, but you can see it only kept 1 because there cannot be replicates in sets\")\n",
        "\n",
        "# Creating sets with fruits and veggies\n",
        "fruits_and_veggies = {'apple', 'broccli', 'spanich'}\n",
        "print(\"\\nFruits and Veggies Set:\", fruits_and_veggies)\n",
        "\n",
        "# Finding the intersection between both sets\n",
        "print(\"\\nFinding intersection between the two sets\")\n",
        "print(\"Intersection:\", fruits.intersection(fruits_and_veggies))\n",
        "\n",
        "# Finding the difference between the sets\n",
        "print(\"\\nFinding difference between the two sets\")\n",
        "print(\"Difference between 'fruits' set and 'fruits_and_veggies':\", fruits.difference(fruits_and_veggies))\n",
        "print(\"Difference between 'fruits_and_veggies' set and 'fruits':\", fruits_and_veggies.difference(fruits))\n",
        "\n",
        "# Adding more items to a set\n",
        "fruits.add('starfruit')\n",
        "print(\"\\nAdded starfruit to 'fruits' set:\", fruits)\n",
        "\n",
        "# Removing items in a set\n",
        "fruits_and_veggies.remove('spanich')\n",
        "print(\"Removed spanich from 'fruits_and_veggies'\", fruits_and_veggies)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fruit Set: {'banana', 'guava', 'apple'}\n",
            "Banana was placed twice, but you can see it only kept 1 because there cannot be replicates in sets\n",
            "\n",
            "Fruits and Veggies Set: {'broccli', 'spanich', 'apple'}\n",
            "\n",
            "Finding intersection between the two sets\n",
            "Intersection: {'apple'}\n",
            "\n",
            "Finding difference between the two sets\n",
            "Difference between 'fruits' set and 'fruits_and_veggies': {'banana', 'guava'}\n",
            "Difference between 'fruits_and_veggies' set and 'fruits': {'broccli', 'spanich'}\n",
            "\n",
            "Added starfruit to 'fruits' set: {'banana', 'starfruit', 'guava', 'apple'}\n",
            "Removed spanich from 'fruits_and_veggies' {'broccli', 'apple'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mSm6X2ftPhD1"
      },
      "source": [
        "# Dictionaries\n",
        "\n",
        "Dictionaries are a built-in data structure in Python that allows you to store values in key:value pairs. The reason why dictionaries are really useful is that you can use keys to access items in a dictionary rather than an index in lists.\n",
        "\n",
        "[Click here for more information on dictionaries.](https://www.w3schools.com/python/python_dictionaries.asp)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-VjTepeTQpCc",
        "outputId": "fa2c0fd0-d455-4d14-a3dc-3a9dea907620"
      },
      "source": [
        "# Creating a dictionary with information about me\n",
        "adam_dict = {'first_name':'Adam',\n",
        "             'last_name':'Villarreal',\n",
        "             'fav_ice_cream':'Mint Chocolate Chip'}\n",
        "\n",
        "print('The keys are what go left of the colon(:) and the values are to the right of the colon')\n",
        "\n",
        "# Accessing items\n",
        "print('\\nYou can access values by their keys')\n",
        "print(\"Getting my first name with 'first_name' key:\", adam_dict['first_name'])\n",
        "\n",
        "# Changing items\n",
        "print('\\nYou can also change values by reassignment')\n",
        "new_fav_flavor = \"Rocky Road\"\n",
        "adam_dict['fav_ice_cream'] = new_fav_flavor # Reassinging my new value\n",
        "print('New Flavor:', adam_dict['fav_ice_cream'])\n",
        "\n",
        "# Deleting items\n",
        "print('\\nYou can delete entire key:item pairs (items) using .pop() method')\n",
        "adam_dict.pop('fav_ice_cream')\n",
        "print(adam_dict)\n",
        "\n",
        "# Adding items\n",
        "print('\\nYou can add items by assignment or using the .update() method')\n",
        "adam_dict['fav_sport'] = 'Soccer'\n",
        "adam_dict.update({'fav_coffee_drink':'Latte'})\n",
        "print(adam_dict)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The keys are what go left of the colon(:) and the values are to the right of the colon\n",
            "\n",
            "You can access values by their keys\n",
            "Getting my first name with 'first_name' key: Adam\n",
            "\n",
            "You can also change values by reassignment\n",
            "New Flavor: Rocky Road\n",
            "\n",
            "You can delete entire key:item pairs (items) using .pop() method\n",
            "{'first_name': 'Adam', 'last_name': 'Villarreal'}\n",
            "\n",
            "You can add items by assignment or using the .update() method\n",
            "{'first_name': 'Adam', 'last_name': 'Villarreal', 'fav_sport': 'Soccer', 'fav_coffee_drink': 'Latte'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PZhPNLDOUOBY"
      },
      "source": [
        "# Looping over Lists, Sets, and Dictionaries"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nGeVhwTOUZBV"
      },
      "source": [
        "## Looping Lists\n",
        "\n",
        "There are two ways to loop over lists:\n",
        "1. Loop by element\n",
        "2. Loop by index"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qo80yEpCUh3x",
        "outputId": "5fa9298e-8705-441b-8b0b-128029726de9"
      },
      "source": [
        "list_a = [1, 10, 'book', 1.3, 'chair']\n",
        "\n",
        "# Looping by element\n",
        "print('Looping by element:')\n",
        "for elem in list_a:\n",
        "    print(elem)\n",
        "\n",
        "# Looping by index\n",
        "print(\"\\nLooping by index:\")\n",
        "for i in range(len(list_a)):\n",
        "    print(list_a[i])\n",
        "\n",
        "print(\"range(len(list_a)) gives you a 'range' object that has ordered numbers from 0 to (length of list_a-1)\")\n",
        "print(\"If range(len(list_a)) is converted to a list, it looks like this:\", list(range(len(list_a))))"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Looping by element:\n",
            "1\n",
            "10\n",
            "book\n",
            "1.3\n",
            "chair\n",
            "\n",
            "Looping by index:\n",
            "1\n",
            "10\n",
            "book\n",
            "1.3\n",
            "chair\n",
            "range(len(list_a)) gives you a 'range' object that has ordered numbers from 0 to (length of list_a-1)\n",
            "If range(len(list_a)) is converted to a list, it looks like this: [0, 1, 2, 3, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y60hAq3cWt5u"
      },
      "source": [
        "## Looping Tuples\n",
        "\n",
        "Looping tuples is exactly the same as looping lists."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H-VZ90cUWyZt",
        "outputId": "50932f70-0aec-47a1-ec46-30c5e68707df"
      },
      "source": [
        "tuple_b = ('backpack', 2, 'desk', 'pencil', 10.5)\n",
        "\n",
        "# Looping by element\n",
        "print('Looping by element:')\n",
        "for elem in tuple_b:\n",
        "    print(elem)\n",
        "\n",
        "# Looping by index\n",
        "print(\"\\nLooping by index:\")\n",
        "for i in range(len(tuple_b)):\n",
        "    print(tuple_b[i])"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Looping by element:\n",
            "backpack\n",
            "2\n",
            "desk\n",
            "pencil\n",
            "10.5\n",
            "\n",
            "Looping by index:\n",
            "backpack\n",
            "2\n",
            "desk\n",
            "pencil\n",
            "10.5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yFysLaSXXKn8"
      },
      "source": [
        "## Looping Sets\n",
        "\n",
        "You can only loop through sets by element since sets are naturally unindexed, so you cannot access items by indices."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pdm3p1WrXTYs",
        "outputId": "cb3ad1cb-bd0d-401b-a766-db3dc63f3b00"
      },
      "source": [
        "fruits = {\"apple\", \"banana\", \"banana\", \"guava\"}\n",
        "\n",
        "for fruit in fruits:\n",
        "    print(fruit)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "banana\n",
            "guava\n",
            "apple\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F04tsBKIX0vw"
      },
      "source": [
        "## Looping Dictionaries\n",
        "\n",
        "To loop dictionaries, there are three ways:\n",
        "1. Loop by keys\n",
        "2. Loop by values\n",
        "3. Loop by key:value item pairs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4Nk6mz0X0an",
        "outputId": "a76f3880-533e-4099-8796-069786744790"
      },
      "source": [
        "adam_dict = {'first_name':'Adam',\n",
        "             'last_name':'Villarreal',\n",
        "             'fav_ice_cream':'Mint Chocolate Chip'}\n",
        "\n",
        "# Looping by keys\n",
        "print('Looping by keys')\n",
        "for key in adam_dict:\n",
        "    print('key:', key)\n",
        "    print('value:', adam_dict[key])\n",
        "\n",
        "# Looping by Values\n",
        "print('\\nLooping by values')\n",
        "for value in adam_dict.values():\n",
        "    print(\"Value:\", value)\n",
        "\n",
        "# Looping by items\n",
        "print('\\nLooping by items')\n",
        "for key, value in adam_dict.items():\n",
        "    print('key:', key)\n",
        "    print('value:', value)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Looping by keys\n",
            "key: first_name\n",
            "value: Adam\n",
            "key: last_name\n",
            "value: Villarreal\n",
            "key: fav_ice_cream\n",
            "value: Mint Chocolate Chip\n",
            "\n",
            "Looping by values\n",
            "Value: Adam\n",
            "Value: Villarreal\n",
            "Value: Mint Chocolate Chip\n",
            "\n",
            "Looping by items\n",
            "key: first_name\n",
            "value: Adam\n",
            "key: last_name\n",
            "value: Villarreal\n",
            "key: fav_ice_cream\n",
            "value: Mint Chocolate Chip\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JDtGslq7f_nn"
      },
      "source": [
        "# Python is an Object Oriented Programming (OOP) Language\n",
        "\n",
        "I highly recommend you to read this introduction of [Object Oriented Programming](https://www.educative.io/blog/object-oriented-programming).\n",
        "\n",
        "At a high level, OOP Programming is a programming style where you are able to create data types that are abstract and very malleable. `Classes` are what allows us to do this, classes are essentially blueprints of the datatype you want to create, and you create `objects` from the `class`!\n",
        "\n",
        "## Creating Classes\n",
        "There are two parts of classes:\n",
        "1. Constructor - This creates the object of the class, it also uses parameters!\n",
        "\n",
        "  - You save data from the parameters in the constructor by defining the class's attributes.\n",
        "\n",
        "2. Methods - These are functions you create that uses the class's attributes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tHoYs_hef9MT",
        "outputId": "44e32197-477f-4e6a-9d1e-bbc3c7b32f54"
      },
      "source": [
        "# Creating a class called Car\n",
        "\n",
        "class Car():\n",
        "    # Defining Constructor\n",
        "    def __init__(self, num_wheels, color, owners_name):\n",
        "        # Defining attributes\n",
        "        self.wheels = num_wheels\n",
        "        self.color = color\n",
        "        self.name = owners_name\n",
        "\n",
        "    # Defining Methods\n",
        "\n",
        "    # These next three are called accessor methods that access the class's attributes\n",
        "    def get_owners_name(self):\n",
        "        return self.name\n",
        "\n",
        "    def get_color(self):\n",
        "        return self.color\n",
        "\n",
        "    def get_num_wheels(self):\n",
        "        return self.wheels\n",
        "\n",
        "    def drive(self, num_miles):\n",
        "        print(f\"{self.name}'s car drives {num_miles} miles.\")\n",
        "\n",
        "# Creating Object\n",
        "my_car = Car(num_wheels=4, color='Blue', owners_name='Adam')\n",
        "\n",
        "# Printing attributes\n",
        "print('Wheels:', my_car.wheels)\n",
        "print('Color:', my_car.color)\n",
        "print('Name:', my_car.name)\n",
        "\n",
        "# Using accessor methods\n",
        "print('\\nNow using accessor methods:')\n",
        "print('Wheels:', my_car.get_num_wheels())\n",
        "print('Color:', my_car.get_color())\n",
        "print('Name:', my_car.get_owners_name())\n",
        "\n",
        "# Using 'drive' method\n",
        "miles = 5\n",
        "my_car.drive(miles)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Wheels: 4\n",
            "Color: Blue\n",
            "Name: Adam\n",
            "\n",
            "Now using accessor methods:\n",
            "Wheels: 4\n",
            "Color: Blue\n",
            "Name: Adam\n",
            "Adam's car drives 5 miles.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DvmMbcIyln7P"
      },
      "source": [
        "## Inheritance\n",
        "\n",
        "Inheritance allows a class that uses the same attributes and methods of another class, usually the class that inherits is called the `child class` or `subclass` while the class that is being inherited from is called the `parent class`.\n",
        "\n",
        "We will be creating a Pickup Truck class, that will inherent from the car class, since a Pickup Truck also has a set number of wheels, a certain color, and a specific owner, and a Pickup Truck also drives! But only Pickup Trucks have a trunk bed, so its just not a normal car.\n",
        "\n",
        "When defining the contstructor of the subclass, you need to call the constructor of the parent class as well.\n",
        "\n",
        "[Please read more about inheritance here](https://www.w3schools.com/python/python_inheritance.asp)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DsK_8JI3mtri",
        "outputId": "ad41a99d-a748-4956-cbfc-045572f16724"
      },
      "source": [
        "# Creating Pickup Truck class by inheriting from the Car class\n",
        "class Pickup_Truck(Car):\n",
        "    # Defining Constructor\n",
        "    def __init__(self, color, owners_name):\n",
        "        # Calling Constructor of the parent class with specific parameters\n",
        "        super().__init__(num_wheels=4, color=color, owners_name=owners_name)\n",
        "        \n",
        "        # Defining attributes only specific to pickup trucks\n",
        "        self.trunk_bed = True\n",
        "        self.items_in_trunk = []\n",
        "    \n",
        "    # Defining methods specific to Pickup Trucks\n",
        "    def add_item_to_trunk(self, item):\n",
        "        # Appending item to items_in_truck list\n",
        "        self.items_in_trunk.append(item)\n",
        "        print('Added {} to the trunk'.format(item))\n",
        "    \n",
        "    def list_items_in_trunk(self):\n",
        "        if len(self.items_in_trunk) == 0:\n",
        "            print('Trunk is Empty')\n",
        "\n",
        "        else:\n",
        "            print('This is what is in the trunk:')\n",
        "            for item in self.items_in_trunk:\n",
        "                print(item)\n",
        "\n",
        "    # Overwritting drive method\n",
        "    def drive(self, num_miles):\n",
        "        print(f\"{self.name}'s truck drives {num_miles} miles.\")\n",
        "\n",
        "# Creating Object\n",
        "my_truck = Pickup_Truck(color='White', owners_name='Adam')\n",
        "\n",
        "# Printing attributes\n",
        "print('Wheels:', my_truck.wheels)\n",
        "print('Color:', my_truck.color)\n",
        "print('Name:', my_truck.name)\n",
        "print('Has Truck Bed:', my_truck.trunk_bed)\n",
        "\n",
        "# Using accessor methods\n",
        "print('\\nNow using accessor methods:')\n",
        "print('Wheels:', my_truck.get_num_wheels())\n",
        "print('Color:', my_truck.get_color())\n",
        "print('Name:', my_truck.get_owners_name())\n",
        "\n",
        "# Using 'drive' method\n",
        "miles = 8\n",
        "my_truck.drive(miles)\n",
        "\n",
        "print('\\nNow adding items to list!')\n",
        "my_truck.list_items_in_trunk()\n",
        "my_truck.add_item_to_trunk('Shovel')\n",
        "my_truck.add_item_to_trunk('Lawn Mower')\n",
        "my_truck.list_items_in_trunk()"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Wheels: 4\n",
            "Color: White\n",
            "Name: Adam\n",
            "Has Truck Bed: True\n",
            "\n",
            "Now using accessor methods:\n",
            "Wheels: 4\n",
            "Color: White\n",
            "Name: Adam\n",
            "Adam's truck drives 8 miles.\n",
            "\n",
            "Now adding items to list!\n",
            "Trunk is Empty\n",
            "Added Shovel to the trunk\n",
            "Added Lawn Mower to the trunk\n",
            "This is what is in the trunk:\n",
            "Shovel\n",
            "Lawn Mower\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}