Python/Python_Lesson_01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wjZKXZ9dXJUr"
   },
   "source": [
    "<a name=\"top\"></a>\n",
    "# Introduction to Python Programming for Bioinformatics\n",
    "\n",
    "## About this notebook\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",
    "## Using this notebook\n",
    "\n",
    "You can download the original version of this notebook from [GitHub](https://linsalrob.github.io/ComputationalGenomicsManual/Python/Python_Lesson_01.ipynb) and from [Rob's Google Drive](https://drive.google.com/file/d/11rcjrwznjZS-qoFoEcCQYF85PCRtN9dr/view?usp=sharing)\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_Km_oeNBXJUy",
    "lines_to_next_cell": 2
   },
   "source": [
    "<a name=\"lessons\"></a>\n",
    "\n",
    "# Lesson Links\n",
    "\n",
    "* [Lesson 1 - Variables and Types](#Lesson-1---Variables-and-Types)\n",
    "  * [Variables](#Variables)\n",
    "  * [Naming variables](#Naming-variables)\n",
    "  * [Types of data](#Types-of-data)\n",
    "  * [Numeric Types](#Numeric-Types)\n",
    "  * [String Types](#String-Types)\n",
    "  * [Using Variables in Python](#Using-Variables-in-Python)\n",
    "  * [Built in Python functions](#Built-in-Python-functions)\n",
    "\n",
    "---\n",
    "\n",
    "Previous Lesson: Local | GitHub | Google Colab\n",
    "\n",
    "Next Lesson: [Local](Python_Lesson_02.ipynb) | [GitHub](https://linsalrob.github.io/ComputationalGenomicsManual/Python/Python_Lesson_02.ipynb) | [Google Colab](https://colab.research.google.com/drive/1Sm7N8Agf0aFj6qbd6GwenGBaqchZYTug)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EGh4nC1QXJU0"
   },
   "source": [
    "# Lesson 1 - Variables and Types\n",
    "\n",
    "Things you'll learn in this lesson:\n",
    "- The basic data types you can work with in Python\n",
    "- How to create and assign values to variables in Python\n",
    "- How to call a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bJVtPIkr5KDA"
   },
   "source": [
    "## Variables\n",
    "\n",
    "Any Python interpreter can be used as a calculator. To run this cell, either click on the triangle, or put your cursor in the cell and press Shift and Enter at the same time.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-19T00:39:12.647810Z",
     "start_time": "2024-08-19T00:39:12.626143Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1719446758028,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "O5D5Pvgu5MrL",
    "outputId": "a41afa0b-c20e-4901-ce95-138ef2c7e2a2"
   },
   "outputs": [],
   "source": [
    "print(3 + 5 * 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zi5ctjIY5j5n"
   },
   "source": [
    "\n",
    "This is great but not very interesting.\n",
    "To do anything useful with data, we need to assign its value to a _variable_.\n",
    "In Python, we can assign a value to a variable using the equals sign `=`.\n",
    "\n",
    "If a variable doesn’t already exist, when you assign to it, Python creates it on the fly. If you assign to a variable that already exists, Python replaces its current value with a new value.\n",
    "\n",
    "Examples\n",
    "\n",
    "    instructor = \"Rob\"         # string value\n",
    "    instructor = \"Stevie\" # same name, diff string value\n",
    "    instructor = 42             # same name, integer value\n",
    "    todays_high_temp = 18.2     # diff name, floating point value\n",
    "\n",
    "We can track the length of a bacterial genome by assigning its length in basepairs to a variable. For example, if the length is 4,500,000 bp, we\n",
    "could assign that to a variable called `genome_size`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-13T07:21:27.325111Z",
     "start_time": "2024-06-13T07:21:27.299019Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 446,
     "status": "ok",
     "timestamp": 1719446897514,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "w7RY3CFRXJU3",
    "outputId": "4ce5aba7-dae1-4a3d-e2d6-5939132a5e9f"
   },
   "outputs": [],
   "source": [
    "genome_size = 4500000\n",
    "print(genome_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ei_aBfYIYmdI"
   },
   "source": [
    "From now on, whenever we use `genome_size`, Python will substitute the value we assigned to it. In simpler terms, **a variable is a reference to a value**.\n",
    "\n",
    "In Python, variable names:\n",
    "\n",
    " - can include letters, digits, and underscores\n",
    " - cannot start with a digit\n",
    " - are case-sensitive\n",
    "\n",
    "This means that, for example:\n",
    " - `genome0` is a valid variable name, whereas `0genome` is not\n",
    " - `genome` and `Genome` are different variables, and this will sometimes trip you up. It is usual practice to use lower case letters for variable names, and if you want to use two words, like `genome size`, to join them with an underscore (i.e. `genome_size`). Sometimes people will use capitals for words, like `GenomeSize`, (but that's wrong!) (but it still works).\n",
    "\n",
    "## Naming variables\n",
    "\n",
    "It is a good idea (and good practice!) to name variables something meaningful. Remember that when you come back to your code in 6 months or a year later, it is going to look like gibebrish, so try and reduce the amount of gibberish as much as possible!\n",
    "\n",
    "For example, while you are writing the code it might be obvious to use `r` to mean `RNA sequence coverage averaged by gene length`, however in 6 months, you'll be wondering if this was really averaged, or just the raw counts. Using a variable like `rnaseq_averaged` is more meaningfull. You should avoid short names (one or two letters), however, you might also want to avoid using `rna_sequence_coverage_averaged_by_gene_length`, which even though it is valid, it will be a pain to type everytime (and make your code look ugly!)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AQsH4eIdsUY_"
   },
   "source": [
    "### Reserved Words\n",
    "\n",
    "The following words have special meaning in Python. We call them keywords or reserved words and you may not use these names for your program variables.\n",
    "\n",
    "> ```and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, nonlocal, None, not, or, pass, raise, return, True, try, while, with, yield```\n",
    "\n",
    "<details>\n",
    "<summary>\n",
    "Python also has a lot of built-in functions. We'll use some of these as we go through, but here is a table of all of them. Although you don't need to worry about them right now, you should avoid using the names of these functions as the name of a variable. Click the triangle at the start of this line to see the complete table.\n",
    "</summary>\n",
    "\n",
    "\n",
    "Function | Description\n",
    "--- | ---\n",
    "abs() | Returns the absolute value of a number\n",
    "all() | Returns True if all items in an iterable object are true\n",
    "any() | Returns True if any item in an iterable object is true\n",
    "ascii() | Returns a readable version of an object. Replaces none-ascii characters with escape character\n",
    "bin() | Returns the binary version of a number\n",
    "bool() | Returns the boolean value of the specified object\n",
    "bytearray() | Returns an array of bytes\n",
    "bytes() | Returns a bytes object\n",
    "callable() | Returns True if the specified object is callable, otherwise False\n",
    "chr() | Returns a character from the specified Unicode code.\n",
    "classmethod() | Converts a method into a class method\n",
    "compile() | Returns the specified source as an object, ready to be executed\n",
    "complex() | Returns a complex number\n",
    "delattr() | Deletes the specified attribute (property or method) from the specified object\n",
    "dict() | Returns a dictionary (Array)\n",
    "dir() | Returns a list of the specified object's properties and methods\n",
    "divmod() | Returns the quotient and the remainder when argument1 is divided by argument2\n",
    "enumerate() | Takes a collection (e.g. a tuple) and returns it as an enumerate object\n",
    "eval() | Evaluates and executes an expression\n",
    "exec() | Executes the specified code (or object)\n",
    "filter() | Use a filter function to exclude items in an iterable object\n",
    "float() | Returns a floating point number\n",
    "format() | Formats a specified value\n",
    "frozenset() | Returns a frozenset object\n",
    "getattr() | Returns the value of the specified attribute (property or method)\n",
    "globals() | Returns the current global symbol table as a dictionary\n",
    "hasattr() | Returns True if the specified object has the specified attribute (property/method)\n",
    "hash() | Returns the hash value of a specified object\n",
    "help() | Executes the built-in help system\n",
    "hex() | Converts a number into a hexadecimal value\n",
    "id() | Returns the id of an object\n",
    "input() | Allowing user input\n",
    "int() | Returns an integer number\n",
    "isinstance() | Returns True if a specified object is an instance of a specified object\n",
    "issubclass() | Returns True if a specified class is a subclass of a specified object\n",
    "iter() | Returns an iterator object\n",
    "len() | Returns the length of an object\n",
    "list() | Returns a list\n",
    "locals() | Returns an updated dictionary of the current local symbol table\n",
    "map() | Returns the specified iterator with the specified function applied to each item\n",
    "max() | Returns the largest item in an iterable\n",
    "memoryview() | Returns a memory view object\n",
    "min() | Returns the smallest item in an iterable\n",
    "next() | Returns the next item in an iterable\n",
    "object() | Returns a new object\n",
    "oct() | Converts a number into an octal\n",
    "open() | Opens a file and returns a file object\n",
    "ord() | Convert an integer representing the Unicode of the specified character\n",
    "pow() | Returns the value of x to the power of y\n",
    "print() | Prints to the standard output device\n",
    "property() | Gets, sets, deletes a property\n",
    "range() | Returns a sequence of numbers, starting from 0 and increments by 1 (by default)\n",
    "repr() | Returns a readable version of an object\n",
    "reversed() | Returns a reversed iterator\n",
    "round() | Rounds a numbers\n",
    "set() | Returns a new set object\n",
    "setattr() | Sets an attribute (property/method) of an object\n",
    "slice() | Returns a slice object\n",
    "sorted() | Returns a sorted list\n",
    "staticmethod() | Converts a method into a static method\n",
    "str() | Returns a string object\n",
    "sum() | Sums the items of an iterator\n",
    "super() | Returns an object that represents the parent class\n",
    "tuple() | Returns a tuple\n",
    "type() | Returns the type of an object\n",
    "vars() | Returns the __dict__ property of an object\n",
    "zip() | Returns an iterator, from two or more iterators\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2vVrIzu76Mka"
   },
   "source": [
    "## Types of data\n",
    "Python knows about several types of data. Three common ones are:\n",
    "\n",
    "* integer numbers\n",
    "* floating point numbers\n",
    "* character strings\n",
    "\n",
    "In the example above, variable `genome_size` was assigned an integer value of `4500000`. If we want to store a fraction, like the %GC of the genome,\n",
    "we can use a floating point value by executing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-13T07:21:54.626948Z",
     "start_time": "2024-06-13T07:21:54.617326Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 440,
     "status": "ok",
     "timestamp": 1719447249773,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "Q-cUtwa26PKT",
    "outputId": "c92cd7ed-3581-43e5-d347-d0cf6e0d3f45"
   },
   "outputs": [],
   "source": [
    "percent_gc = 0.45\n",
    "print(percent_gc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hRyCToPF6Uk7"
   },
   "source": [
    "To create a string, we add single or double quotes around some text.\n",
    "To identify and track a bacteria throughout our study, we can assign it a unique identifier by storing it in a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-13T07:21:57.556131Z",
     "start_time": "2024-06-13T07:21:57.537151Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 461,
     "status": "ok",
     "timestamp": 1719447279852,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "2g7XZo0m6X7Q",
    "outputId": "1e55e0ca-ad92-4cc5-91b1-c8a30fe8c94a"
   },
   "outputs": [],
   "source": [
    "bacteria_id = \"001\"\n",
    "print(bacteria_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3IVQV7ajrzvM"
   },
   "source": [
    "## Numeric Types\n",
    "\n",
    "Python supports two main types of numbers\n",
    "* int, arbitrary size signed integers, like these:\n",
    "  * `2011`\n",
    "  * `-999999999999`\n",
    "* float, arbitrary precision floating point numbers, like these:\n",
    "  * `3.1415926539`\n",
    "  * `3.8 * 10**6`\n",
    "\n",
    "For the most part, you don't need to worry about which type of number to use - Python will take care of that for you. The decimal point tells Python which to use.\n",
    "\n",
    "Mixing floats and ints results in a float so, for example, `2011 * 3.14` results in a floating point number.\n",
    "\n",
    "Try entering these expressions in the following cell:\n",
    "\n",
    "```\n",
    "print(5 - 6)  \n",
    "print(8 * 9)\n",
    "print(6 / 2)\n",
    "print(5.0 / 2)\n",
    "print(5 % 2)  \n",
    "print(2 * 10 + 3)  \n",
    "print(2 * (10 + 3))  \n",
    "print(2 ** 4)\n",
    "```\n",
    "Were there any outputs you didn't expect?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GxdsLvbqr2Bd"
   },
   "outputs": [],
   "source": [
    "# talk about the print variables with your neighbour, and then copy and paste them here!\n",
    "# press shift-enter to execute the code after you have pasted it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_2xdMDdCXJU5"
   },
   "source": [
    "## String Types\n",
    "\n",
    "Strings are really a [list](#Lesson-3-Lists) of characters, and we can do a few interesting things with them. Note that we will talk more about Lists later, so some of this will become clearer when we cover that material.\n",
    "\n",
    "A string is a collection of individual characters, and you can access each of them separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 424,
     "status": "ok",
     "timestamp": 1719448274272,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "UPmV_RArXJU6",
    "outputId": "0e439b06-9070-4dfe-e414-5ee4705f7a0f"
   },
   "outputs": [],
   "source": [
    "sequence = \"ACGT\"\n",
    "print(sequence[0])\n",
    "print(sequence[1])\n",
    "print(sequence[2])\n",
    "print(sequence[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XBWHLwdyXJU6"
   },
   "source": [
    "We can also access a `slice` of a string which is the start and stop positions of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 417,
     "status": "ok",
     "timestamp": 1719448305159,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "gZYPsYogXJU6",
    "outputId": "6cce86e2-c9ce-4d27-a62f-452c0e643910"
   },
   "outputs": [],
   "source": [
    "print(sequence[0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S-j9OuQ96ofq"
   },
   "source": [
    "## Using Variables in Python\n",
    "\n",
    "Once we have data stored with variable names, we can make use of those variables in our calculations. We call these combinations of variables and values  **expressions**. When evaluating an expression, Python internally replaces the variable names with the values to which they refer.\n",
    "\n",
    "We may want to store our genome in kilo base pairs as well as base pairs.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 456,
     "status": "ok",
     "timestamp": 1719448349278,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "gWSAZq0D6xpf",
    "outputId": "32870f1e-fbae-4572-9042-3ebffe0f7e03"
   },
   "outputs": [],
   "source": [
    "genome_kb = genome_size / 1000\n",
    "print(genome_kb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hCZN9s236ucL"
   },
   "source": [
    "We might also decide to add a bacterial genus and species to our bacterial id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 453,
     "status": "ok",
     "timestamp": 1719448371590,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "gLIq7Z1u63VJ",
    "outputId": "43c4cd4c-b987-4010-bc43-29443aa7e4af"
   },
   "outputs": [],
   "source": [
    "bacteria_id = \"E coli: \" + bacteria_id\n",
    "print(bacteria_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8BnjHISr6-hN"
   },
   "source": [
    "## Built-in Python functions\n",
    "\n",
    "To carry out common tasks with data and variables in Python,\n",
    "the language provides us with several built-in functions.\n",
    "To display information to the screen, we use the `print` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 3,
     "status": "ok",
     "timestamp": 1719448392495,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "Igqiw5fJ7FLn",
    "outputId": "d46acd5d-c062-430d-fc63-b89b6b2a76e5"
   },
   "outputs": [],
   "source": [
    "print(genome_size)\n",
    "print(bacteria_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "amsnF9L47gWd"
   },
   "source": [
    "When we want to make use of a function, what computer scientists refer to as **calling the function**, we follow its name by parentheses. The parentheses are important: if you leave them off, the function doesn't actually run!\n",
    "\n",
    "Sometimes you will include values or variables inside the parentheses for the function to use. In the case of `print`, we use the parentheses to tell the function which value we want to display. We will learn more about how functions work and how to create our own in later lessons.\n",
    "\n",
    "We can display multiple things at once using only one `print` function call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1719448476085,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "oQpyFVpi7ivD",
    "outputId": "36fc79f5-d834-4acf-cd5b-0e2498221ed9"
   },
   "outputs": [],
   "source": [
    "print(bacteria_id, \" genome size in kb: \", genome_kb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WsHwduqt7vjX"
   },
   "source": [
    "We can also call a function inside of another function call. For example, Python has a built-in function called `type` that tells you a value's data type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 458,
     "status": "ok",
     "timestamp": 1719448529350,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "6ZCBafYK7yQk",
    "outputId": "0d26a2c9-45ae-4326-ebf0-326c9cdd414f"
   },
   "outputs": [],
   "source": [
    "print(type(60.3))\n",
    "print(type(bacteria_id))\n",
    "print(type(genome_size))\n",
    "print(type(genome_kb))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OvDZ69F373aO"
   },
   "source": [
    "We can also do arithmetic with variables right inside the `print` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 445,
     "status": "ok",
     "timestamp": 1719448566856,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "oMNmpxlC75fA",
    "outputId": "d3b805ed-3959-409d-ca2b-0fa0b31ba761"
   },
   "outputs": [],
   "source": [
    "print(\"genome size in MB:\", genome_size / 1000000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BxsTLSDG8GbK"
   },
   "source": [
    "Note that the above function call did not change the value of `genome_size`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 468,
     "status": "ok",
     "timestamp": 1719448602574,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "aK3sN7nO8DWx",
    "outputId": "83fd1042-b795-4641-8929-e259d494f669"
   },
   "outputs": [],
   "source": [
    "print(genome_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3UrH-otn8OJL"
   },
   "source": [
    "To change the value of the `genome_size` variable, we have to\n",
    "**assign** a new value to `genome_size` using the equals `=` sign:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 549,
     "status": "ok",
     "timestamp": 1719448641027,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "b3Stj4VQ8Qhn",
    "outputId": "35c0daea-511b-496b-cea6-3781643baf18"
   },
   "outputs": [],
   "source": [
    "genome_size = 3100000000\n",
    "print(\"genome size is now:\", genome_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VulGkaqP9jMp"
   },
   "source": [
    "What values do the variables `rrna` and `protein` have after each of the following statements?\n",
    "\n",
    "Guess before executing the lines below..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-13T07:33:04.366522Z",
     "start_time": "2024-06-13T07:33:04.338279Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 193
    },
    "executionInfo": {
     "elapsed": 436,
     "status": "error",
     "timestamp": 1719448697762,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "ppi8ti6d9rd8",
    "outputId": "0d2113d4-24ac-4406-e990-e3b4bab88268"
   },
   "outputs": [],
   "source": [
    "rrna = 400\n",
    "print(\"There are \", rrna, \" rRNAs encoded in the human genome\")\n",
    "print(\"There are \", protein, \" proteins encoded in the human genome\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-13T07:33:05.113253Z",
     "start_time": "2024-06-13T07:33:05.101421Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 2,
     "status": "ok",
     "timestamp": 1719448839783,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "OrBQpVQXa2uS",
    "outputId": "b9344e7e-7f57-4b92-fd36-d2d9925fdc7e"
   },
   "outputs": [],
   "source": [
    "protein = 19126\n",
    "print(\"There are \", rrna, \" rRNAs encoded in the human genome\")\n",
    "print(\"There are \", protein, \" proteins encoded in the human genome\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-13T07:33:06.191673Z",
     "start_time": "2024-06-13T07:33:06.180664Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 417,
     "status": "ok",
     "timestamp": 1719448848748,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "0PEer3Jaa5gr",
    "outputId": "09198250-4f8a-42c9-cd83-d8253dfe5a16"
   },
   "outputs": [],
   "source": [
    "rrna = rrna * 2.0\n",
    "print(\"There are \", rrna, \" rRNAs encoded in the human genome\")\n",
    "print(\"There are \", protein, \" proteins encoded in the human genome\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-06-13T07:35:00.114969Z",
     "start_time": "2024-06-13T07:35:00.109498Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1719448855002,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "YqBUCO2Ua7Vk",
    "outputId": "ea4af57e-91d7-49dd-9ffb-6ef5cb97a548"
   },
   "outputs": [],
   "source": [
    "protein = protein - 126.0\n",
    "print(\"There are \", rrna, \" rRNAs encoded in the human genome\")\n",
    "print(\"There are \", protein, \" proteins encoded in the human genome\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EdWoZVG2-PKk"
   },
   "source": [
    "## Multiple definitions at once!\n",
    "\n",
    "Python allows you to assign multiple values to multiple variables in one line by separating the variables and values with commas. What does the following program print out?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 457,
     "status": "ok",
     "timestamp": 1719448875543,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "IAAYWlIQs3nq",
    "outputId": "4262b451-d47d-46f3-ff18-28d7d101c5f8"
   },
   "outputs": [],
   "source": [
    "a, b = \"E. coli\", \"Salmonella\"\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 457,
     "status": "ok",
     "timestamp": 1719448879999,
     "user": {
      "displayName": "Rob Edwards",
      "userId": "17780279723170493443"
     },
     "user_tz": -570
    },
    "id": "VkwNf2OT-UX9",
    "outputId": "c0b96b3d-f1a1-4e3f-d45f-22884e33a8de"
   },
   "outputs": [],
   "source": [
    "first, second = \"crAssphage\", \"phiX174\"\n",
    "third, fourth = second, first\n",
    "print(third, fourth)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aEZ_PCgkAhg7"
   },
   "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
}