03_Python_fall_2020/notebooks/Rodgers_PythonWorkshop02_functions_Loops_Choices2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Rodgers_PythonWorkshop02_functions_Loops_Choices2.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OxYcTGjds1PM"
      },
      "source": [
        "# Introduction to Python Workshop Series 2 \n",
        "**Functions, Loops, and Conditional Statements**\n",
        "\n",
        "\\\n",
        "March 23 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",
        "* Use Python functions \n",
        "* Define custom functions\n",
        "* Use conditional statements to make choices \n",
        "* Create loops to repeats tasks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kiwHSyYAtQyY"
      },
      "source": [
        "# Annoucements\n",
        "\n",
        "April 6 at 3:00 PM \\\n",
        "**Introduction to Python Workshop Series 3: DataFrames and Plotting Data**\n",
        "\n",
        "[More information and registration here](https://calendar.ua.edu/event/ua_libraries_introduction_to_python_workshop_series_3_dataframes_and_plotting_data_slack_and_github)\n",
        "\n",
        "\n",
        "**Introduction to Python Workshop Series 1: Getting Started**\n",
        "\n",
        "Archived copy here: https://github.com/vfscalfani/UALIB_Workshops\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aob1fF0kufQh"
      },
      "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 in the Zoom chat 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.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DHtEmdnD0nTe"
      },
      "source": [
        "# Using Python Functions [1,2]\n",
        "\n",
        "A brief review of using Python functions from our [first workshop](https://github.com/vfscalfani/UALIB_Workshops/blob/master/03_Python/notebooks/Rodgers_PythonWorkshop01_GettingStarted.ipynb)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MfuNBa0RukOH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "093646c0-2361-41fc-b35c-4ad45287131f"
      },
      "source": [
        "# functions are called with parentheses\n",
        "print(\"Hello World!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SuAtKdrZukQ9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "99a2dd4d-7747-4804-af5d-3194bb72bdec"
      },
      "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() # () evaluates reverse function method with no arguments\n",
        "print(myList)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[9, 45, 1, 23]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L7VqAS0g1ySY"
      },
      "source": [
        "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.) and external libraries, where we need to import the library module before we can use the functions.\n",
        "\n",
        "We can use `import` to load a library module:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BWRuB5ghukWZ"
      },
      "source": [
        "import math\n",
        "# check the help documentation\n",
        "help(math)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-YqnFWSG2TUC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1d5d174b-c0c6-4bbd-8a99-71f014bdadab"
      },
      "source": [
        "# return square root\n",
        "math.sqrt(9)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5PhuFj8q2TW0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "42c6b087-b9d4-4431-938b-3936d25c9503"
      },
      "source": [
        "# import specific parts of a module only\n",
        "from math import sqrt\n",
        "sqrt(9)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OoQa-g5_1aRW"
      },
      "source": [
        "Adapted from \n",
        "\n",
        "[1] https://nbviewer.jupyter.org/github/jakevdp/WhirlwindTourOfPython/blob/master/02-Basic-Python-Syntax.ipynb\n",
        "\n",
        "[2] http://swcarpentry.github.io/python-novice-gapminder/06-libraries/index.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Be8uH1rW4Jwt"
      },
      "source": [
        "# Defining Custom Functions [3]\n",
        "\n",
        "Python functions are defined using the `def` statement. A general Python syntax format for a function looks like this:\n",
        "\n",
        "```python\n",
        "\n",
        "def function_name():\n",
        "    do something\n",
        "```\n",
        "\n",
        "or \n",
        "\n",
        "```python\n",
        "\n",
        "def function_name(param1, parmam2, ...):\n",
        "    do something\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Rtr7uZlOHf5"
      },
      "source": [
        "## Functions without input parameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7eYkpbI7ukY9"
      },
      "source": [
        "def UALIB_address():\n",
        "    print(\"The University of Alabama\")\n",
        "    print(\"University Libraries\")\n",
        "    print(\"Box 870266\")\n",
        "    print(\"Tuscaloosa, AL 35487\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yj0h0a-xgJ9B"
      },
      "source": [
        "In the above function, `UALIB_address` is the function name and `()` contains the function parameters, in this case, there are none. The line containing `def` is completed with a `:`, which is then followed by indented code.\n",
        "\n",
        "To call our new function, type the name of the function with empty parentheses (since no inputs are required):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nvTgtewUukbf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3207287d-2f1a-4d34-b394-4d7c82cda52a"
      },
      "source": [
        "UALIB_address()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The University of Alabama\n",
            "University Libraries\n",
            "Box 870266\n",
            "Tuscaloosa, AL 35487\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "__aT8exChomJ"
      },
      "source": [
        "It is a good idea to add comments to your custom function as a docstring. Enclose comments in triple quotes `\"\"\"` to describe how to use it. There are some guidelines available on how to format docstrings: https://www.python.org/dev/peps/pep-0257/"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "shjuLXjA6mcV"
      },
      "source": [
        "def UALIB_address():\n",
        "    \"\"\" Print The University of Alabama Libraries mailing\n",
        "    address. There are no inputs.\n",
        "    \"\"\"\n",
        "    print(\"The University of Alabama\")\n",
        "    print(\"University Libraries\")\n",
        "    print(\"Box 870266\")\n",
        "    print(\"Tuscaloosa, AL 35487\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7ze2ycRBiC0X",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ca4e1375-18eb-4d49-f638-cd7644f8dc7b"
      },
      "source": [
        "# now we can access the docstring with help()\n",
        "help(UALIB_address)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on function UALIB_address in module __main__:\n",
            "\n",
            "UALIB_address()\n",
            "    Print The University of Alabama Libraries mailing\n",
            "    address. There are no inputs.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8pBw9bSTkdOS"
      },
      "source": [
        "# You can view the original Python source code with two question marks `??`\n",
        "# see: https://jakevdp.github.io/PythonDataScienceHandbook/01.01-help-and-documentation.html\n",
        "UALIB_address??"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7_yYMZ6AOR70"
      },
      "source": [
        "## Functions with input parameters"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "64rZe8eEj3EA"
      },
      "source": [
        "We can also write functions with input parameters. For example, a function that prepends a DOI with `https://doi.org/`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t40BQMfhiC7m"
      },
      "source": [
        "def DOI_link(doi):\n",
        "    \"\"\" returns a doi with url prefix. Input a DOI string\"\"\"\n",
        "    print(\"https://doi.org/\" + doi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4ugBfWAGiC_H",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a67ca068-6e79-4ab5-c25a-3256d3dfb1ef"
      },
      "source": [
        "# try DOI_link function\n",
        "m = \"10.1021/acs.jmedchem.0c01516\"\n",
        "DOI_link(m)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "https://doi.org/10.1021/acs.jmedchem.0c01516\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ekkcaDG2oSlB"
      },
      "source": [
        "Multiple parameters can be incorporated into functions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lw_7onX1iDCa"
      },
      "source": [
        "def id_code(number, location, year):\n",
        "    formatted_id = str(number) + '-' + str(location) + '-' + str(year)\n",
        "    print(formatted_id)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9QTqSEEhAi3P",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "66bbf3cc-8454-457c-da1e-2883ff574403"
      },
      "source": [
        "id_code(34643,\"rodgers\",1981)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "34643-rodgers-1981\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XMQAUjxwqQ--"
      },
      "source": [
        "Note that the output will be formatted with the argument order specificed in the function. If we want to input arguments in a different order, we will need to name the input arguments:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "laD4_p89fVAd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2f11b857-bcc5-41d1-eae6-1d674a468f2d"
      },
      "source": [
        "id_code(location=\"rodgers\", year=1981, number=34643)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "34643-rodgers-1981\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vk_g6g8WrAN6"
      },
      "source": [
        "We can use `return` in functions to output variables/values."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1wxC7jNpfVGY"
      },
      "source": [
        "def pint_to_ounce(v):\n",
        "    \"\"\" converts liquid pints to ounces \"\"\"\n",
        "    vo = v * 16\n",
        "    return vo"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZeEnE0sMrhC9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "55062a87-f4a4-4449-b0f6-dd408323d6ca"
      },
      "source": [
        "pint_to_ounce(4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LeVYD6ewrhFw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3ad4fd80-78d6-435b-f1bf-fe13c48f5c4d"
      },
      "source": [
        "# check the variable returned\n",
        "type(pint_to_ounce(4))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uJOtOTxRww26"
      },
      "source": [
        "When writing functions, it is helpful to figure out the workflow first without a function. For example, let's say we have an [InChI chemical identifier](https://en.wikipedia.org/wiki/International_Chemical_Identifier) and need to write a function to extract out the molecular formula. Here is an example InChI:\n",
        "\n",
        "\\\n",
        "\n",
        "**InChI=1S/C9H8O4/c1-6(10)13-8-5-3-2-4-7(8)9(11)12/h2-5H,1H3,(H,11,12)**\n",
        "\n",
        "\\\n",
        "\n",
        "The molecular formula occurs right after the first `/`, so we can use a string split method. \n",
        "\n",
        "\\\n",
        "\n",
        "*Note: we are using a string approach to extract out the molecular formula from an InChI. InChI is not designed for this and there are certainly more robust methods for getting the molecular formula for chemical substances, so be cautious if you use a method like this...*\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RY1qp4eUrhN3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c13e38b2-a0da-466f-b869-dcdfacc0fb59"
      },
      "source": [
        "# first create a string with the InChI\n",
        "myInChI = \"InChI=1S/C9H8O4/c1-6(10)13-8-5-3-2-4-7(8)9(11)12/h2-5H,1H3,(H,11,12)\"\n",
        "\n",
        "# Next split the string at each `/` and put into a list\n",
        "L = myInChI.split('/')\n",
        "L"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['InChI=1S',\n",
              " 'C9H8O4',\n",
              " 'c1-6(10)13-8-5-3-2-4-7(8)9(11)12',\n",
              " 'h2-5H,1H3,(H,11,12)']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pKdiDgg3fVKB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a4c93e3d-f3f1-4e62-b505-b4793fbc4171"
      },
      "source": [
        "# Now all we need to do is index out the molecular formula at index position 1\n",
        "L[1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'C9H8O4'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UUd3HQC_Ai58"
      },
      "source": [
        "# Next, write a function:\n",
        "def molecular_formula(InChI):\n",
        "    \"\"\" returns molecular formula from a standard InChI input\"\"\"\n",
        "    L = InChI.split('/')\n",
        "    return L[1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OQ6OlgSKAi_m",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "1ed7d92e-682a-4925-c660-fbb98758cc52"
      },
      "source": [
        "# try our new function\n",
        "molecular_formula(\"InChI=1S/C9H8O4/c1-6(10)13-8-5-3-2-4-7(8)9(11)12/h2-5H,1H3,(H,11,12)\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'C9H8O4'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zMUo2rAPawHI"
      },
      "source": [
        "[3] Parts of this section adapted from http://swcarpentry.github.io/python-novice-gapminder/16-writing-functions/index.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O7pFIQ6ABZEy"
      },
      "source": [
        "# Conditional Statements [4,5]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "quUvzQk5R-in"
      },
      "source": [
        "A simplified general Python syntax for conditional statements is as follows:\n",
        "\n",
        "```python\n",
        "\n",
        "if expression1:\n",
        "  do something1\n",
        "elif expression2:\n",
        "  do something2\n",
        "else:\n",
        "  do something3    \n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NVdbhZ-0Olgv"
      },
      "source": [
        "## if"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q0CG3Ae0wR_i"
      },
      "source": [
        "Use an `if` statement to make a choice and determine the direction of code execution. Start the line of code with `if` followed by the condition, then end with a colon, `:`. Conditional statements are often tested with [Comparison Operators](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not) (e.g., `>`) or [sequence operations](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range) (e.g., `x in s`)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lqv46fL1BhU9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d25f2b58-6039-4f1d-aa1d-efcd126ef18f"
      },
      "source": [
        "# if statement with condition met\n",
        "state = 'Alabama'\n",
        "\n",
        "if len(state) > 5:\n",
        "  print(state, 'has more than 5 characters')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Alabama has more than 5 characters\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bhrqpWw3BhlL"
      },
      "source": [
        "# if statement with condition not met\n",
        "state = 'Iowa'\n",
        "\n",
        "if len(state) > 5:\n",
        "  print(state, 'has more than 5 characters')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z-HcCR24OqtS"
      },
      "source": [
        "## else"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qBsSQn4WxXTK"
      },
      "source": [
        "In the above example, the condition is not met, so nothing happens, we can add an `else` condition to create an alternative code execution. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sgESSD9HBh4M",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "840546b0-383e-4e0c-a52a-b822afe0b2c5"
      },
      "source": [
        "# add an else\n",
        "state = 'Iowa'\n",
        "\n",
        "if len(state) > 5:\n",
        "  print(state, 'has more than 5 characters')\n",
        "else:\n",
        "  print(state, 'has less than 5 characters')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Iowa has less than 5 characters\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QzZR2NoKOuEV"
      },
      "source": [
        "## elif "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DctstheEy1UI"
      },
      "source": [
        "Additional conditional tests can be added before `else` with the `elif` statement (else if). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4x61FjIVBh_b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "18ce5636-7b27-4d5c-dccc-d37a2c243d1e"
      },
      "source": [
        "# for example, what if we want to test len(state) == 5\n",
        "state = 'Texas'\n",
        "\n",
        "if len(state) > 5:\n",
        "  print(state, 'has more than 5 characters')\n",
        "elif len(state) == 5:\n",
        "   print(state, 'has 5 characters') \n",
        "else:\n",
        "  print(state, 'has less than 5 characters')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Texas has 5 characters\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8L8sNqkHO-zB"
      },
      "source": [
        "## Testing Multiple True conditions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mk_a_7E87p7s"
      },
      "source": [
        "Next, what if we wanted to add another conditional such as checking if the state variable has 5 characters and contains the letter `a`. You might first try something like this with another `elif` statement. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gsUFA-5sBiCn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3da193ef-b08d-4062-c908-533b65db9acd"
      },
      "source": [
        "state = 'Texas'\n",
        "\n",
        "if len(state) > 5:\n",
        "  print(state, 'has more than 5 characters')\n",
        "elif len(state) == 5:\n",
        "   print(state, 'has 5 characters')\n",
        "elif 'a' in state:\n",
        "   print(state, 'contains the character a') \n",
        "else:\n",
        "  print(state, 'has less than 5 characters')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Texas has 5 characters\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RDTxUY5R-jlG"
      },
      "source": [
        "In the above case, we may have expected to see the following printed:\n",
        "\n",
        "```\n",
        "Texas has 5 characters\n",
        "Texas contains the character a\n",
        "```\n",
        "\n",
        "However, the `if-elif-else` sequence stops once the first condition is True. An alternative would be to rewrite the code with a [boolean operator](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not) or use only `if` statements to test all conditions. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wjoxa8uH7W0S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1acc71c7-fcb3-4c2c-9edb-56ebc9e39514"
      },
      "source": [
        "# with boolean operator\n",
        "state = 'Texas'\n",
        "\n",
        "if len(state) > 5:\n",
        "  print(state, 'has more than 5 characters')\n",
        "elif len(state) == 5 and 'a' in state:\n",
        "   print(state, 'has 5 characters and contains the character a')\n",
        "else:\n",
        "  print(state, 'has less than 5 characters')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Texas has 5 characters and contains the character a\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bc5sXIkE7W3b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a5f73f5c-e939-4bab-a2d0-577f43c74dd7"
      },
      "source": [
        "# with all if statements\n",
        "state = 'Texas'\n",
        "\n",
        "if len(state) > 5:\n",
        "  print(state, 'has more than 5 characters')\n",
        "if 'a' in state:\n",
        "   print(state, 'contains the character a')\n",
        "if len(state) == 5:\n",
        "   print(state, 'has 5 characters')  \n",
        "if len(state) < 5:\n",
        "  print(state, 'has less than 5 characters')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Texas contains the character a\n",
            "Texas has 5 characters\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q94I7ha0PNZl"
      },
      "source": [
        "## Incorporating Within Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KBtdLRukAB_3"
      },
      "source": [
        "Conditional statements can be incorporated into custom functions. Consider a use case where we need to create a function to test if a string contains a `+` or `-` character, for example, within a [SMILES](https://en.wikipedia.org/wiki/Simplified_molecular-input_line-entry_system) chemical representation string.\n",
        "\n",
        "\\\n",
        "\n",
        "Example SMILES for imidazolium: **C1=C[NH+]=CN1**\n",
        "\n",
        "*Note: we are using a string approach to test if a SMILES string contains a `+` or `-` character, which would suggest an atom within the molecule contains a charge. There are more robust ways of doing this with cheminformatics software, so be cautious as there are most certainly edge-cases where string approaches fail.*\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7eJ0N2H0BiST"
      },
      "source": [
        "def has_Atomcharge(smi):\n",
        "    \"\"\" checks if a molecular SMILES string contains a charged atom using\n",
        "    character matching.\n",
        "    Input a SMILES string, returns True or False.\n",
        "    \"\"\"\n",
        "    if \"+\" in smi:\n",
        "        return True\n",
        "    elif \"-\" in smi:\n",
        "        return True\n",
        "    else:\n",
        "        return False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8cG7K9aEBiYF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c9bdd2ec-590d-4901-808a-963013177837"
      },
      "source": [
        "smi = \"C1=C[NH+]=CN1\" # imidazolium molecule SMILES\n",
        "has_Atomcharge(smi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q-iH4n8-BcYh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bfe841bb-ed8b-41c3-aac3-27a0ad22938d"
      },
      "source": [
        "smi = \"CCN1C=C[N+](=C1)C.[Cl-]\" # imidazolium chloride molecule SMILES\n",
        "has_Atomcharge(smi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "25hC5oFwBcgz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6f4cc5ea-66fd-467c-e7f2-915576796e03"
      },
      "source": [
        "smi = \"C=CC1=CC=CC=C1\" # styrene molecule SMILES\n",
        "has_Atomcharge(smi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wnUo24t5vx9c"
      },
      "source": [
        "Adapted from \n",
        "\n",
        "[4] http://swcarpentry.github.io/python-novice-gapminder/13-conditionals/index.html\n",
        "\n",
        "[5] https://github.com/vfscalfani/UALIB_Workshops/blob/master/01_MATLAB/06_MATLAB_Conditional_Statements.md"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tk2LyfE1BZPK"
      },
      "source": [
        "# Loop to Repeat Tasks [6,7,8]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CklOAHPLPWNU"
      },
      "source": [
        "## `for` loops"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tL36z-vWTT99"
      },
      "source": [
        "If we wanted to print a series of statements, we could do this one at a time, but it is very slow and inefficient:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZCit7te0TZ4G",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "71537c59-0770-4a5c-94bb-deb897349717"
      },
      "source": [
        "print(\"Rodgers Library has Nursing collections.\")\n",
        "print(\"Rodgers Library has Engineering collections.\")\n",
        "print(\"Rodgers Library has Math collections.\")\n",
        "print(\"Rodgers Library has Science collections.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Rodgers Library has Nursing collections.\n",
            "Rodgers Library has Engineering collections.\n",
            "Rodgers Library has Math collections.\n",
            "Rodgers Library has Science collections.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TvKjFHYLPdCA"
      },
      "source": [
        "`for` loops allow repeated execution of code on a known collection of values such as a range of numbers or a list. A general syntax example is as follows:\n",
        "\n",
        "```python\n",
        "\n",
        "for item in items:\n",
        "  do something\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lzsrL0Tt21Dq"
      },
      "source": [
        "`while` loops are another type of loop and are useful when you need to iterate for a specific condition and/or don't know the specific number of iterations. For an introduction, see ref [7]. However, today we will cover `for` loops, here is an example with our previous use-case:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Xa-_gNvAjJs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6300374a-4bf9-4823-8e4a-46abf7cfe281"
      },
      "source": [
        "# put or variables in a list\n",
        "subjects = [\"Nursing\", \"Engineering\", \"Math\", \"Science\"]\n",
        "\n",
        "for subject in subjects:\n",
        "  print('Rodgers Library has', subject, 'collections.')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Rodgers Library has Nursing collections.\n",
            "Rodgers Library has Engineering collections.\n",
            "Rodgers Library has Math collections.\n",
            "Rodgers Library has Science collections.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "afbvEg4CVGkR"
      },
      "source": [
        "Here is another example with a range of values:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TbdMoW5Nukl1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d8953cca-444d-44a8-bb12-57f22c91c3d0"
      },
      "source": [
        "for n in range(1,21):\n",
        "  x = (n * 100) / 2\n",
        "  print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "50.0\n",
            "100.0\n",
            "150.0\n",
            "200.0\n",
            "250.0\n",
            "300.0\n",
            "350.0\n",
            "400.0\n",
            "450.0\n",
            "500.0\n",
            "550.0\n",
            "600.0\n",
            "650.0\n",
            "700.0\n",
            "750.0\n",
            "800.0\n",
            "850.0\n",
            "900.0\n",
            "950.0\n",
            "1000.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CPZym1jYWjp7"
      },
      "source": [
        "In loops, it is often useful to store the output in a list variable, rather than printing. here is one way to do that:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dg_iEml0V7lv"
      },
      "source": [
        "L = [] # create an empty list\n",
        "for n in range(1,21):\n",
        "  x = (n * 100) / 2\n",
        "  L.append(x) # append each x value to List, L."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "32QYDfv8V7pZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "afbb8a18-0ef1-4cc3-88f4-a0aef7ed1bdb"
      },
      "source": [
        "L"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[50.0,\n",
              " 100.0,\n",
              " 150.0,\n",
              " 200.0,\n",
              " 250.0,\n",
              " 300.0,\n",
              " 350.0,\n",
              " 400.0,\n",
              " 450.0,\n",
              " 500.0,\n",
              " 550.0,\n",
              " 600.0,\n",
              " 650.0,\n",
              " 700.0,\n",
              " 750.0,\n",
              " 800.0,\n",
              " 850.0,\n",
              " 900.0,\n",
              " 950.0,\n",
              " 1000.0]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lfnTJMqKV7sf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "570a39fb-6b63-4dcc-e801-76c26b4e215a"
      },
      "source": [
        "type(L)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b2a-GkEzV7vP"
      },
      "source": [
        "# We can take the same approach with the string example:\n",
        "\n",
        "# put or variables in a list\n",
        "subjects = [\"Nursing\", \"Engineering\", \"Math\", \"Science\"]\n",
        "sentences = []\n",
        "\n",
        "for subject in subjects:\n",
        "  s = str('Rodgers Library has ' + subject + ' collections.')\n",
        "  sentences.append(s)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gudmYS6JV7x5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "75ec0ad0-56d8-48d8-c6fc-6a5c3aa8808e"
      },
      "source": [
        "sentences"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Rodgers Library has Nursing collections.',\n",
              " 'Rodgers Library has Engineering collections.',\n",
              " 'Rodgers Library has Math collections.',\n",
              " 'Rodgers Library has Science collections.']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EHkOx4CYV70s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "29f68da0-739b-431c-945b-b4c417c7e7aa"
      },
      "source": [
        "type(sentences)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1fgtNPu5YNkk"
      },
      "source": [
        "Let's revisit our custom function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iOPkNTMPYKKq"
      },
      "source": [
        "def has_Atomcharge(smi):\n",
        "    \"\"\" checks if a molecular SMILES string contains a charged atom using\n",
        "    character matching.\n",
        "    Input a SMILES string, returns True or False.\n",
        "    \"\"\"\n",
        "    if \"+\" in smi:\n",
        "        return True\n",
        "    elif \"-\" in smi:\n",
        "        return True\n",
        "    else:\n",
        "        return False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZNSBTttDYsFU"
      },
      "source": [
        "and incorporate it into a for loop:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-1Efmu6SYKN7"
      },
      "source": [
        "# create a list of SMILES to check\n",
        "mysmiles = [\"C1=C[NH+]=CN1\", \"CCCCOC\", \"CCN1C=C[N+](=C1)C.[Cl-]\", \n",
        "            \"C1C(O1)(C2=CC=C(C=C2)Cl)C3=CC=C(C=C3)Cl\", \"C=CC1=CC=CC=C1\"]\n",
        "\n",
        "charge_check = []\n",
        "for smi in mysmiles:\n",
        "  charge_check.append(has_Atomcharge(smi))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3YrErS9dYKRf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df6d198c-b2ff-490c-99ca-91078abb3285"
      },
      "source": [
        "charge_check"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[True, False, True, False, False]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1leAEB9m0lTm"
      },
      "source": [
        "**Working with data from a file**\n",
        "\n",
        "We will review how to work with data files in Workshop 3 using the [pandas library](https://pandas.pydata.org/), however, here is a basic approach for loading a text file into a Python list, as this can be very convenient if you have hundreds or more items to put into a list and then process with a custom function, for example.\n",
        "\n",
        "1. Create a simple text file for testing, we can use the SMILES strings we have from above:\n",
        "\n",
        "```python\n",
        "C1=C[NH+]=CN1\n",
        "CCCCOC\n",
        "CCN1C=C[N+](=C1)C.[Cl-]\n",
        "C1C(O1)(C2=CC=C(C=C2)Cl)C3=CC=C(C=C3)Cl\n",
        "C=CC1=CC=CC=C1\n",
        "```\n",
        "\n",
        "2. copy/paste these into any text editor and save the file as mysmiFile.txt\n",
        "\n",
        "3. upload the mysmiFile.txt to Colab (see our [first workshop](https://github.com/vfscalfani/UALIB_Workshops/blob/master/03_Python/notebooks/Rodgers_PythonWorkshop01_GettingStarted.ipynb) archived notebook).\n",
        "\n",
        "Brief review:\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q7M1SkbUGwjp"
      },
      "source": [
        "pwd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ToGKWtAxGwmt"
      },
      "source": [
        "ls"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cdjvj3lYGwpy"
      },
      "source": [
        "mkdir workshop2_test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1_3jvwu9Gwsm"
      },
      "source": [
        "ls"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ogLVizdNLSyy"
      },
      "source": [
        "Next, we can use the file navigation window to upload data directly to our new folder. Click on the workshop2_test folder `three dots > upload`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oWFpDVxGLRTX"
      },
      "source": [
        "cd workshop2_test"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7AhsWQnMLZdX"
      },
      "source": [
        "ls"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zEBSv0OQVrm-"
      },
      "source": [
        "We can use the Python csv module to load the data into a list [9,10]:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UFtrSp7HLZrq"
      },
      "source": [
        "import csv\n",
        "with open('mysmiFile.txt', newline='') as inp:\n",
        "  reader = csv.reader(inp)\n",
        "  mysmilesF = list(reader)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YGSAZQUN4cS2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d0aa01fe-c5d0-4897-ec9e-bae341afa498"
      },
      "source": [
        "print(mysmilesF)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[['C1=C[NH+]=CN1'], ['CCCCOC'], ['CCN1C=C[N+](=C1)C.[Cl-]'], ['C1C(O1)(C2=CC=C(C=C2)Cl)C3=CC=C(C=C3)Cl'], ['C=CC1=CC=CC=C1']]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w4K-7HYV4ceJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "696a826a-eaed-48a8-bcfa-23a77dde7adb"
      },
      "source": [
        "type(mysmilesF)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sVUKE93J7TP9"
      },
      "source": [
        "Note that our `mysmilesF` list is actually a list of lists:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w2fY0oU15Sbu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e87a1145-82e0-452b-96a6-baeab6db8d1c"
      },
      "source": [
        "mysmilesF[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C1=C[NH+]=CN1']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WALO4lj0-WpO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff0588ab-14ff-46bf-edd9-6376e060c51e"
      },
      "source": [
        "type(mysmilesF[0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PS0aDl7jXE8w"
      },
      "source": [
        "This may be preferred for certain applications, but in our case, it is probably easier to \"flatten\" the list.  Here is a convenient way to \"flatten a list\" from Stackoverflow [11]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gOwPYr4o8aRQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f2086fe3-b861-420d-f1f1-09c236e41beb"
      },
      "source": [
        "flat_mysmilesF = []\n",
        "for sublist in mysmilesF:\n",
        "    for smi in sublist:\n",
        "        flat_mysmilesF.append(smi)\n",
        "flat_mysmilesF     "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C1=C[NH+]=CN1',\n",
              " 'CCCCOC',\n",
              " 'CCN1C=C[N+](=C1)C.[Cl-]',\n",
              " 'C1C(O1)(C2=CC=C(C=C2)Cl)C3=CC=C(C=C3)Cl',\n",
              " 'C=CC1=CC=CC=C1']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jzbLv1Gd4chs"
      },
      "source": [
        "# now we can run our check again on the imported data\n",
        "charge_check2 = []\n",
        "for smi in flat_mysmilesF:\n",
        "  charge_check2.append(has_Atomcharge(smi))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3sWcEsrz5SY2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f0b7ad8d-ead5-49ed-a183-b06d6666f4f8"
      },
      "source": [
        "charge_check2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[True, False, True, False, False]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RZkI2rJI-6x9"
      },
      "source": [
        "It might also be useful to keep track of our lines, using the Python `enumerate` iterator [12]:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jh9QFV764clQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "711ba4a1-2383-4ce5-be26-0bf7790897b0"
      },
      "source": [
        "for i,smi in enumerate(flat_mysmilesF):\n",
        "    AtomCharge_log = has_Atomcharge(smi)\n",
        "    print(i, smi, AtomCharge_log)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 C1=C[NH+]=CN1 True\n",
            "1 CCCCOC False\n",
            "2 CCN1C=C[N+](=C1)C.[Cl-] True\n",
            "3 C1C(O1)(C2=CC=C(C=C2)Cl)C3=CC=C(C=C3)Cl False\n",
            "4 C=CC1=CC=CC=C1 False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2v2pyihMABtr"
      },
      "source": [
        "# we can also use a string concatenation approach with append to\n",
        "# save our output into a list\n",
        "formatted_check = []\n",
        "for i,smi in enumerate(flat_mysmilesF):\n",
        "    AtomCharge_log = has_Atomcharge(smi)\n",
        "    s = str(i) + \" \" + str(smi) + \" \" + str(AtomCharge_log)\n",
        "    formatted_check.append(s)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-LDu71j6AxTH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ee3a2c30-a4a7-4a3b-a8e6-b06cc18564a2"
      },
      "source": [
        "formatted_check"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['0 C1=C[NH+]=CN1 True',\n",
              " '1 CCCCOC False',\n",
              " '2 CCN1C=C[N+](=C1)C.[Cl-] True',\n",
              " '3 C1C(O1)(C2=CC=C(C=C2)Cl)C3=CC=C(C=C3)Cl False',\n",
              " '4 C=CC1=CC=CC=C1 False']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KEkTY0Z1ZCK0"
      },
      "source": [
        "Finally, we may want to write our results to a file [13,14]:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uiaPLkcjDSwh"
      },
      "source": [
        "# write output to file\n",
        "with open('mysmiFile_checked.txt', 'w') as out:\n",
        "  for check in formatted_check:\n",
        "      out.write(str(check) + \"\\n\")\n",
        "\n",
        "# will be saved in current Colab directory, then you can download file and save.      "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XHoaeZ5jhJRJ",
        "outputId": "363b3682-c59a-40a6-ce6e-8c9b2ad3c155"
      },
      "source": [
        "cat mysmiFile_checked.txt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 C1=C[NH+]=CN1 True\n",
            "1 CCCCOC False\n",
            "2 CCN1C=C[N+](=C1)C.[Cl-] True\n",
            "3 C1C(O1)(C2=CC=C(C=C2)Cl)C3=CC=C(C=C3)Cl False\n",
            "4 C=CC1=CC=CC=C1 False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8TXDujAzNZFX"
      },
      "source": [
        "References\n",
        "\n",
        "[6] http://swcarpentry.github.io/python-novice-gapminder/12-for-loops/index.html\n",
        "\n",
        "[7] https://nbviewer.jupyter.org/github/jakevdp/WhirlwindTourOfPython/blob/master/07-Control-Flow-Statements.ipynb\n",
        "\n",
        "[8] https://github.com/vfscalfani/UALIB_Workshops/blob/master/01_MATLAB/05_MATLAB_Loops.md\n",
        "\n",
        "[9] https://stackoverflow.com/questions/24662571/python-import-csv-to-list\n",
        "\n",
        "[10] https://docs.python.org/3/library/csv.html\n",
        "\n",
        "[11] https://stackoverflow.com/questions/952914/how-to-make-a-flat-list-out-of-a-list-of-lists\n",
        "\n",
        "[12] https://nbviewer.jupyter.org/github/jakevdp/WhirlwindTourOfPython/blob/master/10-Iterators.ipynb\n",
        "\n",
        "[13] https://stackoverflow.com/questions/899103/writing-a-list-to-a-file-with-python\n",
        "\n",
        "[14] https://docs.python.org/3/tutorial/inputoutput.html?highlight=write"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_jaC3RKVulgv"
      },
      "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",
        "[3] For searching specific use-cases: https://stackoverflow.com/questions/tagged/python\n",
        "\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."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sMUjvbDsup8V"
      },
      "source": [
        "# Notebook Copy\n",
        "\n",
        "An archived version of this notebook with (most) outputs is available on our UALIB_Workshops GitHub repository: https://github.com/vfscalfani/UALIB_Workshops"
      ]
    }
  ]
}