01_week1_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 1 Tutorial - Data Types and Basic Operations\n",
    "\n",
    "For the first class, we will cover the following topics:\n",
    "\n",
    "1. Python Programming in Biology \n",
    "2. Using Jupyter Notebook\n",
    "3. Data Types and Basic Operations \n",
    "    * Numbers and arithmetic operations\n",
    "    * Strings and string operations\n",
    "    * Booleans, comparison operations, and logical operations \n",
    "    * Variables \n",
    "    * Lists, tuples, dictionaries, and sets \n",
    "    * Indexing and slicing of sequence data types \n",
    "4. Input and Output \n",
    "    * input()\n",
    "    * print()\n",
    "5. Special Characters \n",
    "    * Backslash "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Programming in Biology\n",
    "\n",
    "Python is a versatile and widely used programming language, it can be used in a wide range of applications in biology research. Some of the common uses of Python in biology research include:\n",
    "\n",
    "* Data analysis: Python can be used to analyse large datasets, such as those generated by high-throughput sequencing technologies, microarrays, or proteomics experiments. \n",
    "* Computational modelling: Python can be used to develop mathematical models of biological systems, such as protein-protein interactions, metabolic pathways, or gene regulatory networks. \n",
    "* Machine learning: Python can be used for machine learning applications in biology, such as predicting protein structure or function, identifying disease biomarkers, or classifying cell types. \n",
    "* Image analysis: Python can be used to process and analyse biological images, such as those generated by microscopy or medical imaging. \n",
    "\n",
    "Python allows researchers to automate repetitive tasks, process large datasets efficiently, and develop and simulate complex models. Python is also easy to learn and use, making it accessible to a wide range of researchers, including those with little or no experience. Additionally, the large and active Python community means that there are many resources, libraries, and packages available to support biological research. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Jupyter Notebook \n",
    "\n",
    "__About Jupyter Notebook:__\n",
    "\n",
    "Jupyter Notebook is an open-source web-based interactive computing environment that allows you to create, run, and share live code, equations, visualizations, and narrative text in a single document. It supports multiple programming languages, including Python, R, Julia, and many others. Jupyter Notebook is commonly used in data science, machine learning, scientific computing, and other domains for interactive data analysis, visualization, and exploration. \n",
    "\n",
    "Jupyter Notebook provides a browser-based interface where you can create \"notebooks\" that contain code cells, text cells, and other types of cells. Code cells allow you to write and execute code directly in the notebook, while text cells allow you to write narrative text, equations, and markdown for documentation and explanations. This combination of code and text cells makes Jupyter Notebook an excellent tool for creating reproducible research, documenting data analysis workflows, and sharing interactive notebooks with others.\n",
    "\n",
    "There are other text editors you can use for Python programming as well, such as Visual Studio Code, Spyder, and PyCharm. \n",
    "\n",
    "__Run your first code:__\n",
    "\n",
    "Put the cursor in the box below and click the \"run\" button (or press `shift+enter` on your keyboard) to see the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above cell is a code cell. For all code cells, you can see a `In []` displaying before the cell. \n",
    "\n",
    "__Text cells:__\n",
    "\n",
    "You can double click to edit the text cells, and click the \"Run\" button or press `shift+enter` to display the text cells properly. We're not going to cover how to write formatted texts in Jupyter Notebook in this course, our main purpose is to practise coding. \n",
    "\n",
    "__The two status of a cell:__\n",
    "\n",
    "* When you're in the edit mode of a cell, the cell will show a __green__ border. You can edit the contents of the cell.\n",
    "* When you're in the command mode of a cell, the cell will show a __blue__ border. You can perform various operations on the notebook, such as adding cells , deleting cells , and changing cell types. \n",
    "\n",
    "__Shortcuts:__\n",
    "\n",
    "When you're in the edit mode:\n",
    "* Press `shift+enter` to run the cell. \n",
    "* Press `esc` to go to the command mode.\n",
    "\n",
    "When you're in the command mode:\n",
    "* Press `b` to add a new cell.\n",
    "* Press `d` twice to delete the cell.\n",
    "* Press `y` to change the cell type to code.\n",
    "* Press `m` to change the cell type to text.\n",
    "* Press `enter` to go to the edit mode.\n",
    "\n",
    "If you forgot the shortcuts, you can always use the tool bar.\n",
    "\n",
    "__Exercise: play with the above shortcuts, create some new cells, delete some existing cells, and changing between cell types.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types and Basic Operations \n",
    "### Integers `int`\n",
    "\n",
    "In Python, integers (int) are a built-in data type that represents whole numbers without any fractional or decimal parts. Integers can be positive, negative, or zero, and can have an unlimited range of values, limited only by the available system memory.\n",
    "\n",
    "You can define an integer variable in Python by assigning a whole number to a variable name. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = -10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Floating-point numbers `float`\n",
    "\n",
    "Floating-point numbers in Python are a type of numerical data that can represent real numbers with decimal values. They are implemented as a built-in data type called \"float\" in Python and are used for performing arithmetic operations with real numbers that require precision beyond what can be achieved with integers.\n",
    "\n",
    "In Python, you can create a floating-point number by simply including a decimal point in a numeric value. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3.14 \n",
    "b = 2.0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic operations \n",
    "\n",
    "Arithmetic operations can be performed on integers and floating-point numbers in Python using the standard arithmetic operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# addition \n",
    "10+3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# substraction \n",
    "10-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplication\n",
    "10*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# division \n",
    "10/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# exponentiation\n",
    "10**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# modulo operator \n",
    "10%3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# floor division operator \n",
    "10//3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# calculate the quotient and remainder\n",
    "divmod(17,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Commenting in Python:__ anything after a `#` is a comment, comments won't be read by the computer so it means nothing in programming. It is used to explain why the code is written in a particular way. Normally, we use `#` for single line comments and `\"\"\" comments \"\"\"` for multi-line comments. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Start\")\n",
    "\n",
    "\"\"\"\n",
    "Hi!\n",
    "Let's do some calculation!\n",
    "\"\"\"\n",
    "\n",
    "print(\"End\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may think we are never going to use these functions... However, for DNA sequences we often care about the multiples of three:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "divmod(1464, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can perform arithmetic operations on floating-point numbers too, try it yourself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# addition "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# substraction "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplication "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# division "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exponentiation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# modulo operator "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# floor division operator "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__When you perform an arithmetic operation on floating-point numbers, what is the type of the result number?__\n",
    "\n",
    "It will a floating-point number. \n",
    "\n",
    "__Limited precision of floating-point numbers:__\n",
    "\n",
    "Floating-point numbers in Python, as well as in most other programming languages, have inherent limitations due to the way they are represented in computer hardware. Floating-point numbers are represented with a fixed number of bits, which limits their precision. As a result, some numbers cannot be exactly represented, and rounding errors can occur in arithmetic operations. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0.1+0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0.3-0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__What would you get if you calculate an integer with a floating-point number?__ Please try it yourself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# please do some calculations on integers with floating-point numbers \n",
    "3 + 3.0 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result will be floating-point number, even if it is a whole number. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings `str`\n",
    "\n",
    "In Python, a string is a sequence of characters enclosed in either single quotes '' or double quotes \"\". Strings are one of the built-in data types in Python and are used to represent text and manipulate it in various ways. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello, world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Hello, world!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"My name is ...\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can put double quotes in single quotes and vice versa. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"It's Harvey's birthday today.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'It's Harvey's birthday today.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"I was \"surprised\" when I saw her.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'I was \"surprised\" when I saw her.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Operations \n",
    "\n",
    "__Concatemation__\n",
    "\n",
    "Strings can be concatenated using the `+` operator, which combines two or more strings into a single string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello,\" + \"world!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we use `+` operator to concatenate strings, it doesn't provide the space character in between so we need to add it manually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add the space\n",
    "\"Hello, \" + \"world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"Hi, \" + \"my name is ...\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"I have \" + str(x) + \" apples.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the error message we can also see that we can't concatenate strings with integers using the `+` operator. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Repetition__\n",
    "\n",
    "Strings can be repeated using the `*` operator, which creates multiple copies of a string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hello!\" * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Let's go!\" * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Converting cases and replacing substrings__\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"The weather is good today!\".upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"LOL\".lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"My name is Jiajia.\".replace(\"Jiajia\", \"your name\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Booleans `bool`\n",
    "\n",
    "Booleans in Python are a data type that can have one of two possible values: True or False. \n",
    "\n",
    "They are commonly used in conditional statements, comparisons, and logical operations. Booleans in Python are a subclass of integers, with True representing the integer 1 and False representing the integer 0.\n",
    "\n",
    "### Comparison Operations\n",
    "\n",
    "Comparison operations, also known as relational operators, are used in Python to compare values and determine their relationship. They return a boolean value, either TRUE or FALSE, depending on whether the comparison is true or false. \n",
    "\n",
    "__Equality: `==`__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1.0 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "66 == \"66\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Blue\" == \"Red\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"Blue\" == 'Blue'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Think of some examples yourself and try the equal to `==` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Inequality: `!=`__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 != 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 != 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "66 != \"66\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Blue\" != \"Red\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Blue\" != \"Blue\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Think of some examples yourself and try the not equal to `!=` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Greater than: `>`__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing an integer with a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "66 > \"55\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Turns out we can't compare integers with strings.\n",
    "\n",
    "Comparing a string with a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"123\" > \"100\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"10000\" > \"101\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"apple\" > \"banana\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"appleapple\" > \"banana\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python compares strings lexicographically based on their ASCII values. The comparison starts with the first character of the strings and proceeds to subsequent characters until a difference is found or until the end of one of the strings is reached. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"Aa\" > \"aa\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If there is no difference until the end of one string, it will compare the lengths. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"1231\" > \"123\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Think of some examples yourself and try the greater than `>` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Less than:__ `<` same usage as above. \n",
    "\n",
    "Think of some examples yourself and try the less than `<` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Greater than or equal to:__ `>=`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2.0 >= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2.0 >= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2.0 >= 3.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "66 >= \"66\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"abc\" >= \"ab\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"abc\" >= \"abcf\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Think of some examples yourself and try the greater than or equal to `>=` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Less than or equal to:__ `<=`\n",
    "\n",
    "Think of some examples yourself and try the less than or equal to `<=` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Chain multiple comparisons together:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 < 2 < 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1.0 < 1.0 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"123\" < \"1234\" < \"12345\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Think of some examples yourself and try to chain multiple comparisons together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical Operations \n",
    "\n",
    "Logical operations are used to combine or modify boolean values. There are three primary logical operators `and`, `or`, and `not`. They are used to perform conjunction, disjunction, and negation operations, respectively.\n",
    "\n",
    "__`and` (conjunction):__ \n",
    "\n",
    "You have to satisfy both conditions to be True. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "True and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "False and False "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__`&` can represent `and` as well, please give it a try:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True & False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__`or` (disjunction):__\n",
    "\n",
    "You only need to meet one of the two conditions to be True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__`|` can represent `or`, please give it a try:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True | False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__`not` (negation):__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not False "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables \n",
    "\n",
    "In Python, variables are used to store values or references to objects, making it easier to use, manipulate, and reference data throughout your code. Variables can store data of various types, such as integers, floats, strings, lists, tuples, dictionaries, and more. \n",
    "\n",
    "To create a variable in Python, we use the assignment operator `=` to assign a value to a variable name. \n",
    "\n",
    "The variable name must follow the naming conventions:\n",
    "* It should start with a letter (a-z or A-Z) or an underscore (`_`).\n",
    "* No restriction on the length of the variable name.\n",
    "* It can consist of letters, digits, and underscores. \n",
    "* It cannot contain dashes or hyphens (`-`). \n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 90"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Jiajia\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting = \"Hello, world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "greeting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Using variables in expressions:__\n",
    "\n",
    "We can use variables in expressions and pass them as arguments to functions or methods. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "price = 26.99\n",
    "total_price = price * 1.1 # 10% GST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_price"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Reassigning a value:__\n",
    "\n",
    "We can also reassign a value to a variable name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 26\n",
    "age = \"27\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists \n",
    "\n",
    "In Python, a list is a mutable, ordered collection of items. Lists can contain items of different data types, including other lists. They are created using square brackets `[]` and items are separated by commas. \n",
    "\n",
    "__What does mutable mean?__\n",
    "\n",
    "Mutable means you can edit the list after you have created it. Immutable data type means you cannot edit it once it has been  created.\n",
    "\n",
    "__What does ordered collection of items mean?__\n",
    "\n",
    "An ordered collection of items refers to a data structure where the items are stored in a specific order or sequence. The order of the items is maintained, and each item has a unique index based on its position in the collection. For example, you can access a item by telling python it is the first/second/third in the list. We will cover how to access the items in a list later. \n",
    "\n",
    "__Create a list with integers:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Create a list with mixed data types:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixed_list = [1, \"Hi\", 99.99, True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixed_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Empty list:__\n",
    "\n",
    "You can also create a empty list and add the elements later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_list = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Append an item to the empty list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_list.append(\"apple\")\n",
    "empty_list.append(1)\n",
    "empty_list.append(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_list.remove(\"apple\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "A tuple is an immutable, ordered collection of items. Tuples can contain elements of different data types, including other tuples and lists. Tuples are similar to lists, but unlike lists, their elements cannot be changed once they are created. Tuples are created using parentheses `()` and items are separated by commas.\n",
    "\n",
    "__Create a tuple with integers:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = (1, 2, 3, 4, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Create a tuple with mixed data types:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixed_tuple = (1, \"Hello\", 2.33, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixed_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__You can also create an empty tuple:__\n",
    "\n",
    "But can you append data to it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_tuple = ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "empty_tuple.append(66)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like we mentioned before, tuples are immutable so we can't add elements to it once it has been created. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries \n",
    "\n",
    "A dictionary is a mutable, unordered collection of key-value pairs, where each key is unique. Dictionaries are created using curly brackets `{}` with key-value pairs separated by commas and a colon separates each key from its associated value. \n",
    "\n",
    "__Creating a dictionary:__\n",
    "\n",
    "You can create a dictionary in this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person = {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person = {\"name\": \"John\", \"age\": 30, \"age\": 44, \"city\": \"New York\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, the item before the colon is key, the item after the colon is value. name is the key and John is the value of the key. \n",
    "\n",
    "Or you can write a dictionary in this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "movie = {\n",
    "    \"name\": \"Inception\",\n",
    "    \"year\": 2010,\n",
    "    \"review\": 8.8\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "movie = {\n",
    "    \"name\": \"Inception\",\n",
    "    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'movie' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[12], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mmovie\u001b[49m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'movie' is not defined"
     ]
    }
   ],
   "source": [
    "movie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second way is preferred because when you have many key-value pairs, the second one can be easily read. \n",
    "\n",
    "__Creating a dictionary with mixed data types:__ \n",
    "\n",
    "* Both keys and values can contain different types of data. \n",
    "* Keys can contain strings, integers, floats, booleans, and tuples as data types. __However__, it is not recommended to use other data types of keys than strings. It can make your code harder to read and maintain. \n",
    "* Values have no restrictions on data types. \n",
    "\n",
    "Here is an example dictionary containing values of more complexed data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "company = {\n",
    "    'name': 'TechCorp',\n",
    "    'founded': 2005,\n",
    "    'employees': [\n",
    "        {'id': 1, 'name': 'John', 'position': 'CEO'},\n",
    "        {'id': 2, 'name': 'Jane', 'position': 'CTO'},\n",
    "        {'id': 3, 'name': 'Bob', 'position': 'Software Engineer'}\n",
    "    ],\n",
    "    'locations': [\n",
    "        {'city': 'New York', 'state': 'NY'},\n",
    "        {'city': 'San Francisco', 'state': 'CA'}\n",
    "    ],\n",
    "    'revenue': 25000000.0\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "company"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Creating an empty dictionary and add data later:__\n",
    "\n",
    "Dictionary is a mutable data type, so you can change and add data after it has been created. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_dict = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_dict[\"key1\"] = \"to_my_home\"\n",
    "empty_dict[\"key2\"] = \"to_the_office\"\n",
    "empty_dict[\"key3\"] = \"bike\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'key1': 'to_my_home', 'key2': 'to_the_office', 'key3': 'bike'}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Accessing values in the dictionary:__\n",
    "\n",
    "We can access values in a dictionary by using the keys associated with the vales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Inception'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie[\"name\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'TechCorp'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "company[\"name\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accessing the value of \"year\" in the dictionary movie:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2010"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie[\"year\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets \n",
    "\n",
    "In Python, a set is an unordered collection of unique items. Sets are mutable. \n",
    "\n",
    "Sets are particularly useful when you need to store or operate on a collection of distinct elements, such as performing set operations like union, intersection, and difference.\n",
    "\n",
    "To create a set, you can use curly braces {} with comma-separated values, or use the set() constructor with an iterable (e.g., list or tuple) as an argument.\n",
    "\n",
    "__Creating a set:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = {1, 2, 3, 4, 5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Creating a set with mixed values:__\n",
    "\n",
    "Sets can contain different data types, but the elements must be hashable (immutable) data types like strings, numbers (integers and floats), and tuples containing only hashable elements. Lists and dictionaries cannot be elements of a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixed_set = {42, 'hello', 3.14, ('a', 'b', 'c'), True}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('a', 'b', 'c'), 3.14, 42, True, 'hello'}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mixed_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set is a less used data type compares to other data types, so we will not cover too much in this class. \n",
    "\n",
    "### Indexing\n",
    "\n",
    "Indexing refers to access individual elements of a sequence data type (strings, lists, and tuples) based on their position. \n",
    "\n",
    "In Python, indexing is zero-based, meaning the first element has an index of 0, the second element has an index of 1, and so on. \n",
    "\n",
    "__Indexing with strings:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "gene = \"ATGCGTAAGCTTAGACCGATCATGCCGCTAGGCTACGAAGTCCATAG\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_base = gene[0]\n",
    "first_base"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'T'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second_base = gene[1]\n",
    "second_base"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise: to get the 10th base."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene[9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Negative indexing:__\n",
    "\n",
    "Negative indexing can be used to access elements from the end of the sequence. For example, an index of -1 refers to the last element, -2 refers to the second-to-last element, and so on. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'G'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "last_base = gene[-1]\n",
    "last_base"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second_to_last_base = gene[-2]\n",
    "second_to_last_base"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise: to get the 5th-to-last base."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene[-5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Indexing with lists:__\n",
    "\n",
    "Indexing with lists is similar with strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "amino_acids = ['Alanine', 'Arginine', 'Asparagine', 'Aspartic acid', 'Cysteine',\n",
    "               'Glutamine', 'Glutamic acid', 'Glycine', 'Histidine', 'Isoleucine',\n",
    "               'Leucine', 'Lysine', 'Methionine', 'Phenylalanine', 'Proline',\n",
    "               'Serine', 'Threonine', 'Tryptophan', 'Tyrosine', 'Valine']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the first amino acid in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the second amino acid in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the last amino acid in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the second to last amino acid in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Indexing with tuples:__\n",
    "\n",
    "Indexing with tuples is similar with strings and lists. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dna_bases = ('Adenine', 'Thymine', 'Cytosine', 'Guanine')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the first DNA base in the tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the second DNA base in the tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the last DNA base in the tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the second to last DNA base in the tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing \n",
    "\n",
    "Slicing is a technique in Python that allows you to extract a portion (a continuous subsequence) of a sequence data type like strings, list, and tuples. Slicing uses the colon `:` operator to indicate the start and end position of the slice. \n",
    "\n",
    "__The basic syntax for slicing is:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence[start:end]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Where `start` is the index of the first element you want to __include__ in your slice, and `end` is the first element you want to __exclude__ from the slice. \n",
    "\n",
    "The resulting slice will include elements from the `start` index (inclusive) to the `end` index (exclusive). \n",
    "\n",
    "__Slicing with strings:__\n",
    "\n",
    "Let's continue to use the string we created before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ATGCGTAAGCTTAGACCGATCATGCCGCTAGGCTACGAAGTCCATAG'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the first 5 bases from the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ATGCG'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the 5th to 13th bases from the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'GTAAGCTTA'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene[4:13]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also leave the start or end index blank, it will slice from the beginning to the end index or from the start index to the end.\n",
    "\n",
    "To get the slice from the beginning to the 11th base:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ATGCGTAAGCT'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene[:11]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the slice from the 18th base to the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'GATCATGCCGCTAGGCTACGAAGTCCATAG'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene[17:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Negative indexing:__\n",
    "\n",
    "We can also use negative indexing when slicing. Negative indexing allows you to reference elements from the end of the sequence. When using negative indexing in slices, -1 refers to the last elements, -2 refers to the second-to-last element, and so on. \n",
    "\n",
    "To get the slice from the last 6th element to the second-to-last element of the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'CCATA'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene[-6:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the last 5 elements of the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'CATAG'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene[-5:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the slice from the beginning to the 11th-to-last element of the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gene[:-10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Reverse a sequence:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'GATACCTGAAGCATCGGATCGCCGTACTAGCCAGATTCGAATGCGTA'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gene[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Slicing with lists:__\n",
    "\n",
    "Slicing lists is similar to how we slice strings. We will use the amino_acids list we created before for practising."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alanine',\n",
       " 'Arginine',\n",
       " 'Asparagine',\n",
       " 'Aspartic acid',\n",
       " 'Cysteine',\n",
       " 'Glutamine',\n",
       " 'Glutamic acid',\n",
       " 'Glycine',\n",
       " 'Histidine',\n",
       " 'Isoleucine',\n",
       " 'Leucine',\n",
       " 'Lysine',\n",
       " 'Methionine',\n",
       " 'Phenylalanine',\n",
       " 'Proline',\n",
       " 'Serine',\n",
       " 'Threonine',\n",
       " 'Tryptophan',\n",
       " 'Tyrosine',\n",
       " 'Valine']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "amino_acids"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing the first 3 amino acids from the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing the 13rd to 16th amino acids from the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing from the 8th-to-last element to the end of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse `amino_acids`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Slicing with tuples:__\n",
    "\n",
    "Slicing tuples is similar to how we slice strings and lists. We will practise on the dna_bases tuple we created before. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dna_bases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the first 2 elements of the tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the second and the third elements of the tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the last 3 elements of the tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse `dna_bases`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input and Output \n",
    "\n",
    "In Python, there are several ways to handle input and output of data. \n",
    "\n",
    "__`input()` function for input:__\n",
    "\n",
    "We can use the `input()` function to read input from the user through `stdin`. The `input()` function displays prompt message on the console and waits for the user to enter a value. The value entered by the user is returned as a string. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name?oooo\n"
     ]
    }
   ],
   "source": [
    "name = input(\"What is your name?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oooo'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Who is your supervisor?Benjamin\n"
     ]
    }
   ],
   "source": [
    "supervisor = input(\"Who is your supervisor?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benjamin'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "supervisor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your age?10\n"
     ]
    }
   ],
   "source": [
    "age = input(\"What is your age?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__`print()` function for output:__\n",
    "\n",
    "The `print()` function is used to output data to the console. For example, output the 2 values we have input used the input function on the screen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oooo\n",
      "Benjamin\n"
     ]
    }
   ],
   "source": [
    "print(name)\n",
    "print(supervisor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can pass one or more arguments to `print()` and separate them with commas, it will concatenate them into a string and display the result on the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is oooo and my supervisor is Benjamin .\n"
     ]
    }
   ],
   "source": [
    "print(\"My name is\", name, \"and my supervisor is\", supervisor, \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__The dot in the end is not in place, why is that?__\n",
    "\n",
    "By default, when print multiple objects using `print()`, the `print()` function will put a space between the objects. The variable `supervisor` and the dot are two separated objects so they have a space in between.\n",
    "\n",
    "How we can delete the additional space?\n",
    "\n",
    "__`print()` with option `sep=`:__\n",
    "\n",
    "The option `sep=` allows us to choose which delimiter to use rather than the default space character. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is!oooo!and my supervisor is!Benjamin!.\n"
     ]
    }
   ],
   "source": [
    "print(\"My name is\", name, \"and my supervisor is\", supervisor, \".\", sep=\"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise: use the `sep=` option to make the additional space disappear:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is oooo and my supervisor is Benjamin.\n"
     ]
    }
   ],
   "source": [
    "print(\"My name is \", name, \" and my supervisor is \", supervisor, \".\", sep=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Special Characters\n",
    "\n",
    "__Backslash `\\`:__\n",
    "\n",
    "In Python, a backslash is used as an escape character to represent certain special characters that have a specific meaning. When a backslash is followed by a character, it creates a special sequence that represents a character that cannot be typed directly in a string.\n",
    "\n",
    "The commonly used blackslash escape sequences are:\n",
    "* `\\n`: represents a new line character\n",
    "* `\\t`: represents a tab character \n",
    "* `\\\"`: represents a double quote character without the meaning of creating a string \n",
    "* `\\'`: represents a single quote character without the meaning of creating a string \n",
    "\n",
    "For example, use print function to create a table:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[58], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mprint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mTitle1\u001b[39;49m\u001b[38;5;130;43;01m\\t\u001b[39;49;00m\u001b[38;5;124;43mTitle2\u001b[39;49m\u001b[38;5;130;43;01m\\t\u001b[39;49;00m\u001b[38;5;124;43mTitle3\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[38;5;124;43md\u001b[39;49m\u001b[38;5;130;43;01m\\t\u001b[39;49;00m\u001b[38;5;124;43me\u001b[39;49m\u001b[38;5;130;43;01m\\t\u001b[39;49;00m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not callable"
     ]
    }
   ],
   "source": [
    "print(\"Title1\\tTitle2\\tTitle3\\nd\\te\\tf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "print = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise: create print a table like the image below__\n",
    "\n",
    "![table](./figures/table.png)\n",
    "\n",
    "Write your answer here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of escaping double quotes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "She said \"Hello\"\n"
     ]
    }
   ],
   "source": [
    "print(\"She said \\\"Hello\\\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Exercise: practise the escape of single quotes__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}