1_Python_The_Basics_Filled.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNk6jijPcGce70ecKx58sAl",
      "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/theheking/intro-to-python/blob/gh-pages/1_Python_The_Basics_Filled.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fundamentals of Python\n",
        "\n",
        "# Objectives\n",
        "- Understand the background of Python\n",
        "- Understand the different data types and structures\n",
        "- Be able to use Python like a calculator\n",
        "\n",
        "Guido Van Rossum first created Python in 1991 with these key aims:\n",
        "1. Suitable for day-to-day activities. Fast development time.\n",
        "2. As simple and easy to understand as English\n",
        "3. Open source so that everyone can contribute to the program\n",
        "\n",
        "# What are the advantages of using Python compared to other languages?\n",
        "\n",
        "## Advantages\n",
        "- Open-source\n",
        "- Available for iOS, Windows and Linux\n",
        "- Designed for readability\n",
        "- Large supportive community\n",
        "- Third-party packages! \n",
        "\n",
        "## Disadvantages\n",
        "- Speed\n",
        "- High memory consumption\n",
        "- Low execution speed"
      ],
      "metadata": {
        "id": "K6jZDrWSei1K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "print(sys.version)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vg5LgNuSfGPB",
        "outputId": "e05bd10f-fe61-48da-b0fa-025cb1ca8335"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.10.11 (main, Apr  5 2023, 14:15:10) [GCC 9.4.0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The designer of Python is Guido van Rossum!\n",
        "He used to be the BDFL which he retired from in 2018! Now 32 years later and on release 3.10.11"
      ],
      "metadata": {
        "id": "ZspmX_OhaWzc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#what mode are we using now \n",
        "#show example if you were to use as a script"
      ],
      "metadata": {
        "id": "Ai2u9oQgBMXa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Using interactive Python in Jupyter-style notebooks\n",
        "There are two methods for using Python:\n",
        "- Interactive mode: similar to a scientific calculator, but you insert code into blocks within jupyter notebooks .ipynb.\n",
        "- Scripting mode: save that same code into a file with the ending .py."
      ],
      "metadata": {
        "id": "z5xEES0ABJ0p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Python is cool!\")"
      ],
      "metadata": {
        "id": "1ez6kEjdPE_C",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "36d03659-3e26-412a-a19c-befc4f58d453"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python is cool!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Python is rad\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KYm-k843q8Sg",
        "outputId": "9fdb76fc-44bd-445c-f4c7-e9450102baaa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python is rad\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Some easy shortcuts to note\n",
        "\n",
        "Shift-Enter to run the contents of the cell\n",
        "\n",
        "You can add new cells by either:\n",
        "1.   Hovering in between two boxes and selecting code. \n",
        "2.   Selecting Insert then Insert code cell\n",
        "\n",
        "\n",
        "NOTE: When the text on the left hand of the cell is: In [*] (with an asterisk rather than a number) --> cell is still running.\n",
        "\n",
        "Let's begin writing some more code in our notebook.\n",
        "\n"
      ],
      "metadata": {
        "id": "YckDXXfXQtfu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#assign a string to variable\n",
        "name = \"Garvan\"\n",
        "#print variable\n",
        "print(name)"
      ],
      "metadata": {
        "id": "CaUZgf3RPkFM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "61bd4fea-574d-4054-9986-4cf4b1501e95"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Garvan\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A hashtag (#) denotes a comment. The python interpreter ignores anything after that comment."
      ],
      "metadata": {
        "id": "gRYT9Zt5REjd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#print(name)\n",
        "print(name) "
      ],
      "metadata": {
        "id": "VxHwGT-qRDtg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f8e74314-0b34-4015-a634-efa5893501e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Garvan\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Variables and data types"
      ],
      "metadata": {
        "id": "wfk81IM0NlfC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Integers, floats and strings\n",
        "With 'Numeric' types, there are two key types integer and floats.\n",
        "\n",
        "Other slightly less important types include `hex` for hexadecimal and `complex` for complex numbers!\n",
        "\n"
      ],
      "metadata": {
        "id": "1xmve48CNq9j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " #assign number to variable\n",
        " kinghorn = 1\n",
        " print(kinghorn)"
      ],
      "metadata": {
        "id": "radunqHzRLss",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1fc3468f-007e-4d80-806a-d6c2db1d1a6d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#what type is it \n",
        "type(kinghorn)"
      ],
      "metadata": {
        "id": "RmaZOpLRRNCG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ba0ddb9d-eb0d-48c1-ac82-5c83ec7f9fbd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#assign a decimal to variable\n",
        "katherine = 1.01\n"
      ],
      "metadata": {
        "id": "F1yf2YKPRPqn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#what type is this \n",
        "type(katherine)"
      ],
      "metadata": {
        "id": "peedsFc7RS7s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c04d8ce4-cb46-4bb7-9a45-715551a11429"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Poll Time \n",
        "\n",
        "What is the <b>type</b> of the variable letters defined below ?\n",
        "\n",
        "letters = \"ABACBS\"\n"
      ],
      "metadata": {
        "id": "tUz1brdPN6cu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Strings\n",
        "`str` stands for \"string\". These hold sequences of characters. Characters are not limited to letters but, also numbers, punctuation and emojiis!"
      ],
      "metadata": {
        "id": "LrNrEqbpOz9V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "words_words=\"Python strings are UTF-8 <3 \""
      ],
      "metadata": {
        "id": "nohUxGSYVpLZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#print the string\n",
        "print(words_words)"
      ],
      "metadata": {
        "id": "vSh0q8ZnVxmf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7f25a5f4-21e7-4594-dd34-8814394c14d7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python strings are UTF-8 <3 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#what type is it\n",
        "type(words_words)"
      ],
      "metadata": {
        "id": "hXcXZkQXVx7n",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "deb66e48-934c-46cc-8c3d-0f309e48da63"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Operators "
      ],
      "metadata": {
        "id": "qvyoV-UHO1an"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can perform mathematical calculations in Python using the basic operators such as: \n",
        "\n",
        "##### + - * / % **\n"
      ],
      "metadata": {
        "id": "KxWZH-b7V26j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#addition\n",
        "2+2"
      ],
      "metadata": {
        "id": "nzMrjQqeZVXW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aa93e0c7-ee7f-4948-d502-4c0784e00a2e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#multiplication\n",
        "6*145"
      ],
      "metadata": {
        "id": "s1S0cXJAbgBg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9ce54312-53a8-494f-983e-2b5af731132f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "870"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#power\n",
        "8**789"
      ],
      "metadata": {
        "id": "Tp7TVhC-bhWq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "654279f6-72cc-4199-8267-396d930b07a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "34514353004048826885504379648003866504545218716100012512887166177026352534370841541962887882501289866325841638561707331766897031691050608333957460427033539970294439535876702952471732553659998595663644745155016713628313452425984909782081990174307591624993749579100130456318398090982815078162452007632470130691334908608531591427734030915851830575474874482280253468219207395528369339077139237178924637556985496275398612686731128467281887462316631160226001821395479523833586086502488859219359045000405140507016244667252934364031433606290733177233518426837335038979332193267723253000815065275439846928505916844052298665056194386833699440777271073682443908318576459257064547325048882423449738412777426102675653869436928"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Modulo\n",
        "13%6"
      ],
      "metadata": {
        "id": "fVP5CtH8V2CF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aadad59f-1c2b-43d1-9685-cd2dd9678f67"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# int + int = ?\n",
        "a=5\n",
        "print(a+4)\n",
        "type(a+4)"
      ],
      "metadata": {
        "id": "aDqq2EjZWQS6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "31daabab-b1c1-4c9d-d94c-b58fd8739429"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# int + float = ?\n",
        "a=3\n",
        "print(a+3.2)\n",
        "type(a+3.2)"
      ],
      "metadata": {
        "id": "4JJvEUBwWQvE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1255e5ea-c186-48c1-8d95-bda6f312143d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6.2\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# int + str = ?\n",
        "name=\"barbie\"\n",
        "print(name+1)"
      ],
      "metadata": {
        "id": "ksRBZ5MgWwK8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "outputId": "e349a9aa-2179-4c38-9ec6-1e03792ce0c2"
      },
      "execution_count": null,
      "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-35-bfb80f99988d>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# int + str = ?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"barbie\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#str(int) + str =?\n",
        "str(4)+ \"ken\""
      ],
      "metadata": {
        "id": "IYxP1ySCWyF3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "670efcdf-5e27-477f-e5b8-3f89ea827435"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'4ken'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# demonstrate int += 1\n",
        "number=4\n",
        "number+=1\n",
        "print(number)"
      ],
      "metadata": {
        "id": "fpdi2x8wW6-c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "86c05c74-0b5c-4832-a35b-faceccbc9e13"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Boolean operators\n",
        "Boolean logic means your result can one of two values, True or False. \n",
        "\n",
        "We can also use comparison and logic operators: <b> <, >, ==, !=, <=, >=  </b> and statements of identity such as <b> and, or, and not. </b> These will evaluate the two values and output True and False."
      ],
      "metadata": {
        "id": "uEhNgzLOO6Yx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " # > \n",
        " ken=4\n",
        " barbie=6\n",
        " ken != barbie"
      ],
      "metadata": {
        "id": "FCNqcHhHW9sF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "26d05e90-d90d-46fd-8157-cc3ef1cb05d0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ken = True\n"
      ],
      "metadata": {
        "id": "PGXNM73uXMVp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#or"
      ],
      "metadata": {
        "id": "TFEJqFFaXMK7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Lists and sequence types\n"
      ],
      "metadata": {
        "id": "eoy_8rK6NwWl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Lists\n",
        "Lists are a compound data type made up of smaller parts. \n"
      ],
      "metadata": {
        "id": "k8dXZrS_NxYf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " #form a list of numbers\n",
        " numbers = [4,5,67]"
      ],
      "metadata": {
        "id": "UrXhfLZbZNM8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#find the length\n",
        "len(numbers)"
      ],
      "metadata": {
        "id": "GrmnqunbZPrj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d100d537-9434-433d-c8ed-99a051181d99"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#lists can contain multiple data types\n",
        "list_of_cats = [\"Persian\", 5, 6]\n",
        "#write a mixed list including a list with a list\n",
        "list_of_cats = [\"Persian\", 5, [6,4.3,5]]\n",
        "len(list_of_cats)"
      ],
      "metadata": {
        "id": "yPI1UW0dbr8z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aecc0582-5102-4890-8eb1-e57f1371591d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#these can be retrieved by their index \n",
        "list_of_cats[1]"
      ],
      "metadata": {
        "id": "9oTHoLrZb1mi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "34fd51ae-51a8-4240-8965-89f518d95df5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#in python the first item in an index is always zero\n",
        "list_of_cats[0]"
      ],
      "metadata": {
        "id": "Q7HMhuP_b4XW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "3f644ab3-1070-4c63-ebd4-76ff1091c7c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Persian'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#you can assign a new value to any position on the list\n",
        "list_of_cats[0] = \"Siamese\""
      ],
      "metadata": {
        "id": "ZVKGxmmBcBzB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#print  the new list\n",
        "print(list_of_cats)"
      ],
      "metadata": {
        "id": "FB1OkzkTcIfa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c238d645-8ce8-4e03-ab87-7bb6b77e7185"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Siamese', 5, [6, 4.3, 5]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#you can append items to the end of the list\n",
        "list_of_cats.append(\"Fluffy\")"
      ],
      "metadata": {
        "id": "9nHzKlzZcKs0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(list_of_cats)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8W_B5Nut0F9E",
        "outputId": "a3687b1f-d2f7-4670-a20c-2f46ca85720c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Siamese', 5, [6, 4.3, 5], 'Fluffy']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#you can add multiple items to the end of a list with extend\n",
        "list_of_cats.extend([1,2])\n",
        "\n",
        "print(len(list_of_cats))\n",
        "print(list_of_cats)"
      ],
      "metadata": {
        "id": "TwUe0bQNcOFf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "88826f0b-3c1a-47c6-e1ef-c505776d3748"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n",
            "['Siamese', 5, [6, 4.3, 5], 'Fluffy', 1, 2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#assign a list of dog breeds to variable \n",
        "list_of_dogs = [\"shitz tzu\",\"golden retriever\",\"chihauha\"]\n",
        "#print the third entry in the list of dogs\n",
        "print(list_of_dogs[2])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C6YL8ckR0ZoM",
        "outputId": "cf7c807c-4b53-45b0-d947-149f464a5588"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "chihauha\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#assign a list of animals to variable list_of_safari\n",
        "list_of_safari=[\"elephant\",\"hippo\",\"lion\"]\n",
        "\n",
        "#print the first entry in the list\n",
        "print(list_of_safari[0])\n",
        "\n",
        "#change the second entry in the list and print it\n",
        "list_of_safari[1]=\"scottish_terrier\"\n",
        "print(list_of_safari[1])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kZcQkTIZ3m9l",
        "outputId": "2c597c01-5626-41b1-8cd6-0ab62024048c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "elephant\n",
            "scottish_terrier\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#you can also access the values from a negative index \n",
        "#for example list_of_safari can be accessed [-3] --> [-1]\n",
        "\n",
        "#print of the second to last entry in the list\n",
        "\n",
        "print(list_of_safari[-2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XtT0VhgQ-jQq",
        "outputId": "95c83047-195f-4cb1-bf31-63f97e195a43"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "scottish_terrier\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loops "
      ],
      "metadata": {
        "id": "puoowQLSPOBI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A **for loop** can be used to access the elements in a list or other Python data structure one at a time. We will learn about loops in another lesson.\n",
        "\n",
        "Indentation is very important in Python. Note that the second line in the example above is indented, indicating the code that is the body of the loop.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "TBoJxiBtcYLG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list_of_numbers=[6,4,5]\n",
        "for num in list_of_numbers:\n",
        "  print(num)"
      ],
      "metadata": {
        "id": "tTq5oNiFcU0w",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f7ba906f-31a0-48de-bc16-a5684feaaecb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "  type(list_of_numbers)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1pSLQs8I3Fxj",
        "outputId": "b9e11e6c-170b-4581-c096-b104a7082ff2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "To find out what methods are available for an object, we can use the built-in help command:\n",
        "\n"
      ],
      "metadata": {
        "id": "Tf9gHOrwce2s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#help of list\n",
        "help(list_of_numbers)"
      ],
      "metadata": {
        "id": "sm--S9IGAWkU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "984d5993-f00f-4e7f-cee4-b981c271c614"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on list object:\n",
            "\n",
            "class list(object)\n",
            " |  list(iterable=(), /)\n",
            " |  \n",
            " |  Built-in mutable sequence.\n",
            " |  \n",
            " |  If no argument is given, the constructor creates a new empty list.\n",
            " |  The argument must be an iterable if specified.\n",
            " |  \n",
            " |  Methods defined here:\n",
            " |  \n",
            " |  __add__(self, value, /)\n",
            " |      Return self+value.\n",
            " |  \n",
            " |  __contains__(self, key, /)\n",
            " |      Return key in self.\n",
            " |  \n",
            " |  __delitem__(self, key, /)\n",
            " |      Delete self[key].\n",
            " |  \n",
            " |  __eq__(self, value, /)\n",
            " |      Return self==value.\n",
            " |  \n",
            " |  __ge__(self, value, /)\n",
            " |      Return self>=value.\n",
            " |  \n",
            " |  __getattribute__(self, name, /)\n",
            " |      Return getattr(self, name).\n",
            " |  \n",
            " |  __getitem__(...)\n",
            " |      x.__getitem__(y) <==> x[y]\n",
            " |  \n",
            " |  __gt__(self, value, /)\n",
            " |      Return self>value.\n",
            " |  \n",
            " |  __iadd__(self, value, /)\n",
            " |      Implement self+=value.\n",
            " |  \n",
            " |  __imul__(self, value, /)\n",
            " |      Implement self*=value.\n",
            " |  \n",
            " |  __init__(self, /, *args, **kwargs)\n",
            " |      Initialize self.  See help(type(self)) for accurate signature.\n",
            " |  \n",
            " |  __iter__(self, /)\n",
            " |      Implement iter(self).\n",
            " |  \n",
            " |  __le__(self, value, /)\n",
            " |      Return self<=value.\n",
            " |  \n",
            " |  __len__(self, /)\n",
            " |      Return len(self).\n",
            " |  \n",
            " |  __lt__(self, value, /)\n",
            " |      Return self<value.\n",
            " |  \n",
            " |  __mul__(self, value, /)\n",
            " |      Return self*value.\n",
            " |  \n",
            " |  __ne__(self, value, /)\n",
            " |      Return self!=value.\n",
            " |  \n",
            " |  __repr__(self, /)\n",
            " |      Return repr(self).\n",
            " |  \n",
            " |  __reversed__(self, /)\n",
            " |      Return a reverse iterator over the list.\n",
            " |  \n",
            " |  __rmul__(self, value, /)\n",
            " |      Return value*self.\n",
            " |  \n",
            " |  __setitem__(self, key, value, /)\n",
            " |      Set self[key] to value.\n",
            " |  \n",
            " |  __sizeof__(self, /)\n",
            " |      Return the size of the list in memory, in bytes.\n",
            " |  \n",
            " |  append(self, object, /)\n",
            " |      Append object to the end of the list.\n",
            " |  \n",
            " |  clear(self, /)\n",
            " |      Remove all items from list.\n",
            " |  \n",
            " |  copy(self, /)\n",
            " |      Return a shallow copy of the list.\n",
            " |  \n",
            " |  count(self, value, /)\n",
            " |      Return number of occurrences of value.\n",
            " |  \n",
            " |  extend(self, iterable, /)\n",
            " |      Extend list by appending elements from the iterable.\n",
            " |  \n",
            " |  index(self, value, start=0, stop=9223372036854775807, /)\n",
            " |      Return first index of value.\n",
            " |      \n",
            " |      Raises ValueError if the value is not present.\n",
            " |  \n",
            " |  insert(self, index, object, /)\n",
            " |      Insert object before index.\n",
            " |  \n",
            " |  pop(self, index=-1, /)\n",
            " |      Remove and return item at index (default last).\n",
            " |      \n",
            " |      Raises IndexError if list is empty or index is out of range.\n",
            " |  \n",
            " |  remove(self, value, /)\n",
            " |      Remove first occurrence of value.\n",
            " |      \n",
            " |      Raises ValueError if the value is not present.\n",
            " |  \n",
            " |  reverse(self, /)\n",
            " |      Reverse *IN PLACE*.\n",
            " |  \n",
            " |  sort(self, /, *, key=None, reverse=False)\n",
            " |      Sort the list in ascending order and return None.\n",
            " |      \n",
            " |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n",
            " |      order of two equal elements is maintained).\n",
            " |      \n",
            " |      If a key function is given, apply it once to each list item and sort them,\n",
            " |      ascending or descending, according to their function values.\n",
            " |      \n",
            " |      The reverse flag can be set to sort in descending order.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Class methods defined here:\n",
            " |  \n",
            " |  __class_getitem__(...) from builtins.type\n",
            " |      See PEP 585\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Static methods defined here:\n",
            " |  \n",
            " |  __new__(*args, **kwargs) from builtins.type\n",
            " |      Create and return a new object.  See help(type) for accurate signature.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data and other attributes defined here:\n",
            " |  \n",
            " |  __hash__ = None\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tuples"
      ],
      "metadata": {
        "id": "FI0U4jefPQa-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A tuple is similar to a list in that it's an ordered sequence of elements. However, tuples can not be changed once created (they are \"immutable\"). Tuples are made by placing comma-separated values inside parentheses ().\n",
        "\n"
      ],
      "metadata": {
        "id": "P1nQMflKcv-1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# tuples_are_immutable = (\"bar\", 100, 200, \"foo\")\n",
        "tuples_example = (\"bar\", 100, 400, \"help\")"
      ],
      "metadata": {
        "id": "Af3sx41Jct5f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#print one element of tuple\n",
        "print(tuples_example[3])"
      ],
      "metadata": {
        "id": "_xpBUGdudTpb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "65fddf45-ae83-4799-989b-bbd01e2115b4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "help\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#reassign a different value to element of a tuple\n",
        "tuples_example[3]=\"hello\""
      ],
      "metadata": {
        "id": "9TxahFfrdTax",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 186
        },
        "outputId": "22eca5e1-78aa-48ee-f2f7-6a6b6f2e370d"
      },
      "execution_count": null,
      "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-60-d05b5a7a7b59>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#reassign a different value to element of a tuple\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtuples_example\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Dictionary\n",
        "\n",
        "Dictionaries are used to store key-value pairs. They are unordered.\n",
        "\n",
        "The `items` method returns a sequence of the key-value pairs as tuples. `values` returns a sequence of just the values. `keys` returns a sequence of just the keys.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "1LM_XFaQPSgi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dogma = {'DNA': 1, 'RNA': 2, 'Protein': 3, 'key':5}\n",
        "dogma"
      ],
      "metadata": {
        "id": "_Iun9Frrcuda",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff588f1f-c977-4eae-b2d9-d31c30ec059d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'DNA': 1, 'RNA': 2, 'Protein': 3, 'key': 5}"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#print a value of the dictionary using the key\n",
        "dogma['DNA']"
      ],
      "metadata": {
        "id": "0_qSvnr-fNE-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "57a03aab-91f4-41f8-9c02-f879b9097ce5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#reassign a value of dictionary\n",
        "dogma['RNA'] =16"
      ],
      "metadata": {
        "id": "YlVIvMx1fVUm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#print the values only\n",
        "print(dogma)"
      ],
      "metadata": {
        "id": "FAEm4H-Yfzk1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37f25d27-5834-4bf9-f146-d707543665a8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'DNA': 1, 'RNA': 16, 'Protein': 3, 'key': 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dogma.items()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ocrNj0XH6D6a",
        "outputId": "9a008b33-8525-4c54-b466-e08191498fee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_items([('DNA', 1), ('RNA', 16), ('Protein', 3), ('key', 5)])"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#print the keys only\n",
        "dogma.keys()"
      ],
      "metadata": {
        "id": "0RTunIJaf2XO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f69c28ff-7130-4544-df06-29563781586a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_keys(['DNA', 'RNA', 'Protein', 'key'])"
            ]
          },
          "metadata": {},
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#print the values only\n",
        "dogma.values()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KRBgy8_G6OZA",
        "outputId": "ed863a1c-5975-4fb4-fde5-e99f18c31b3f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_values([1, 16, 3, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#get the length of the dictionary\n",
        "len(dogma)"
      ],
      "metadata": {
        "id": "NB4DlLTff52K",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5874f5d9-bbdd-468e-fcd0-04f44ccd5691"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dict_of_dicts = {'first': {1:2, 2: 4, 4: 8, 8: 16}, 'second': {'a': 2.2, 'b': 4.4}}\n",
        "dict_of_dicts #an example of a more compliated dictionary"
      ],
      "metadata": {
        "id": "hmnGn9Wnf9Vq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37b23d0f-64a1-4df6-95c5-19078a4a256f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'first': {1: 2, 2: 4, 4: 8, 8: 16}, 'second': {'a': 2.2, 'b': 4.4}}"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "# Poll Time\n",
        "\n",
        "jam_ratings = {'Plum': 6, 'Apricot': 2, 'Strawberry': 8}\n",
        "\n",
        "\n",
        "How would you change the value associated with the key Apricot to 9?\n",
        "\n",
        "- jam_ratings = {'apricot': 9}\n",
        "- jam_ratings[9] = 'Apricot'\n",
        "- jam_ratings['Apricot'] = 9\n",
        "- jam_ratings[2] = 'Apricot'"
      ],
      "metadata": {
        "id": "orfpWoUQgFvH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "jam_ratings = {'Plum': 6, 'Apricot': 2, 'Strawberry': 8}"
      ],
      "metadata": {
        "id": "Bb-Y3FWC-0XD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "jam_ratings['Apricot']=9"
      ],
      "metadata": {
        "id": "2JCN-0kzAfYN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(jam_ratings)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xrUercyjAfDo",
        "outputId": "60626dca-8579-4554-dd2d-94b31fe8315a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Plum': 6, 'Apricot': 9, 'Strawberry': 8}\n"
          ]
        }
      ]
    }
  ]
}