1_Python_The_Basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyO/XxzgwBh1tRgsvKbkpLMS",
      "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.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 as a package \n",
        "# print the version  by using sys.version"
      ],
      "metadata": {
        "id": "vg5LgNuSfGPB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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": "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": [
        "# use print to print a string"
      ],
      "metadata": {
        "id": "1ez6kEjdPE_C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# what mode are we using now "
      ],
      "metadata": {
        "id": "Ai2u9oQgBMXa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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",
        "\n",
        "#print variable\n"
      ],
      "metadata": {
        "id": "CaUZgf3RPkFM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      ],
      "metadata": {
        "id": "VxHwGT-qRDtg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      ],
      "metadata": {
        "id": "radunqHzRLss"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#what type is it \n"
      ],
      "metadata": {
        "id": "RmaZOpLRRNCG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#assign a decimal to variable\n"
      ],
      "metadata": {
        "id": "F1yf2YKPRPqn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#what type is this \n"
      ],
      "metadata": {
        "id": "peedsFc7RS7s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      ],
      "metadata": {
        "id": "vSh0q8ZnVxmf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#what type is it\n"
      ],
      "metadata": {
        "id": "hXcXZkQXVx7n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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 "
      ],
      "metadata": {
        "id": "nzMrjQqeZVXW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#multiplication using *"
      ],
      "metadata": {
        "id": "s1S0cXJAbgBg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#power using **"
      ],
      "metadata": {
        "id": "Tp7TVhC-bhWq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#modulo using %"
      ],
      "metadata": {
        "id": "fVP5CtH8V2CF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# int + int = ?"
      ],
      "metadata": {
        "id": "aDqq2EjZWQS6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# int + float = ?"
      ],
      "metadata": {
        "id": "4JJvEUBwWQvE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# int + str = ?\n",
        "#str(int) + str =?"
      ],
      "metadata": {
        "id": "ksRBZ5MgWwK8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# assign a value \n",
        "# demonstrate int += 1"
      ],
      "metadata": {
        "id": "fpdi2x8wW6-c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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": [
        " #test out which variables of integers is larger than another \n"
      ],
      "metadata": {
        "id": "FCNqcHhHW9sF"
      },
      "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"
      ],
      "metadata": {
        "id": "UrXhfLZbZNM8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#find the length"
      ],
      "metadata": {
        "id": "GrmnqunbZPrj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#lists can contain multiple data types\n",
        "\n",
        "#write a mixed list including a list with a list"
      ],
      "metadata": {
        "id": "yPI1UW0dbr8z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#these can be retrieved by their index "
      ],
      "metadata": {
        "id": "9oTHoLrZb1mi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#in python the first item in an index is always zero"
      ],
      "metadata": {
        "id": "Q7HMhuP_b4XW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#you can assign a new value to any position on the list "
      ],
      "metadata": {
        "id": "ZVKGxmmBcBzB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#print  the new list"
      ],
      "metadata": {
        "id": "FB1OkzkTcIfa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#you can append items to the end of the list\n"
      ],
      "metadata": {
        "id": "9nHzKlzZcKs0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#you can add multiple items to the end of a list with extend list.extend(anotherlist)\n"
      ],
      "metadata": {
        "id": "TwUe0bQNcOFf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# DIY \n",
        "1. Assign a list of your choosing (e.g. safari animals) to a variable\n",
        "2. Print the third entry in the list\n",
        "3. Change the second entry in the list to \"puggle\".\n",
        "Extension: \n",
        "- You can access the values from a negative index. It can be accessed from [-3] to [-1]\n",
        "Print off the second to last entry in your list. "
      ],
      "metadata": {
        "id": "NdT-W_2sTjgE"
      }
    },
    {
      "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"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "  type(list_of_numbers)"
      ],
      "metadata": {
        "id": "1pSLQs8I3Fxj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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": [
        "# example tuple tuples_are_immutable = (\"bar\", 100, 200, \"foo\")"
      ],
      "metadata": {
        "id": "Af3sx41Jct5f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#print one element of tuple"
      ],
      "metadata": {
        "id": "_xpBUGdudTpb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#reassign a different value to element of a tuple"
      ],
      "metadata": {
        "id": "9TxahFfrdTax"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#print a value of the dictionary using the key "
      ],
      "metadata": {
        "id": "0_qSvnr-fNE-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#reassign a value of dictionary"
      ],
      "metadata": {
        "id": "YlVIvMx1fVUm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#print the items "
      ],
      "metadata": {
        "id": "FAEm4H-Yfzk1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#print the keys only"
      ],
      "metadata": {
        "id": "0RTunIJaf2XO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#print the values only"
      ],
      "metadata": {
        "id": "KRBgy8_G6OZA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#get the length of the dictionary"
      ],
      "metadata": {
        "id": "NB4DlLTff52K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#if you want to have more fun\n",
        "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"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      }
    }
  ]
}