03_Python_spring_2022/01_Python_computational_notebooks_and_syntax.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "01_Python computational notebooks and syntax.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PVtJvcEPfwre"
      },
      "source": [
        "# Computational Notebooks and Beginner Syntax with Python \n",
        "February 23 (in person) and February 24 (zoom) at 3:00 PM \\\n",
        "Vincent Scalfani and Lance Simpson \\\n",
        "*The University of Alabama Libraries* \\\n",
        "[Contact Information on UA Libraries Directory](https://www.lib.ua.edu/#/staffdir?liaison=1&department=Rodgers%20Library%20for%20Science%20and%20Engineering)\n",
        "\n",
        "\n",
        "**Today, attendees will learn how to:**\n",
        "\n",
        "* Work with Python in Google Colaboratory\n",
        "* Format notebooks\n",
        "* Get help in Python and view documentation\n",
        "* Understand basic Python syntax and create variables\n",
        "* Import Python libraries\n",
        "* Save and share notebooks\n",
        "* (time permitting) - Load data into Colaboratory notebooks\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LA4Pn7aEWVGi"
      },
      "source": [
        "# Annoucements\n",
        "\n",
        "## Upcoming Workshops\n",
        "\n",
        "### March 9 and 10 - Defining Custom Functions and Automating Tasks with Python\n",
        "\n",
        "**Option 1: Wednesday, 3/09/2022, at 3:00 p.m.**\n",
        "\n",
        ">**Mode:** In-person, [Rodgers Library for Science and Engineering Scholars’ Station](https://map.concept3d.com/?id=1222#!m/324492)\n",
        "\n",
        ">**Registration Link:** https://ua.libcal.com/calendar/instruction/python_spring_2022_2\n",
        "\n",
        "**Option 2: Thursday, 3/10/2022, at 3:00 p.m.**  \n",
        ">**Mode:** Virtual, Zoom \n",
        "\n",
        ">**Registration Link:**\n",
        "https://ua-edu.zoom.us/meeting/register/tZwpdO-vqjwsG9dqdjZKg09ZFpZSrBluc5YV \n",
        "\n",
        "### March 30 and 31 - Plotting and Working with Data with Python\n",
        "\n",
        "**Option 1: Wednesday, 3/30/2022, at 3:00 p.m.**\n",
        ">**Mode:** In-person, [Rodgers Library for Science and Engineering Scholars’ Station](https://map.concept3d.com/?id=1222#!m/324492) \n",
        "\n",
        ">**Registration Link:** https://ua.libcal.com/calendar/instruction/python_spring_2022_3  \n",
        "\n",
        "**Option 2: Thursday, 3/31/2022, at 3:00 p.m.**  \n",
        ">**Mode:** Virtual, Zoom \n",
        "\n",
        ">**Registration Link:** https://ua-edu.zoom.us/meeting/register/tZ0rf-yvqj4sHdWcUUGlD6Hge71_T3g3kZuQ  \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IcxYmdGdgopl"
      },
      "source": [
        "# What is Google Colaboratory (Colab) [1]?\n",
        "\n",
        "1. Online Jupyter based environment for Python programming\n",
        "\n",
        "2. It is free.\n",
        "\n",
        "3. No setup or local installations are necassary. Code is run on a temporary virtual machine provided by Colab service.\n",
        "\n",
        "4. You can use Chrome, Firefox, or Safari. Other browsers may be supported.\n",
        "\n",
        "3. A \"Pro\" version is available if more computing resources are needed.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "[1] See the Google Research FAQ: https://research.google.com/colaboratory/faq.html\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KKiVnNKYjgW6"
      },
      "source": [
        "# Setup For Today\n",
        "\n",
        "If you would like to follow along intractively with us today:\n",
        "\n",
        "1. Go to the link provided for this Colab notebook. \n",
        "\n",
        "2. Save a copy to your Google Drive. You should then be able to run and edit the code interactively."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CydB4KKCr6v7"
      },
      "source": [
        "# Getting Started\n",
        "For good luck and to make sure our Colab Notebook connects to a virtual machine:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nxCUiSxSuvPW"
      },
      "source": [
        "print('Hello World!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hxlk2mnsy2aa"
      },
      "source": [
        "## Working with Text in Colab"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oL7Bw2r5wvRJ"
      },
      "source": [
        "### In Code Cells"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x7GbecKdwRay"
      },
      "source": [
        "# This is a Code cell\n",
        "# Python will ignore any text after a `#` symbol\n",
        "# Text comments can be on their own line like this:\n",
        "\n",
        "# Let's say Hi!\n",
        "print(\"Hello World!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-A5eHUMhxlTY"
      },
      "source": [
        "# Text comments can also be placed after code on same line:\n",
        "print(\"Hello World!\") # Let's say Hi!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iFeItODYw-nU"
      },
      "source": [
        "### In Text Cells [2,3]\n",
        "\n",
        "This is a Text Cell. Text Cells use Markdown formatting, which is a markup language [2,3]. The basics are straightforward:\n",
        "\n",
        "```markdown\n",
        "**bold text**\n",
        "```\n",
        "**bold text**\n",
        "\n",
        "\\\n",
        "\n",
        "```markdown\n",
        "*Italics*\n",
        "```\n",
        "*Italics*\n",
        "\n",
        "\\\n",
        "\n",
        "Headings use `#` and automatically populate the Colab Table of Contents.\n",
        "\n",
        "```markdown\n",
        "# Heading 1\n",
        "## Heading 2 (under 1)\n",
        "### Heading 3 (under 2)\n",
        "```\n",
        "\n",
        "# Heading 1\n",
        "## Heading 2 (under 1)\n",
        "### Heading 3 (under 2)\n",
        "\n",
        "\\\n",
        "\n",
        "List markup:\n",
        "\n",
        "```markdown\n",
        "1. Item one\n",
        "2. Item two\n",
        "3. Item three\n",
        "```\n",
        "1. Item one\n",
        "2. Item two\n",
        "3. Item three\n",
        "\n",
        "Bullets:\n",
        "\n",
        "```markdown\n",
        "* Item one\n",
        "* Item two\n",
        "* Item three\n",
        "```\n",
        "* Item one\n",
        "* Item two\n",
        "* Item three\n",
        "\n",
        "\\\n",
        "\n",
        "\n",
        "Links can be added as standard URLs:\n",
        "\n",
        "https://github.com/ualibweb/UALIB_Workshops\n",
        "\n",
        "Or they can be renamed like this:\n",
        "\n",
        "```markdown\n",
        "[UALIB GutHub Repository](https://github.com/ualibweb/UALIB_Workshops)\n",
        "```\n",
        "\n",
        "[UALIB GutHub Repository](https://github.com/ualibweb/UALIB_Workshops)\n",
        "\n",
        "\\\n",
        "\n",
        "Code blocks can be incorporated with three backticks.\n",
        "\n",
        "\n",
        "````\n",
        "```python\n",
        "print(\"Hello World!\")\n",
        "```\n",
        "````\n",
        "\n",
        "```python\n",
        "print(\"Hello World!\")\n",
        "```\n",
        "\n",
        "A single backtick,  `` ` ``, is used for inline code:\n",
        "\n",
        "The Python function \\`print`.\n",
        "\n",
        "The Python function `print`.\n",
        "\n",
        "\\\n",
        "\n",
        "**References**\n",
        "\n",
        "[2] https://colab.research.google.com/notebooks/markdown_guide.ipynb\n",
        "\n",
        "[3] https://docs.github.com/en/github/writing-on-github/basic-writing-and-formatting-syntax\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UCo-hX2svX60"
      },
      "source": [
        "## Interrupt Code Execution [4]\n",
        "\n",
        "Before we get too far, it is useful to know how to stop code execution in Colab. Consider this simple example where we print numbers 0-99 wth a 1 sec delay between each print. What if we made a mistake or the code is taking too long?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LXlKu7EP57_q"
      },
      "source": [
        "# Stop a code execution with:\n",
        "# Select Runtime > Interrupt Execution or click on stop.\n",
        "import time\n",
        "nums = list(range(1,100))\n",
        "for num in nums:\n",
        "  print(num)\n",
        "  time.sleep(1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ujp7M3QKn0Kr"
      },
      "source": [
        "[4] https://colab.research.google.com/notebooks/basic_features_overview.ipynb"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rjUiAUCRIdYm"
      },
      "source": [
        "# Getting Help in Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LE2z8LkbPvFV"
      },
      "source": [
        "## Web Documentation\n",
        "\n",
        "We recommend starting out with viewing the online web-based documentation for Python: https://docs.python.org/3/. See also the Library Reference section for built-in Python functions: https://docs.python.org/3/library/index.html\n",
        "\n",
        "\\\n",
        "Moreover, when using new libraries, start with the available online documentaion, for example, here is the documentation for the pandas data analysis and manipulation library: https://pandas.pydata.org/docs/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "158F0265bdgZ"
      },
      "source": [
        "## help() function [5,6]\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bj3uj3FFbpz4"
      },
      "source": [
        "# If you know the name of the function, use the help() function \n",
        "# to display the docstring\n",
        "help(sorted)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5JeqnBMYbrid"
      },
      "source": [
        "# using a question mark will show the help in a pop-up Colab window\n",
        "sorted?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sbsnKHqJjjcI"
      },
      "source": [
        "# You may have noticed that Colab shows recommedations as you type.\n",
        "# These can be useful, especially for exploring operations of objects.\n",
        "\n",
        "a = [6,3,0,5] # this creates a list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ghKIDwkKbrlt"
      },
      "source": [
        "# now if we type `a` followed by a period `.`, the available attributes/methods\n",
        "# will show up. We can select one we are interested in and add a ? for info\n",
        "a.pop?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IKX2wIq_oR6i"
      },
      "source": [
        "For more help information, see:\n",
        "\n",
        "[5] https://jakevdp.github.io/PythonDataScienceHandbook/01.01-help-and-documentation.html\n",
        "\n",
        "[6] https://colab.research.google.com/notebooks/basic_features_overview.ipynb"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bCGPKBj5pJ0D"
      },
      "source": [
        "## dir() function [7]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NWcaXHRmmHx-"
      },
      "source": [
        "# The Python dir() function is useful for exploring modules [7].\n",
        "# this prints a list of available functions and variables\n",
        "# example with time module\n",
        "import time\n",
        "dir(time)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fVd0JnzlqTLT"
      },
      "source": [
        "[7] https://stackoverflow.com/questions/139180/how-to-list-all-functions-in-a-python-module\n",
        "\n",
        "Note that if you are unfamiliar with the module, it may be eaiser to explore the module on the web: https://docs.python.org/3/library/time.html?highlight=time#module-time"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k_i6yM2fmH1e"
      },
      "source": [
        "# now we can use help() to get more information about a particular function\n",
        "help(time.sleep)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NtZuaGPRRMDh"
      },
      "source": [
        "# Basic Python Syntax [8]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_uWn5gfqRGZ_"
      },
      "source": [
        "# assignments\n",
        "h = 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0w-DBcUpRGgp"
      },
      "source": [
        "# You can continue statements on a new line by enclosing with parentheses\n",
        "k = (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9\n",
        "     + 10 + 11 + 12 + 13 + 14 + 15)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YJYrQCThRGj5"
      },
      "source": [
        "# Parentheses are also used for grouping\n",
        "5 * (1 + 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zbr4cuOKRGmw"
      },
      "source": [
        "# note that output is suppressed by defualt\n",
        "# use the print function or type the variable name\n",
        "k"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MmDb3ADQRGp4"
      },
      "source": [
        "# each statement is generally written on a new line\n",
        "a = 1\n",
        "b = 2\n",
        "\n",
        "# alternatively, you can terminate statements with a semicolon\n",
        "# and put multiple statements on one line, like this:\n",
        "\n",
        "a = 1; b = 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pnrnwFCMRGsu"
      },
      "source": [
        "# Indentation is important\n",
        "\n",
        "x = 1000\n",
        "if x < 2:\n",
        "      y = x + 1\n",
        "      print(x) # here print(x) will only be executed if x < 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E2fMPmJXRw_2"
      },
      "source": [
        "x = 1000\n",
        "if x < 2:\n",
        "   y = x + 1\n",
        "print(x) # here print(x) is outside the block and will always be executed."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6idKR2jZRxG4"
      },
      "source": [
        "# note that spaces on the same line do not matter\n",
        "x = 1 + 10\n",
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BXSDmgoURxOC"
      },
      "source": [
        "x = 1             +          10\n",
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZECHScKCRG0g"
      },
      "source": [
        "# functions are called with parentheses\n",
        "print(\"Hello World!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eJbbFUxLRG86"
      },
      "source": [
        "# empty parentheses are used when a function should be evaluated\n",
        "# even with no argument input\n",
        "\n",
        "myList = [23, 1, 45, 9]\n",
        "myList.reverse() # the () indicates to evaluate reverse function with no arguments\n",
        "print(myList)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M5rEYyXrSZqu"
      },
      "source": [
        "[8] Basic Python Syntax section adapted from https://nbviewer.jupyter.org/github/jakevdp/WhirlwindTourOfPython/blob/master/02-Basic-Python-Syntax.ipynb"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FJJUjIFDxP6p"
      },
      "source": [
        "# Python Variables [9,10]\n",
        "\n",
        "Python uses the `=` symbol to assign values to names."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YI6tTUBtxPwc"
      },
      "source": [
        "## Simple Variables\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kgIqVn0HGmSu"
      },
      "source": [
        "### Integers\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GNkr9TpBGrOn"
      },
      "source": [
        "x = 5\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qa_EMobyGzCB"
      },
      "source": [
        "# use the type function to view type\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BkMbRKpJJVPF"
      },
      "source": [
        "Variables are stored between cells"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0poQ5LXfJYJU"
      },
      "source": [
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hL9GhcBWJYRS"
      },
      "source": [
        "# overwrite x\n",
        "x = 7\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5CXdGsSXLhoK"
      },
      "source": [
        "### Floating Point Numbers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7YwXQdFnJYXY"
      },
      "source": [
        "a = 1.825\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gH7eGjJ-JYbE"
      },
      "source": [
        "type(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VLED13O7L4NC"
      },
      "source": [
        "# we can also use the float function\n",
        "b = float(2)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fWNUkdHZL4T-"
      },
      "source": [
        "type(b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2TjxVLSkN_QC"
      },
      "source": [
        "### Strings\n",
        "\n",
        "Python uses single `' '` or double quotes `\" \"` to create strings"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ie3SEA9gL4aQ"
      },
      "source": [
        "s1 = \"Thanks for coming to our workshop!\"\n",
        "print(s1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4K0ZaBU0Ob0p"
      },
      "source": [
        "s2 = 'single quotes work too'\n",
        "s2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nwbXywJhOb9h"
      },
      "source": [
        "type(s2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V8qceElzO8SX"
      },
      "source": [
        "# double quotes are sometimes required:\n",
        "s3 = \"Wow, that's awesome\"\n",
        "print(s3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EHZxPa9zPj7O"
      },
      "source": [
        "We can index into strings using brackets"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UA5At-waO85q"
      },
      "source": [
        "# get the first character (zero based indexing in Python)\n",
        "s3[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w7xbfmjpO9B_"
      },
      "source": [
        "# get the last character\n",
        "s3[18]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7xyJylqzO9HR"
      },
      "source": [
        "# get the last character, use -1 for end\n",
        "s3[-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pE3sfXb8RIkK"
      },
      "source": [
        "# get a range of charcters using a :\n",
        "# values between indices\n",
        "s3[0:3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8kHBmym6RcxO"
      },
      "source": [
        "# There are many built in functions and methods for strings\n",
        "help(str)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XIqAUGZKRc5O"
      },
      "source": [
        "# length\n",
        "len(s3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h9rYfKMoRc8P"
      },
      "source": [
        "# create a title version\n",
        "s1.title()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cUJ9_LdDTJrH"
      },
      "source": [
        "# lowercase all text\n",
        "s1.lower()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KulN1n8XTJt0"
      },
      "source": [
        "# replace text\n",
        "s1.replace('workshop','zoom lesson',1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pmgrJUMBU1Hr"
      },
      "source": [
        "There are other built in Python types including complex, boolean, and None. See the Python documention for [Built-in Types](https://docs.python.org/3/library/stdtypes.html)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mCuWYhhFxPmS"
      },
      "source": [
        "## Compound Variables"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PGlfR6hhqTzs"
      },
      "source": [
        "### Lists\n",
        "\n",
        "Lists are one of the sequence types in Python and are created by separating values with a comma and enclosing in brackets, `[]`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4JbJAtTLNtII"
      },
      "source": [
        "# create a list with numbers\n",
        "myL = [10, 20, 20, 30, 100, 10, 50]\n",
        "print(myL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "948tMLrl7jMy"
      },
      "source": [
        "type(myL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1btdVNNk7upx"
      },
      "source": [
        "# create a list with strings\n",
        "myS = [\"apple\", \"orange\", \"pear\", \"blueberry\"]\n",
        "print(myS)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xUJWtJnRsGmF"
      },
      "source": [
        "There are many built-in sequence operations described in the [Python Documention for Sequence Types](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range). Let's try a few:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "th0dnmc48XY1"
      },
      "source": [
        "myL"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y-KTf9pWNtOe"
      },
      "source": [
        "# check if an item is in a list\n",
        "100 in myL"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uMiOyUOgNtSD"
      },
      "source": [
        "\"pear\" in myS"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xoiaDANXNtVA"
      },
      "source": [
        "# get length of list\n",
        "len(myL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a96t49lLthxN"
      },
      "source": [
        "# get min of list\n",
        "min(myL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vpscBJDTth5c"
      },
      "source": [
        "# count occurences of a value\n",
        "myL.count(20)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HemIaDDuth8K"
      },
      "source": [
        "# concatenate a value or another list\n",
        "t = myL + [70, 60]\n",
        "print(t)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bTi647YOth_K"
      },
      "source": [
        "# append a value\n",
        "myL.append(80)\n",
        "myL"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M4xOZpo8tiCP"
      },
      "source": [
        "# sort a list\n",
        "myL.sort()\n",
        "print(myL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oBsog9kZ-QEQ"
      },
      "source": [
        "myS.sort()\n",
        "print(myS)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a42QSlXyNtYE"
      },
      "source": [
        "# reverse a list\n",
        "myL.reverse()\n",
        "print(myL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0vxpqx2SwXHg"
      },
      "source": [
        "### Lists can contain a mix of types"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W7_vgW7kv8yA"
      },
      "source": [
        "# you can mix types of data and even have lists within lists!\n",
        "R = [20, 1.825, 'a string', [37,11,22,41]]\n",
        "print(R)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MAJl3GLixhLz"
      },
      "source": [
        "### List Indexing\n",
        "\n",
        "Python indexing starts at 0 from left to right. When indexing from right to left, the indexing starts at -1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ILOkeZkDv832"
      },
      "source": [
        "myL = [10, 20, 20, 30, 100, 10, 50]\n",
        "print(myL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8vk2bcNVxlJE"
      },
      "source": [
        "# get the 1st value\n",
        "myL[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_Mn83sEMxlMh"
      },
      "source": [
        "# get the 5th value\n",
        "myL[4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4khJuCrRxlP2"
      },
      "source": [
        "# get the last value\n",
        "myL[-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MUTj3VmrxlSu"
      },
      "source": [
        "# get the second to last value\n",
        "myL[-2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cq99L3utxlVb"
      },
      "source": [
        "# get the first four values with a slice\n",
        "myL[0:4] # 4 because we are getting values within the index values"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2q_L17L3zzAj"
      },
      "source": [
        "# replace a value\n",
        "myL[1] = 99\n",
        "print(myL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bFFY7Te3zzDv"
      },
      "source": [
        "# replace values\n",
        "myL[4:7] = [1000, 1001, 1002]\n",
        "print(myL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_4tysVIt9mxB"
      },
      "source": [
        "R"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xdPIDWZDzzMe"
      },
      "source": [
        "# to index lists within lists, add a second set of brackets\n",
        "# for example, get the i character within 'a string'\n",
        "\n",
        "R = [20, 1.825, 'a string', [37,11,22,41]]\n",
        "R[2][5]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O5aJTMgWxleG"
      },
      "source": [
        "# index out last two elements of [37,11,22,41]\n",
        "R[3][2:4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8R9sHWydE6lV"
      },
      "source": [
        "Python has a variety of other compound data structure types such as tuple, dictionary, set, and more [10]. See the [Python docuemntation](https://docs.python.org/3/library/index.html)\n",
        "\n",
        "\n",
        "Python Variables sections adapted from:\n",
        "\n",
        "[9] http://swcarpentry.github.io/python-novice-gapminder/\n",
        "\n",
        "[10] https://github.com/jakevdp/WhirlwindTourOfPython (see chapters 6 and 7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e4Ry12Vx-koL"
      },
      "source": [
        "# Importing Python Libraries [11]\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t8hSH_HdTTU3"
      },
      "source": [
        "What is a Python Library [11]?\n",
        "\n",
        "\n",
        "* Python Libraries are collections of files (modules) containing functions and variables.\n",
        "\n",
        "* Colab has many Python libraries that can be imported directly such as [NumPy](https://numpy.org/) and [pandas](https://pandas.pydata.org/), which are often used with data analysis.\n",
        "\n",
        "* External libraries can be found on the [Python Package Index (PyPI)](https://pypi.org/).\n",
        "\n",
        "Python [Built-in functions](https://docs.python.org/3/library/functions.html) are always available and generally do not need to be explicity imported. However, there are modules within the [Python Standard Library](https://docs.python.org/3/library/index.html) (e.g., math functions, file format handling, etc.), where we need to import the library module before we can use it.\n",
        "\n",
        "We can use `import` to load a library module:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kJmubAupTA_F"
      },
      "source": [
        "import math\n",
        "# check the help documentation\n",
        "help(math)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xwqb6PDNTmes"
      },
      "source": [
        "Let's try some of the math functionality. We can refer to functions and other things in the module by using a period, `.`, followed by the function or constant name."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M6ZvgC41TBKn"
      },
      "source": [
        "# return absolute value\n",
        "math.fabs(-1.2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q0ScaO-fTBdC"
      },
      "source": [
        "# return square root\n",
        "math.sqrt(9)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LksPJ0efTBgj"
      },
      "source": [
        "# If we leave off math., Python will report a NameError\n",
        "sqrt(9)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oAGMaNLGT293"
      },
      "source": [
        "We can import specific parts from the module using `from`. This then allows us to refer directly to, for example, a specific function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OBP8QaxWTBj1"
      },
      "source": [
        "from math import sqrt\n",
        "sqrt(9)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CwOzfq_wTBqY"
      },
      "source": [
        "# We can also import more than one item at a time\n",
        "from math import sqrt, fabs\n",
        "c = sqrt(9)\n",
        "d = fabs(-1.2)\n",
        "print('c is', c)\n",
        "print('d is', d)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JSJ98eRGUBm3"
      },
      "source": [
        "An alias can be created for library modules."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C25GpRbUTBy5"
      },
      "source": [
        "import math as m\n",
        "# now instead of math., we use the alias, m.\n",
        "m.sqrt(9)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dzCkQ7WxTB6j"
      },
      "source": [
        "# you will almost always see certain libraries (e.g., numpy) \n",
        "# imported as an alias\n",
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HejmUEwcUNV5"
      },
      "source": [
        "Importing specific parts of a module and creating aliases can help shorten programs and (sometimes) improve code readability.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "juRwt_SPVVaD"
      },
      "source": [
        "## Libraries not in Colab\n",
        "\n",
        "If you find that a library you need is not available directly in Colab, see the documention for [Importing a library that is not in Colaboratory](https://colab.research.google.com/notebooks/snippets/importing_libraries.ipynb). You can use `pip` or `apt-get` called from shell (`!`)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H6EKONI1UOhy"
      },
      "source": [
        "[11] This section on libraries was adapted from http://swcarpentry.github.io/python-novice-gapminder/06-libraries/index.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QE35H-VDyShu"
      },
      "source": [
        "# Save and Share Notebooks\n",
        "\n",
        "1. Can share notebooks similarly to other Google services with the 'Share' button, which offers a variety of permissions options.\n",
        "\n",
        "2. Can download Colab notebooks as .ipynb and/or .py format to upload to cloud services (e.g., UA Box) or code repository sites like GitHub. There is also a direct option to save a copy to [GitHub or Google Drive](https://colab.research.google.com/github/googlecolab/colabtools/blob/master/notebooks/colab-github-demo.ipynb).\n",
        "\n",
        "> Tip: Consider backing up the .py file too as this can be easily viewed in any text editor."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N5GWu6blxPZs"
      },
      "source": [
        "# Loading Data into Colab\n",
        "\n",
        "We will review an introductory method, where we can load files from our local system into the Colab virtual machine using the file navigation window. Other more advanced options such as connecting to your Google Drive are described in the Colab Documentation on [External data](https://colab.research.google.com/notebooks/io.ipynb).\n",
        "\n",
        "\n",
        "**Important** \n",
        "\n",
        "All data uploaded to Colab is temporary and deleted when the virtual machine is deleted (~12 hours or less). [See the Colaboratory FAQ](https://research.google.com/colaboratory/faq.html).\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zOYtR_eYlbV-"
      },
      "source": [
        "**Basic File Navigation**\n",
        "\n",
        "When working with data files in Colab, it is useful to know a few unix shell file navigation operations [12]. Shell commands are executed in Colab/Jupyter with the `!` symbol before the command, like `!pwd` to print the working directory, but Jupyter/Colab also has system aliases for many common operations, so you may not need to use `!` before the operation [13,14].\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "29BqGlJYxDwX"
      },
      "source": [
        "**Print the working directory:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "62cZ8D06X_Qh"
      },
      "source": [
        "pwd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w9xCAF0vxTVK"
      },
      "source": [
        "**List the items in the content folder:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-XVfnySZX_bj"
      },
      "source": [
        "ls"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oc8ydLVApiiP"
      },
      "source": [
        "Click on the File Navigation Window on the left to see the content folder. We can probably upload data to `/content` or `sample_data`, but it might be nice to create our own folder for organization. We can use `mkdir` to create a new folder directory. Let's call it `workshop_test`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QliD4e7_X_eh"
      },
      "source": [
        "mkdir workshop_test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IGdYXtiSx8he"
      },
      "source": [
        "**List the items in content folder to see our new folder**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OnY9GAc6ZxRl"
      },
      "source": [
        "ls"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vkXBZML4rPE7"
      },
      "source": [
        "**Uploading Files**\n",
        "\n",
        "Next, we can use the file navigation window to upload data directly to our new folder. Click on the workshop_test folder `three dots > upload`. We'll upload a sample file called alkanes.txt, which is available on the [UALIB_Workshops Python data folder](https://github.com/ualibweb/UALIB_Workshops/tree/master/03_Python_fall_2020/data). Click on the alkanes.txt file, then right click on `Raw > Save Link as`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NrKycajWyYgr"
      },
      "source": [
        "**Change directories into our new folder:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WnmSES0WZ6L9"
      },
      "source": [
        "cd workshop_test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YkfTBuZFypWv"
      },
      "source": [
        "**List contents to see our file:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wLoLsy3AgNTT"
      },
      "source": [
        "ls"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WpTfzyGMy7Bu"
      },
      "source": [
        "**View the alkanes.txt file content with unix `cat`:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GxV9ghDdgfJM"
      },
      "source": [
        "cat alkanes.txt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q63h1wPLzL82"
      },
      "source": [
        "Now if we want to use this data within Python, we can read the data in with the [Python csv import](https://docs.python.org/3/library/csv.html) or use a library like Pandas to read the data into a dataframe (we'll look at this more in Workshop 3). Preview below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OJnP-e9YgfRW"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "alkane_df = pd.read_csv('alkanes.txt', names=['alkane_name', 'mol_formula',\n",
        "                                              'mol_weight'], sep = '\\t' )\n",
        "alkane_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qo3RKlQkayhb"
      },
      "source": [
        "[12] See, for example, http://swcarpentry.github.io/shell-novice/\n",
        "\n",
        "[13] https://colab.research.google.com/notebooks/basic_features_overview.ipynb\n",
        "\n",
        "[14] https://jakevdp.github.io/PythonDataScienceHandbook/01.05-ipython-and-shell-commands.html#Shell-Related-Magic-Commands"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lZyiM4e2Xq_L"
      },
      "source": [
        "# Python Learning Resources\n",
        "\n",
        "We recommend the following resources as a start for further reading. Some content (as referenced and attributed to above) in this workshop have been adapted and derive from them:\n",
        "\n",
        "\n",
        "[1] https://github.com/jakevdp/WhirlwindTourOfPython\n",
        "\n",
        "[CC0-1.0 License](https://github.com/jakevdp/WhirlwindTourOfPython/blob/master/LICENSE)\n",
        "\n",
        "\\\n",
        "\n",
        "[2] http://swcarpentry.github.io/python-novice-gapminder/\n",
        "\n",
        "[CC-BY-4.0 License](http://swcarpentry.github.io/python-novice-gapminder/LICENSE.html)\n",
        "\n",
        "\\\n",
        "\n",
        "In addition, UA Libraries provides access to many Python eBooks. Use [Scout](https://www.lib.ua.edu/scout/) to discover Python eBooks. Start with a search for `python` and limit to ebooks within computer science discipline.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xn9C7o0c8Jbc"
      },
      "source": [
        "# Questions\n",
        "\n",
        "That's it for today, thank you!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dj6tQF-KGrnY"
      },
      "source": [
        "# Notebook Copy\n",
        "\n",
        "An archived version of this notebook is available on our UALIB_Workshops GitHub repository: https://github.com/ualibweb/UALIB_Workshops"
      ]
    }
  ]
}