Elementary Python for OT-2 API.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Introduction\" data-toc-modified-id=\"Introduction-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Introduction</a></span></li><li><span><a href=\"#Objectives\" data-toc-modified-id=\"Objectives-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Objectives</a></span></li><li><span><a href=\"#Disclaimer\" data-toc-modified-id=\"Disclaimer-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Disclaimer</a></span></li><li><span><a href=\"#System-Setup\" data-toc-modified-id=\"System-Setup-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>System Setup</a></span><ul class=\"toc-item\"><li><span><a href=\"#Installing-Spyder\" data-toc-modified-id=\"Installing-Spyder-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Installing Spyder</a></span></li></ul></li><li><span><a href=\"#Navigating-within-Spyder\" data-toc-modified-id=\"Navigating-within-Spyder-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Navigating within Spyder</a></span><ul class=\"toc-item\"><li><span><a href=\"#Useful-shortcuts-in-Spyder\" data-toc-modified-id=\"Useful-shortcuts-in-Spyder-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>Useful shortcuts in Spyder</a></span></li></ul></li><li><span><a href=\"#Getting-started\" data-toc-modified-id=\"Getting-started-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Getting started</a></span><ul class=\"toc-item\"><li><span><a href=\"#print()\" data-toc-modified-id=\"print()-6.1\"><span class=\"toc-item-num\">6.1&nbsp;&nbsp;</span><code>print()</code></a></span></li><li><span><a href=\"#Variable-assignment\" data-toc-modified-id=\"Variable-assignment-6.2\"><span class=\"toc-item-num\">6.2&nbsp;&nbsp;</span>Variable assignment</a></span></li><li><span><a href=\"#Comments\" data-toc-modified-id=\"Comments-6.3\"><span class=\"toc-item-num\">6.3&nbsp;&nbsp;</span>Comments</a></span></li></ul></li><li><span><a href=\"#Commonly-used-variable-types-(officially:-data-types)\" data-toc-modified-id=\"Commonly-used-variable-types-(officially:-data-types)-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Commonly used variable types (officially: data types)</a></span><ul class=\"toc-item\"><li><span><a href=\"#Some-basic-data-types-\" data-toc-modified-id=\"Some-basic-data-types--7.1\"><span class=\"toc-item-num\">7.1&nbsp;&nbsp;</span>Some basic data types <a name=\"ch2.1\"></a></a></span><ul class=\"toc-item\"><li><span><a href=\"#integer-(int)\" data-toc-modified-id=\"integer-(int)-7.1.1\"><span class=\"toc-item-num\">7.1.1&nbsp;&nbsp;</span>integer (int)</a></span></li><li><span><a href=\"#strings-(str)\" data-toc-modified-id=\"strings-(str)-7.1.2\"><span class=\"toc-item-num\">7.1.2&nbsp;&nbsp;</span>strings (str)</a></span></li><li><span><a href=\"#floating-point-numbers-(float)\" data-toc-modified-id=\"floating-point-numbers-(float)-7.1.3\"><span class=\"toc-item-num\">7.1.3&nbsp;&nbsp;</span>floating point numbers (float)</a></span></li><li><span><a href=\"#booleans-(bool)\" data-toc-modified-id=\"booleans-(bool)-7.1.4\"><span class=\"toc-item-num\">7.1.4&nbsp;&nbsp;</span>booleans (bool)</a></span></li></ul></li><li><span><a href=\"#Type-conversion\" data-toc-modified-id=\"Type-conversion-7.2\"><span class=\"toc-item-num\">7.2&nbsp;&nbsp;</span>Type conversion</a></span></li></ul></li><li><span><a href=\"#Lists-and-dictionaries\" data-toc-modified-id=\"Lists-and-dictionaries-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Lists and dictionaries</a></span><ul class=\"toc-item\"><li><span><a href=\"#list\" data-toc-modified-id=\"list-8.1\"><span class=\"toc-item-num\">8.1&nbsp;&nbsp;</span>list</a></span></li><li><span><a href=\"#dictionary-(dict)\" data-toc-modified-id=\"dictionary-(dict)-8.2\"><span class=\"toc-item-num\">8.2&nbsp;&nbsp;</span>dictionary (dict)</a></span></li></ul></li><li><span><a href=\"#Notes-on-doing-basic-maths\" data-toc-modified-id=\"Notes-on-doing-basic-maths-9\"><span class=\"toc-item-num\">9&nbsp;&nbsp;</span>Notes on doing basic maths</a></span></li><li><span><a href=\"#Basic-string-manipulation\" data-toc-modified-id=\"Basic-string-manipulation-10\"><span class=\"toc-item-num\">10&nbsp;&nbsp;</span>Basic string manipulation</a></span><ul class=\"toc-item\"><li><span><a href=\"#Empty-string\" data-toc-modified-id=\"Empty-string-10.1\"><span class=\"toc-item-num\">10.1&nbsp;&nbsp;</span>Empty string</a></span></li><li><span><a href=\"#Concatenation\" data-toc-modified-id=\"Concatenation-10.2\"><span class=\"toc-item-num\">10.2&nbsp;&nbsp;</span>Concatenation</a></span></li><li><span><a href=\"#Substring-using-slice\" data-toc-modified-id=\"Substring-using-slice-10.3\"><span class=\"toc-item-num\">10.3&nbsp;&nbsp;</span>Substring using slice</a></span></li><li><span><a href=\"#.append()\" data-toc-modified-id=\".append()-10.4\"><span class=\"toc-item-num\">10.4&nbsp;&nbsp;</span><del><code>.append()</code></del></a></span></li><li><span><a href=\"#.split()\" data-toc-modified-id=\".split()-10.5\"><span class=\"toc-item-num\">10.5&nbsp;&nbsp;</span><code>.split()</code></a></span></li></ul></li><li><span><a href=\"#Simple-custom-functions\" data-toc-modified-id=\"Simple-custom-functions-11\"><span class=\"toc-item-num\">11&nbsp;&nbsp;</span>Simple custom functions</a></span></li><li><span><a href=\"#For-loop\" data-toc-modified-id=\"For-loop-12\"><span class=\"toc-item-num\">12&nbsp;&nbsp;</span>For loop</a></span><ul class=\"toc-item\"><li><span><a href=\"#range()\" data-toc-modified-id=\"range()-12.1\"><span class=\"toc-item-num\">12.1&nbsp;&nbsp;</span><code>range()</code></a></span></li><li><span><a href=\"#Nested-for-loops\" data-toc-modified-id=\"Nested-for-loops-12.2\"><span class=\"toc-item-num\">12.2&nbsp;&nbsp;</span>Nested for loops</a></span></li></ul></li><li><span><a href=\"#If-else-statements-(optional-material)\" data-toc-modified-id=\"If-else-statements-(optional-material)-13\"><span class=\"toc-item-num\">13&nbsp;&nbsp;</span>If else statements (optional material)</a></span><ul class=\"toc-item\"><li><span><a href=\"#Comparison-operators\" data-toc-modified-id=\"Comparison-operators-13.1\"><span class=\"toc-item-num\">13.1&nbsp;&nbsp;</span>Comparison operators</a></span></li><li><span><a href=\"#Logical-operators\" data-toc-modified-id=\"Logical-operators-13.2\"><span class=\"toc-item-num\">13.2&nbsp;&nbsp;</span>Logical operators</a></span></li><li><span><a href=\"#If-else-examples\" data-toc-modified-id=\"If-else-examples-13.3\"><span class=\"toc-item-num\">13.3&nbsp;&nbsp;</span>If else examples</a></span></li></ul></li><li><span><a href=\"#A-superficial-introduction-to-the-concept-of-Object-Oriented-Programming-(OOP)\" data-toc-modified-id=\"A-superficial-introduction-to-the-concept-of-Object-Oriented-Programming-(OOP)-14\"><span class=\"toc-item-num\">14&nbsp;&nbsp;</span>A superficial introduction to the concept of Object-Oriented Programming (OOP)</a></span></li><li><span><a href=\"#Final-remarks-(that-we-cannot-cover-today)\" data-toc-modified-id=\"Final-remarks-(that-we-cannot-cover-today)-15\"><span class=\"toc-item-num\">15&nbsp;&nbsp;</span>Final remarks (that we cannot cover today)</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "In this workshop we will cover the basic elements of programming in Python. Only materials that are absolutely essential to understanding and programming the OT-2 API will be covered. This workshop is intended for people with little to no programming experience.\n",
    "\n",
    "# Objectives\n",
    "\n",
    "By the end of this workshop, we hope participants are able to:\n",
    "\n",
    "1. Set up an IDE for coding in Python, and put to use the features that faciliate coding and debugging.\n",
    "2. Understand the common data types in Python and when to use which.\n",
    "3. Perform simple calculations and modify strings.\n",
    "4. Understand the concept of function and where to check their arguments.\n",
    "5. Write for loops to automatically repeat blocks of codes.\n",
    "6. Understand superficially the concept of Object-Oriented Programming.\n",
    "7. Make use of knowledge of points 2-5 above to solve practical issues in using the OT-2.\n",
    "\n",
    "# Disclaimer\n",
    "I have limited experience in programming and received little formal training. Coding practices may be unorthodox and even heretic in the eyes of properly trained programmers.\n",
    "\n",
    "The information that we will go over is filtered specifically for understanding the OT-2 API. Many other useful functions are omitted simply because they are non-essential from the API's perspective. Those who wish to make the full use of Python + the robot would benefit greatly by attending Python courses offered by the Software Capentry in the University of Edinburgh or by the Edinburgh Genomics.\n",
    "\n",
    "Please forgive my ocassional loss of professionalism in language.\n",
    "\n",
    "# System Setup\n",
    "\n",
    " \n",
    "## Installing Spyder\n",
    "It is best to make use of an Integrated Development Environment (IDE) when writing codes. My personal experience suggests that  Spyder is most friendly to Python beginners and its Variable Explorer is tremendously helpful, both in debugging and in understanding how the code works.\n",
    "\n",
    "The relatively fool-proof way to get Spyder is to download and install [Anaconda](https://www.anaconda.com/distribution/).\n",
    "\n",
    "*Note: I strongly recommend you NOT to install the app Kite. It does more harm than good in my experience*\n",
    "\n",
    "From time to time you might need to upgrade your IDE or your packages. To do so, type `conda update --all` inside the Spyder IPython console, or follow the [instructions](https://www.anaconda.com/keeping-anaconda-date/) from Anaconda.\n",
    "\n",
    "# Navigating within Spyder\n",
    "\n",
    "![SpyderInterface](images/Spyder_interface.png)\n",
    "\n",
    "## Useful shortcuts in Spyder\n",
    "1. F5 = Run entire script\n",
    "2. Ctrl/Cmd + Return/Enter = Run cell\n",
    "3. Ctrl/Cmd + 1 = Comment/De-comment\n",
    "\n",
    "**Cells are partitioned by the comment `#%%` in the Spyder Editor.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting started\n",
    "\n",
    "## `print()`\n",
    "\n",
    "The `print()` function is your best friend. You get to know what's going on by asking the computer to show you what you are interested."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable assignment\n",
    "The equal sign `=` in almost all programming languages denote an assignment of value to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    }
   ],
   "source": [
    "a = 1000\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OT-2\n"
     ]
    }
   ],
   "source": [
    "b = \"OT-2\"\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double assignment allows two assignments in a single line.  \n",
    "You can also do triple or mulitple assignments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n",
      "OT-2\n"
     ]
    }
   ],
   "source": [
    "a, b = 1000, \"OT-2\"\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that if you don't do an assignment in the line, the console will give the output directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'OT-2'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comments\n",
    "Comments are your explanations of what the code does. It helps other people to understand what you are trying to do, and helps you remember why you code in a particular way. The following example is just an illustration. Comments for self-explanatory codes are redundant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2500.0\n"
     ]
    }
   ],
   "source": [
    "# This code calculate Fluorescence / OD\n",
    "fluo = 5000\n",
    "od = 2.0\n",
    "fluo_OD = fluo / od\n",
    "print(fluo_OD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# # !\"£$%^&*()_+\"     * Note that once you have a hashtag, whatever that comes afterwards are all comments.\n",
    "# You have to start a new line without a hashtag to resume coding\n",
    "fluo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One useful thing to do with comments is to \"comment-out\" a section of the code, that is, not run that part only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Without using comment-out:\n",
      "5.0\n"
     ]
    }
   ],
   "source": [
    "a = 1000\n",
    "b = 200\n",
    "a = a/b\n",
    "print(\"Without using comment-out:\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using comment-out:\n",
      "1000\n"
     ]
    }
   ],
   "source": [
    "a = 1000\n",
    "b = 200\n",
    "# a = a/b\n",
    "print(\"Using comment-out:\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Commonly used variable types (officially: data types)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some basic data types <a name=\"ch2.1\"></a>\n",
    "### integer (int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4000\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "var_int = 4000\n",
    "print(var_int)\n",
    "print(type(var_int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### strings (str)\n",
    "for texts and characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OT-2\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "var_str = \"OT-2\"\n",
    "print(var_str)\n",
    "print(type(var_str))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### floating point numbers (float)\n",
    "In an over-simplified sense, any other number that carries decimal points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10123598.8562545\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "var_float = 10123598.8562545\n",
    "print(var_float)\n",
    "print(type(var_float))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### booleans (bool)\n",
    "Only takes True or False, equivalent to 1 or 0.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "var_bool1 = True\n",
    "var_bool2 = False\n",
    "print(var_bool1)\n",
    "print(var_bool2)\n",
    "print(type(var_bool1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to infer the type of the variable in the console by calling it directly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4000"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'OT-2'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10123598.8562545"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_bool1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type conversion\n",
    "In some cases it is useful to convert string into numbers, and vice versa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'89006542'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(89006542)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "85678"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('85678')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you string contains alphabets, conversion to an int or float will fail"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'A1'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-21-d5e71966c3c3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'A1'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: 'A1'"
     ]
    }
   ],
   "source": [
    "int('A1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conversion of a float in string format to int is also prohibited"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "85.67"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('85.67')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: '85.67'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-515ef414cde9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'85.67'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: '85.67'"
     ]
    }
   ],
   "source": [
    "int('85.67')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conversion of float to int will remove the digits behind the decimal point "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(1000.786)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists and dictionaries\n",
    "\n",
    "If you do a PCR and only have one sample you use a single PCR tube. If you deal with 7-8 samples that are ordered you use PCR tube strips. If you have hundreds of samples you use 96-well or 384-well plates. The key point is that your sample locations are **indexed**. You do the same in programming.\n",
    "\n",
    "## list\n",
    "A list is equivalent to PCR tube strips, just that they have (nearly) infinite length. You label one strip with one name.  \n",
    "\n",
    "Items are delimited by a comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_list = [1, 2, 3, 4, 5, 6]\n",
    "var_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create an empty list, just leave it empty but with brackets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_list = []\n",
    "var_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can literally put anything inside a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 10, 100, 'text', True]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 10\n",
    "var_list = [1, a, 100, 'text', True] # A mix of int, var, str, and bool\n",
    "var_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can put a list inside a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, [5, 6, 7]]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [5, 6, 7]\n",
    "list2 = [1, 2 , 3, list1]\n",
    "list2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have a long list, you can arrange them vertically in the code.  \n",
    "Ending a list with a comma is fine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1005719631856,\n",
       " 5746381643542,\n",
       " 8434216572496,\n",
       " 2491294949454,\n",
       " 21975214621121,\n",
       " 1964943136274,\n",
       " 1984249121000,\n",
       " 149219542792464]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_list = [\n",
    "    1005719631856,\n",
    "    5746381643542,\n",
    "    8434216572496,\n",
    "    2491294949454,\n",
    "    21975214621121,\n",
    "    1964943136274,\n",
    "    1984249121000,\n",
    "    149219542792464,\n",
    "]\n",
    "int_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All items inside a list has an index for retrieving the item. A list is ordered - the item order is preserved when the list is called.\n",
    "Using the example of `var_list`:  \n",
    "\n",
    "| index | item |\n",
    "|-----|----|\n",
    "|0|1|\n",
    "|1|10|\n",
    "|2|100|\n",
    "|3|'text'|\n",
    "|4|True|\n",
    "\n",
    "This allows you to get retrieve specific items from the list using the `[]` notation.  \n",
    "\n",
    "**Note that the first item of a list has the index of 0, not 1. Think of a list as a building and index 0 is the \"Ground Floor\".**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'text'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_list[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To replace an item in the list, reassign it.  \n",
    "Let's replace the 'text' item with index=3 to '1000'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 10, 100, 1000, True]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_list[3] = 1000\n",
    "var_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trying to call the an item beyond indicies that correspond to an item will lead to an `IndexError`.\n",
    "If you see this error, you must be counting the list wrong."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true,
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-33-12cebd302046>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mvar_list\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "var_list[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Counting backwards? 2nd item from the end of the list? Put a minus symbol `-` before your index `1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_list[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slice a list by using the \"slice operator\" `:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100, 1000, True]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get items from index = 2 till the end of sequence\n",
    "var_list[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 10, 100]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get items from the beginning till item of index = 2\n",
    "# In other words, var_list[:3] is equivalent to var_list[0:3]\n",
    "var_list[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1000, True]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_list[3:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Take note! `[3:5]` actually gives items from index=0 to index=2. So it is actually getting item_of_start_index to item_of_(end_index - 1) !**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combining a negative index with the splice operator allows you to get multiple items from the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100, 1000, True]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var_list[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Beware that when couting backwards, the last item has an index of -1, not -0.**\n",
    "\n",
    "To get the length of the list, use the `len()` function, with the list as the input argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(var_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add items to a list (aka. grow a list), use the `list.append()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 10, 100, 1000, True, 'new']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "item_to_add = 'new'\n",
    "var_list.append(item_to_add)\n",
    "var_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The list should now have a length of 6 instead of 5\n",
    "len(var_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To concatenate two or more lists, simply use the `+` operator "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1, 2, 3] \n",
    "list2 = [4, 5, 6]\n",
    "list3 = [7, 8, 9]\n",
    "long_list = list1 + list2 + list3\n",
    "long_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dictionary (dict)\n",
    "A dictionary can be understood as a list with unique \"name tags\" to every item it stores.\n",
    "While a list is denoted by square brackets, a dictionary is denoted by curly brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Monday': 'Clean gel tank',\n",
       " 'Tuesday': 'Autoclave tips',\n",
       " 'Wednesday': 'Clear bins'}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chores = {'Monday': \"Clean gel tank\",\n",
    "            'Tuesday': \"Autoclave tips\",\n",
    "            'Wednesday': \"Clear bins\"\n",
    "           }\n",
    "chores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Items are retreived in a similar way as lists, just that there are no indicies but only \"name-tags\", which are called **keys**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Clean gel tank'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chores['Monday']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you try to call a key that is absent from the dictionary, you will get an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'Sunday'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-45-50c1074f10b3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mchores\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'Sunday'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'Sunday'"
     ]
    }
   ],
   "source": [
    "chores['Sunday']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To avoid running into error, use the `dict.get(key)` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clean gel tank\n"
     ]
    }
   ],
   "source": [
    "print(chores.get('Monday'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(chores.get('Sunday'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the reason why it is called a dictionary, is that like a dictionary, you can't have two entries of the same word.  \n",
    "If you insist on doing so, the most recent assignment will overwrite the previously assigned key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'table': 'a set of facts or figures systematically displayed, especially in columns (Google def 2)'}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note how the first definition becomes \"erased\" in the output\n",
    "\n",
    "var_dict = {\n",
    "    'table': \"a piece of furniture with a flat top and one or more legs (Google def 1)\",\n",
    "    'table': \"a set of facts or figures systematically displayed, especially in columns (Google def 2)\"\n",
    "}\n",
    "var_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create an empty dictionary, put nothing inside the curly brakets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "null_dict = {}\n",
    "null_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add a `key: item` pair to a dictionary, just assign it to a new key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Monday': 'Clean gel tank',\n",
       " 'Tuesday': 'Autoclave tips',\n",
       " 'Wednesday': 'Clear bins',\n",
       " 'Thursday': 'Refill MilliQ water tank'}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chores['Thursday'] = \"Refill MilliQ water tank\"\n",
    "chores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be careful though, if a key alreayd exist, trying to add a new `key: item` pair with the same key will overwrite the previous item."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To concatenate two dictionaries, use the `dict.update()` function. The input argument must be a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Monday': 'Clean gel tank',\n",
       " 'Tuesday': 'Autoclave tips',\n",
       " 'Wednesday': 'Clear bins',\n",
       " 'Thursday': 'Refill MilliQ water tank',\n",
       " 'Friday': 'Buy beer for happy hour',\n",
       " 'Saturday': 'Hang over'}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_chores = {\n",
    "    'Friday': \"Buy beer for happy hour\",\n",
    "    'Saturday': \"Hang over\",\n",
    "             }\n",
    "chores.update(new_chores)\n",
    "chores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same function can also be used to add a single key:item pair, making it a very versatile function. I prefer using it over the assignment method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Monday': 'Clean gel tank',\n",
       " 'Tuesday': 'Autoclave tips',\n",
       " 'Wednesday': 'Clear bins',\n",
       " 'Thursday': 'Refill MilliQ water tank',\n",
       " 'Friday': 'Buy beer for happy hour',\n",
       " 'Saturday': 'Hang over',\n",
       " 'Sunday': 'Do nothing'}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chores.update({'Sunday': \"Do nothing\"})\n",
    "chores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notes on doing basic maths\n",
    "Simple addition, subtraction, multiplication is just like that of Excel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "205"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + 10 * 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above example takes only int as input and you get back an int as output. Put a float anywhere inside and you get back a float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "205.0"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5.0 + 10 * 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whenever you do a division, you always get back a float, even if your inputs are all int and your dividend is divisible by your divisor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100 / 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The proper way to do power is not through the `^` sign, but rather, `**`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2^4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic string manipulation\n",
    "\n",
    "String can be seen as list objects consisting of only characters, numbers and symbols. So, you can use some of the same functions from list on strings.\n",
    "\n",
    "## Empty string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "null_str = \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello_world  = \"Hello\" + \" \" + \"World\"\n",
    "hello_world"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Substring using slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello_world[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'rl'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello_world[-3:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ~~`.append()`~~\n",
    "Note that there is no such function `.append()` for str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'str' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-62-b9e99d8024a8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mhello_world\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\" Goodbye World\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'str' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "hello_world.append(\" Goodbye World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `.split()`\n",
    "The `.split()` function takes a user-determined delimiter, removes the delimiter from the str, and return the rest of the parts as a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'World']"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello_world.split(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['University', 'of', 'Edinburgh']"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"University of Edinburgh\".split(\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The delimiter can be anything, so long as it is inside the str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['University', 'Edinburgh']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "split_str = \"University of Edinburgh\".split(\" of \")\n",
    "split_str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The individual words/strings/stretches of characters can then be retrieved through the list's indicies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Edinburgh'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_name = split_str[1]\n",
    "city_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A combinatoin of double assignment and `.split()` works magic in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Trevor'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_name = \"Trevor Ho\"\n",
    "first_name, last_name = my_name.split(\" \")\n",
    "first_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ho'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "last_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple custom functions\n",
    "\n",
    "The function in computer science has its roots in mathematical functions like y = f(x), y is output, f is the function name, x is the input. It is very similar in Python.\n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def divide(dividend, divisor):\n",
    "    quotient = dividend / divisor\n",
    "    return quotient\n",
    "\n",
    "divide(1000,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "source": [
    "function name: the name that is followed by parentheses and right after the reserved word `def`  \n",
    "input: variables that are inside the parentheses, their proper name is **\"arguments\"**  \n",
    "output: the varaible that follows after the reserved word `return`\n",
    "\n",
    "the output (and hence `return`) is entirely optional if you just want the function to carry out something\n",
    "\n",
    "**Important: notice that the lines below `def` are right indented. This is to tell Python that those lines belong to the function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-70-892f0500f8b6>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-70-892f0500f8b6>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    quotient = dividend / divisor\u001b[0m\n\u001b[1;37m           ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "def divide(dividend, divisor):\n",
    "quotient = dividend / divisor\n",
    "return quotient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An extremely important point is that **the order of arguments matters**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.01"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divide(10,1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, it is ok change the order if your specify what variables are meant for what arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100.0"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divide(divisor=10, dividend=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note: always write and debug your function without `def` and `return` first before encapsulating it with def and return.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# For loop\n",
    "\n",
    "For loop is used when you need to repeat blocks of code for a set number of times. \n",
    "The for loop is arguably the most important concept to master if you wish to make the most out of the robot.\n",
    "\n",
    "Let's start with an example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I should do my experiments\n",
      "I should do my experiments\n",
      "I should do my experiments\n"
     ]
    }
   ],
   "source": [
    "for i in [1,2,3]:\n",
    "    print(\"I should do my experiments\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The command `print()` was executed three times, because there are 3 items within the list of `[1,2,3]`  \n",
    "Notice that it was indented and so was within the loop.\n",
    "\n",
    "Simply iterating a fixed action isn't very helpful, but the for loop in Python is inherently built to be mutable at every iteration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pipette water into well A1\n",
      "Pipette water into well B1\n",
      "Pipette water into well C1\n"
     ]
    }
   ],
   "source": [
    "for well in [\"A1\", \"B1\", \"C1\"]:\n",
    "    action = \"Pipette water into well \" + well\n",
    "    print(action)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `range()`\n",
    "\n",
    "If you need to iterate your action 100 times, it would not make sense to manually create a list of 1 to 100.\n",
    "The `range(start, stop, step)` function is very useful in this situation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(1, 10)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Notice that the range function creates only a range object\n",
    "x = range(1,10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To turn that into something useful, pass the range object into the list() function\n",
    "list(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the function does not stop at `10`, but rather, `9`. This is similar to the `:` operator in slicing a list. To obtain a list of numbers from 1 to 12, the correct input is `range(1,13)`\n",
    "\n",
    "A combination of the `range()` function with a for loop then works magic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pipette water into column 1 of the destination plate\n",
      "Pipette water into column 2 of the destination plate\n",
      "Pipette water into column 3 of the destination plate\n",
      "Pipette water into column 4 of the destination plate\n",
      "Pipette water into column 5 of the destination plate\n",
      "Pipette water into column 6 of the destination plate\n",
      "Pipette water into column 7 of the destination plate\n",
      "Pipette water into column 8 of the destination plate\n",
      "Pipette water into column 9 of the destination plate\n",
      "Pipette water into column 10 of the destination plate\n",
      "Pipette water into column 11 of the destination plate\n",
      "Pipette water into column 12 of the destination plate\n"
     ]
    }
   ],
   "source": [
    "for column in range(1,13): # by convention, variable names of i, j, k are very popular in for loop creation\n",
    "    action = \"Pipette water into column \" + str(column) + \" of the destination plate\"\n",
    "    print(action)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested for loops\n",
    "\n",
    "Sometimes we have loop in more than 1 dimension, e.g. Sample 1: pipette up and down 3 times, Sample 2: pipette up and down 3 times, Sample 3: pipette up and down 3 times.\n",
    "\n",
    "To do this, it is helpful to put one for loop inside the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Switch to sample 1\n",
      "Pipette sample up and down\n",
      "Pipette sample up and down\n",
      "Pipette sample up and down\n",
      "Switch to sample 2\n",
      "Pipette sample up and down\n",
      "Pipette sample up and down\n",
      "Pipette sample up and down\n",
      "Switch to sample 3\n",
      "Pipette sample up and down\n",
      "Pipette sample up and down\n",
      "Pipette sample up and down\n"
     ]
    }
   ],
   "source": [
    "for sample in [\"1\", \"2\", \"3\"]:\n",
    "    change_sample = \"Switch to sample \" + sample\n",
    "    print(change_sample)\n",
    "    for i in range(3):\n",
    "        print(\"Pipette sample up and down\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To further integrate the sample name and action step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pipette sample 1 up and down\n",
      "Pipette sample 1 up and down\n",
      "Pipette sample 1 up and down\n",
      "Pipette sample 2 up and down\n",
      "Pipette sample 2 up and down\n",
      "Pipette sample 2 up and down\n",
      "Pipette sample 3 up and down\n",
      "Pipette sample 3 up and down\n",
      "Pipette sample 3 up and down\n"
     ]
    }
   ],
   "source": [
    "for sample in [\"1\", \"2\", \"3\"]:\n",
    "    for i in range(3):\n",
    "        action = \"Pipette sample \" + sample + \" up and down\"\n",
    "        print(action)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# If else statements (optional material)\n",
    "\n",
    "## Comparison operators\n",
    "They are used to compare two variables. Output is a boolean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 < 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 > 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "15 <= 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comparison operator for checking equality is `==`. This often get mixed up with the assignment symbol `=`.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Python' == 'Python'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Python' != 'Python'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking if item in lists and dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1, 2, 3, 4, 5, 6, 7, 8]\n",
    "3 in list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9 in list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Monday': 'Clean gel tank',\n",
       " 'Tuesday': 'Autoclave tips',\n",
       " 'Wednesday': 'Clear bins',\n",
       " 'Thursday': 'Refill MilliQ water tank',\n",
       " 'Friday': 'Buy beer for happy hour',\n",
       " 'Saturday': 'Hang over',\n",
       " 'Sunday': 'Do nothing'}"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Monday' in chores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'March' in chores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 >= 9 and 10 <= 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 >= 9 or 10 <= 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 >= 9 or not (10 <= 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If else examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Different\n"
     ]
    }
   ],
   "source": [
    "fluo1 = 16\n",
    "fluo2 = 20\n",
    "if fluo1 == fluo2:\n",
    "    print(\"Same\")\n",
    "else:\n",
    "    print(\"Different\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fluo2 larger\n"
     ]
    }
   ],
   "source": [
    "if fluo1 == fluo2:\n",
    "    print(\"Same\")\n",
    "elif fluo1 > fluo2:\n",
    "    print(\"Fluo1 larger\")\n",
    "else:\n",
    "    print(\"Fluo2 larger\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Indentation is important**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "scrolled": true,
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-99-9d4b7f21bf49>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-99-9d4b7f21bf49>\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    elif fluo1 > fluo2:\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "if fluo1 == fluo2:\n",
    "    print(\"Same\")\n",
    "    elif fluo1 > fluo2:\n",
    "        print(\"Fluo1 larger\")\n",
    "    else:\n",
    "        print(\"Fluo2 larger\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A superficial introduction to the concept of Object-Oriented Programming (OOP)\n",
    "\n",
    "The idea of OOP is to make virtual objects inside the computer and let them interact with each other, or ask them to do something.\n",
    "\n",
    "A good cartoon illustration is available on a [page](https://www.freecodecamp.org/news/object-oriented-programming-concepts-21bb035f7260/) written by FreeCodeCamp. Let's scroll until you see a cat.\n",
    "\n",
    "The most important concept is that most virtual objects are like an object in real life: each has some properties (e.g. breed, color, gender, height, weight, etc.) and is able do something (e.g. meow, eat, sleep, etc)\n",
    "\n",
    "Objects' properties are coded by variables within an object. In Python, they are accessed as `object.var`.  \n",
    "For example, `cat.breed`  \n",
    "\n",
    "Objects' abilities to do something are executed via methods. In Python, they are accessed as `object.method()`.  \n",
    "For example, `cat.eat()`\n",
    "\n",
    "Take home messages:\n",
    "1. If you see `sth.xyz`, without parentheses behind, `xyz` is a variable/attribute/property of the object. \n",
    "2. If you see `sth.xyz()`, `xyz()` is a method that is part of the \"innate\" abilities of the object to do something.  \n",
    "3. Objects themselves can act on other objects, i.e. when an object is an argument of a method of another object.\n",
    "\n",
    "Superficially, the terms \"properties\", \"attributes\" and \"fields\" are often used interchanagbly. One can also view \"functions\" and \"methods\" in a similary manner, though methods and functions are technically distinct.\n",
    "\n",
    "The following is an example of creating objects of humans and viruses to see if the humans with some properties (`age`) can survive an infection `.infect()` by a virus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alexander is dead\n",
      "Beth is alive\n",
      "Chris is alive\n",
      "Dorothy is dead\n"
     ]
    }
   ],
   "source": [
    "# Make templates for objects (Ignore this part)\n",
    "\n",
    "class Person:\n",
    "    \n",
    "    name = \"\"\n",
    "    hp = 0\n",
    "    age = 0\n",
    "    status = \"alive\"\n",
    "    \n",
    "    def __init__(self, name, hp, age):\n",
    "        self.name = name\n",
    "        self.hp = hp\n",
    "        self.age = age\n",
    "        self.status = \"alive\"\n",
    "        \n",
    "    def set_status(self):\n",
    "        if self.hp <= 0:\n",
    "            self.status = \"dead\"\n",
    "        \n",
    "class Virus:\n",
    "    \n",
    "    lethality = 0\n",
    "    \n",
    "    def __init__(self, lethality):\n",
    "        self.lethality = lethality\n",
    "        \n",
    "    def infect(self,person):\n",
    "        person.hp = person.hp - person.age * self.lethality\n",
    "        person.set_status()\n",
    "\n",
    "# Create objects\n",
    "\n",
    "patient1 = Person(name = \"Alexander\", hp = 1000, age = 50)\n",
    "patient2 = Person(name = \"Beth\", hp = 9000, age = 25)\n",
    "patient3 = Person(name = \"Chris\", hp = 5000, age = 17)\n",
    "patient4 = Person(name = \"Dorothy\", hp = 7000, age = 90)\n",
    "\n",
    "corona = Virus(lethality = 100)\n",
    "\n",
    "# Let objects take action\n",
    "\n",
    "corona.infect(patient1)\n",
    "corona.infect(patient2)\n",
    "corona.infect(patient3)\n",
    "corona.infect(patient4)\n",
    "\n",
    "# Get the outcomes\n",
    "\n",
    "for patient in [patient1, patient2, patient3, patient4]:\n",
    "    outcome = patient.name + \" is \" + patient.status\n",
    "    print(outcome)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final remarks (that we cannot cover today)\n",
    "\n",
    "1. When you are stuck, Google. Chances are there is someone who had the same issue as you do and his/her question is answered on Stack Overflow.\n",
    "\n",
    "2. There is an [official guide](https://www.python.org/dev/peps/pep-0008) in Python on how to style your code to improve readibility. As you code more and more frequently you will find this useful.\n",
    "\n",
    "3. Learning how to read documentation of libraries / codes written by others will grant you the ability to learn how to code on your own.\n",
    "\n",
    "4. Properly document your code will make them useful to yourself and others in the long run."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "323px",
    "width": "390px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}