Python/Python_Lesson_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wjZKXZ9dXJUr"
   },
   "source": [
    "# Introduction to Python Programming for Bioinformatics. Lesson 2.\n",
    "\n",
    "<details>\n",
    "<summary>\n",
    "About this notebook\n",
    "</summary>\n",
    "\n",
    "This notebook was originally written by [Marc Cohen](https://github.com/mco-gh), an engineer at Google. The original source can be found on [Marc's short link service](https://mco.fyi/), and starts with [Python lesson 0](https://mco.fyi/py0), and I encourage you to work through that notebook if you find some details missing here.\n",
    "\n",
    "Rob Edwards edited the notebook, adapted it for bioinformatics, using some simple geneticy examples, condensed it into a single notebook, and rearranged some of the lessons, so if some of it does not make sense, it is Rob's fault!\n",
    "\n",
    "It is intended as a hands-on companion to an in-person course, and if you would like Rob to teach this course (or one of the other courses) don't hesitate to get in touch with him.\n",
    "\n",
    "</details>\n",
    "<details>\n",
    "<summary>\n",
    "Using this notebook\n",
    "</summary>\n",
    "\n",
    "You can download the original version of this notebook from [GitHub](https://linsalrob.github.io/ComputationalGenomicsManual/Python/Python_Lesson_02.ipynb) and from [Rob's Google Drive]()\n",
    "\n",
    "**You should make your own copy of this notebook by selecting File->Save a copy in Drive from the menu bar above, and then you can edit the code and run it as your own**\n",
    "\n",
    "There are several lessons, and you can do them in any order. I've tried to organise them in the order I think most appropriate, but you may disagree!\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_Km_oeNBXJUy"
   },
   "source": [
    "<a name=\"lessons\"></a>\n",
    "\n",
    "# Lesson Links\n",
    "\n",
    "* [Lesson 2 - Expressions](#Lesson-2---Expressions)\n",
    "  * [Constants vs. Variables](#Constants-vs.-Variables)\n",
    "  * [Data Types](#Data-Types)\n",
    "  * [The Boolean (bool) Type](#The-Boolean-(bool)-Type)\n",
    "  * [The None Type](#The-None-Type)\n",
    "  * [Comparison Opererators](#Comparison-Opererators)\n",
    "  * [Boolean Operators - and, or, and not](#Boolean-Operators---and,-or,-and-not)\n",
    "  * [Order of Evaluation](#Order-of-Evaluation)\n",
    "  * [Python Precedence Rules](#Python-Precedence-Rules)\n",
    "  * [F strings](#F-strings)\n",
    "\n",
    "Previous Lesson: [Local](Python_Lesson_01.ipynb) | [GitHub](https://linsalrob.github.io/ComputationalGenomicsManual/Python/Python_Lesson_01.ipynb) | [Google Colab](https://colab.research.google.com/drive/11rcjrwznjZS-qoFoEcCQYF85PCRtN9dr)\n",
    "\n",
    "Next Lesson: [Local](Python_Lesson_03.ipynb) | [GitHub](https://linsalrob.github.io/ComputationalGenomicsManual/Python/Python_Lesson_03.ipynb) | [Google Colab](https://colab.research.google.com/drive/1NbWawPfWAQV2x56rG0SvcMNpXI7sn3R0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mfGvFV6WLjI1"
   },
   "source": [
    "# Lesson 2 - Expressions\n",
    "\n",
    "\n",
    "Things you'll learn in this lesson:\n",
    "- More about types in Python\n",
    "- Boolean operators\n",
    "- How to combine constants, variables, and operators into arithmetic, boolean, and comparison expressions\n",
    "- Operator precedence\n",
    "- The magical f-string\n",
    "\n",
    "Link to the original version of this notebook on [Marco's short link service](https://mco.fyi/py2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IpvP1cdrMj7N"
   },
   "source": [
    "# Constants vs. Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "no7Tp6rlMqxe"
   },
   "source": [
    "* Literal values (like `\"Rob\"` and `2010`) are called constants because they don't change.\n",
    "\n",
    "* Constants, are called constants because its value is fixed, unlike variables, whose associated value may change (or *vary*) over time.\n",
    "\n",
    "* The data a variable refers to may be simple, e.g. a number or a string, or it may be complex, e.g. a list or an object (we'll learn about those later)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LOPDElnTtZ_3"
   },
   "source": [
    "# Data Types\n",
    "\n",
    "In Python, values have a *type*. We already saw three data types in the previous lesson. We'll take a look at a few other types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PqEElVkjMx0U"
   },
   "source": [
    "# The Boolean (`bool`) Type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9v1wuSdBM4Gn"
   },
   "source": [
    "Python supports a special type called booleans, written `bool` in Python, which are used to indicate whether something is true or false. Booleans have one of two possible values:\n",
    "\n",
    "* `True`\n",
    "* `False`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1RhUxhsoM7SJ"
   },
   "source": [
    "When evaluating a **number** as a boolean, the following rules apply:\n",
    "\n",
    "* 0 is `False`\n",
    "* 0.0 is `False`\n",
    "* all other numerical values are `True`\n",
    "\n",
    "When evaluating a **string** as a boolean, the following rules apply:\n",
    "\n",
    "* the empty string (`\"\"` and `''`) is `False`\n",
    "* all other strings are `True`\n",
    "\n",
    "If it's something, its True. Otherwise its _NOT_.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YtDLrMs2M-_C"
   },
   "source": [
    "# The None Type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8wM1pnKbNCkk"
   },
   "source": [
    "Python has a special type called `None` and it means *no value*.\n",
    "\n",
    "It's a good choice when you want to initialize a variable without an obvious choice for the initial value, like this:\n",
    "\n",
    "```bacteria = None```\n",
    "\n",
    "None always evaluates to False in boolean expressions.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hBrzYShvNkkG"
   },
   "source": [
    "# Comparison Opererators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "G_I6sd1ANlxp"
   },
   "source": [
    "As their name suggests, comparison operators allow us to compare values and result in a boolean type indicating whether the comparison is `True` or `False`.\n",
    "\n",
    "The following table summarizes the most commonly used operators in Python, along with their definition when applied to numbers and strings.\n",
    "\n",
    "|operator|operation on numbers|operation on strings|\n",
    "|--------|--------------------|--------------------|\n",
    "|==|equal to|equal to|\n",
    "|!=|not equal to|not equal to|\n",
    "|>|greater than|lexicographically greater than|\n",
    "|>=|greater than or equal to|lexocographically greater than or equal to|\n",
    "|<|less than|lexicographically less than|\n",
    "|<=|less than or equal to|lexocographically less than or equal to|\n",
    "\n",
    "(Remember the crocodile!)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "twQUgl3GNpVK"
   },
   "source": [
    "## Challenge\n",
    "\n",
    "Which boolean value (`True` or `False`) do each of these expressions evaluate to?\n",
    "\n",
    "* `123 == 10`\n",
    "* `10 == 123`\n",
    "* `123 == 123`\n",
    "* `123 != 321`\n",
    "* `123 != 123`\n",
    "* `age == 65`\n",
    "* `age != min_age`\n",
    "\n",
    "* `\"E. coli\" == \"Salmonella\"`\n",
    "* `\"E. coli\" == \"E. coli\"`\n",
    "* `\"E. coli\" == \"E.coli\"`\n",
    "* `\"E. coli\" != \"e. coli\"`\n",
    "\n",
    "### `>` and `>=`\n",
    "* `123 > 10`\n",
    "* `10 > 123`\n",
    "* `123 > 123`\n",
    "* `123 >= 123`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GTamPNU8NwEc"
   },
   "source": [
    "# Boolean Operators - `and`, `or`, and `not`\n",
    "\n",
    "Boolean operators are special operators in Python that let you combine boolean values in logical ways corresponding to how we combine truth values in the real world. An example of a boolean **and** expression would be \"I'll buy a new phone if I like the features **and** the price is low\". There are three main boolean operators: `and`, `or`, and `not`. We'll look at examples of each in the next cells."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5uzIu5wwNxCq"
   },
   "source": [
    "## Boolean `and`\n",
    "\n",
    "* `A and B`\n",
    "\n",
    "is `True` only true when both A and B are `True`, otherwise it's `False`.\n",
    "\n",
    "Example:\n",
    "\n",
    "* I ride my bike only when it's both sunny and warm.\n",
    "* In other words, if `is_sunny` and `is_warm` are both `True` then `is_sunny and is_warm` is `True` so I **will** ride my bike.\n",
    "\n",
    "In Python...\n",
    "```\n",
    "if is_sunny and is_warm:\n",
    "    # ride bike\n",
    "```\n",
    "\n",
    "We haven't learn about `if` statements so don't worry if the previous construct looks unfamiliar. It's a simple way of checking the value of a boolean expression, but we'll dive deeper into `if` statements shortly.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 6,
     "status": "ok",
     "timestamp": 1719449654138,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "PfzPhjzdfr5W",
    "outputId": "58171ae7-024c-47f4-8544-d80647da5626"
   },
   "outputs": [],
   "source": [
    "is_sunny = False\n",
    "is_warm = False\n",
    "print(is_sunny and is_warm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "90Arbj1TN0mK"
   },
   "source": [
    "### Truth Table for boolean `and`\n",
    "|`var1`|`var2`|`var1 and var2`|\n",
    "|------|------|---------------|\n",
    "|`False`|`False`|`False`|\n",
    "|`True`|`False`|`False`|\n",
    "|`False`|`True`|`False`|\n",
    "|`True`|`True`|`True`|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9QZ93qNgN5Oh"
   },
   "source": [
    "## Boolean `or`\n",
    "\n",
    "* `A or B`\n",
    "\n",
    "is `True` when either A or B are `True`, or when both are `True`, otherwise it's `False`.\n",
    "\n",
    "Example:\n",
    "\n",
    "* I ride my bike  when it's sunny, or warm, or both\n",
    "* In other words, if `is_sunny` or `is_warm` (or both) are `True` then `is_sunny or is_warm` is `True` so I **will** ride my bike.\n",
    "\n",
    "In Python...\n",
    "```\n",
    "if is_sunny or is_warm:\n",
    "  # ride bike\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OVf9BfHTN8k3"
   },
   "source": [
    "### Truth Table for boolean `or`\n",
    "\n",
    "|`var1`|`var2`|`var1 or var2`|\n",
    "|------|------|---------------|\n",
    "|`False`|`False`|`False`|\n",
    "|`True`|`False`|`True`|\n",
    "|`False`|`True`|`True`|\n",
    "|`True`|`True`|`True`|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WFlkXCULN_yJ"
   },
   "source": [
    "## Logical Not\n",
    "\n",
    "* `not A`\n",
    "\n",
    "is `True` when A is `False`\n",
    "is `False` when A is `True`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4OEHQqVjOCkM"
   },
   "source": [
    "### Truth Table for boolean `not`\n",
    "\n",
    "|`var1`|`not var1`|\n",
    "|------|---------|\n",
    "|`False`|`True`|\n",
    "|`True`|`False`|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NjRlRqDkQxX3"
   },
   "source": [
    "# Expressions Revisited"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZhpEy8pPQqGz"
   },
   "source": [
    "* Python lets us combine variables, constants and operators into larger units called expressions.\n",
    "* Expressions appear in many places\n",
    "  * assignment statements. Here we are assigning the new number to the same variable\n",
    "    * `age = age + 1    # we do this every birthday`\n",
    "    * we could write this in two steps:\n",
    "       * `tmp = age + 1`\n",
    "       * `age = tmp`\n",
    "    * but using one assignment is simpler, easier, and cleaner\n",
    "  * function calls\n",
    "    * `print(total_days * 365) # number of days alive`\n",
    "* As we learn more, we'll see expressions popping up all over the place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JdS3GxIOQ4DC"
   },
   "outputs": [],
   "source": [
    "age = 22\n",
    "print(age)\n",
    "age = age + 1\n",
    "print(age)\n",
    "age += 1\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 358,
     "status": "ok",
     "timestamp": 1719449985659,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "EKp1t5XVQ5An",
    "outputId": "263a643d-1dd6-4f80-8b70-5e47b9c1f888"
   },
   "outputs": [],
   "source": [
    "age = 22\n",
    "days_per_year = 365\n",
    "days_old = age * days_per_year\n",
    "print(f\"I was {days_old} days old on my last birthday!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NWQDio7OQ7Ss"
   },
   "source": [
    "## Types of Expressions\n",
    "\n",
    "* arithmetic expressions\n",
    "\n",
    "`genome_size = chromosome_1_size + chromosome_2_size`\n",
    "\n",
    "* comparative expressions\n",
    "\n",
    "`genome_size == 0`\n",
    "\n",
    "* boolean expressions\n",
    "\n",
    "`chromosome_1 and plasmid`\n",
    "\n",
    "* combinations of the above\n",
    "\n",
    "`plasmid and (chromosome_1_size + chromosome_2_size + plasmid_size) < genome_size`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "J_VZLf1QRAXa"
   },
   "source": [
    "## Order of Evaluation\n",
    "\n",
    "How does Python know the correct order to evaluate a complex expression?\n",
    "\n",
    "Example: `4 + 1 * 5`\n",
    "\n",
    "Is that `(4 + 1) * 5`, which is `25`?  \n",
    "Or is it `4 + (1 * 5)`, which is `9`?\n",
    "\n",
    "Another example:  True or False and False\n",
    "\n",
    "Is that `(True or False) and False`, which is `False`?  \n",
    "Or is it `True or (False and False)`, which is `True`?\n",
    "\n",
    "Python uses operator precedence rules to avoid this ambiguity and evaluate expressions in a predictable way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-iFwjdFZRDkY"
   },
   "source": [
    "## Python Precedence Rules\n",
    "\n",
    "This is a subset of the complete rules (in order of highest to lowest precedence):\n",
    "\n",
    "* parentheses (innermost to outermost, left to right)\n",
    "* exponentiation (left to right)\n",
    "* multiplication, division, modulus (left to right)\n",
    "* addition, subtraction (left to right)\n",
    "* comparisons (left to right)\n",
    "* boolean not\n",
    "* boolean and\n",
    "* boolean or\n",
    "\n",
    "[The Official Rules](https://docs.python.org/3/reference/expressions.html#operator-precedence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AWaVO8AORHZA"
   },
   "source": [
    "## Practical Advice\n",
    "\n",
    "**When in doubt, use parentheses.**\n",
    "\n",
    "Coders make liberal use of parentheses because:\n",
    "* You don't need to remember the precedence rules.\n",
    "* You don't have to worry about surprises.\n",
    "* It makes code more readable.\n",
    "* It eliminates any ambiguity\n",
    "\n",
    "For example, we could write this expression, which evaluates `A and B` first, then `C and D`, and finally takes the boolean `or` of the two preceding results:\n",
    "\n",
    "`A and B or C and D`\n",
    "\n",
    "but we much prefer to make explicit, like this so we don't have to _think_ (about precedence rules) every time we look at this code:\n",
    "\n",
    "`(A and B) or (C and D)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DaYXt_iJCQOU"
   },
   "source": [
    "## F-strings\n",
    "\n",
    "We often need to combine variables, values, and strings. For example, if we have the following variables:\n",
    "\n",
    "- `bacteria_name`\n",
    "- `genome_size`\n",
    "\n",
    "we might want to print a report, where each line summarizes the values above. We could do that like this:\n",
    "\n",
    "```\n",
    "print(\"bacteria: \", bacteria_name, \", genome size: \", genome_size, \" bp\")\n",
    "```\n",
    "which produces this output:\n",
    "```\n",
    "bacteria: E. coli genome size: 4500000 bp\n",
    "```\n",
    "\n",
    "This sort of construct gets a bit tedious. Plus the space between the customer id and the following comma unintended and undesirable.\n",
    "\n",
    "Python has a simple approach, called f-strings, that offer a more readable solution to this problem. If you prefix a string with the character `f`, it gives the string magic powers. Specifically, the sting has the ability to **interpolate** variables inside curly brackets. Here's how we could express the previous `print` statement using an f-string:\n",
    "\n",
    "```\n",
    "print(f\"bacteria: {bacteria_name}, genome size: {genome_size} bp\")\n",
    "```\n",
    "\n",
    "This is shorter, less tedious, easier to read and write, and solves the formatting issue related to the comma between the two fields.\n",
    "\n",
    "Note that you can put any Python code inside the curly braces, so this technique is very powerful. Once you get going with Python, you'll find all sort of wonderful ways to use f-strings.\n",
    "\n",
    "There is also a neat trick that can help with large numbers! Adding a `:,` after a number means `automatically insert thousands separators`:\n",
    "\n",
    "```\n",
    "print(f\"bacteria: {bacteria_name}, genome size: {genome_size:,} bp\")\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 366,
     "status": "ok",
     "timestamp": 1719450438745,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "kvRg8zPWED-_",
    "lines_to_next_cell": 2,
    "outputId": "ebd32aec-5c21-4715-b62a-604016de57f1"
   },
   "outputs": [],
   "source": [
    "bacteria_name = \"E. coli\"\n",
    "genome_size = 4500000\n",
    "print(f\"bacteria: {bacteria_name}, genome size: {genome_size:,} bp\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "23qlp6QEJStb"
   },
   "source": [
    "[Return to the lesson listing](#lessons)\n",
    "\n",
    "[Return to the top of the notebook](#top)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [
    {
     "file_id": "15KAyGvriQwRoXQa3t70jmi3XumKBxDRi",
     "timestamp": 1718237753735
    }
   ]
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}