Lesson_1_Basics/Lesson_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/How-to-Learn-to-Code/python-class/blob/master/Lesson_1_Basics/Lesson_1.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning objectives\n",
    "\n",
    "Students will gain an introduction to programming in python, working in interactive notebooks, and learning how to leverage outside resources for coding help. Moreoever students will gain a basic understanding of variables, data types, and working with simple expressions for comparison and computation.\n",
    "\n",
    "* [Introduction to Programming](#program)\n",
    "* [Introduction to Jupyter and Google Colab](#jupyter)\n",
    "* [Basic math operators: +, -, *, /, **](#math)\n",
    "* [Use of the assignment operator (=)](#assign)\n",
    "* [Data types: integer, float, string, boolean](#data)\n",
    "* [Basic functions: print(), type(), int(), float(), str(), bool()](#function)\n",
    "* [Comparison operators: >, <, ==, >=, <=](#compare)\n",
    "* [In Class Exercises](#homework)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Basic Introduction to Programming in Python <a id='program'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a general purpose programming language that is widely used in scientific computing, image analysis, machine learning etc. It allows you to specify a set of instructions, written as a script or a program, to execute some task of interest. \n",
    "\n",
    "* Have any of you used a script before? What did you do to run it? What was the purpose of the script? Did it aid in reproducibility? Was it quicker to run or modify than calculating things individually by hand? \n",
    "\n",
    "The purpose of this series of python workshops is not to give you an extensive in depth overview of everything you can do in python. However, we do aim to give you all the skills and terminology necessary to **learn** how to learn to code in python. Google, [stack overflow](https://stackoverflow.com/), and [github issues](https://github.com/)) are invaluable tools you can use to your advantage for (1) gaining coding help and (2) learning how to write code from reading code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Introduction to Jupyter Notebooks and Google Colab <a id='jupyter'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"The Jupyter Notebook is an incredibly powerful tool for interactively developing and presenting data science projects. A notebook integrates code and its output into a single document that combines visualizations, narrative text, mathematical equations, and other rich media. The intuitive workflow promotes iterative and rapid development, making notebooks an increasingly popular choice at the heart of contemporary data science, analysis, and increasingly science at large. \" - [dataquest](https://www.dataquest.io/blog/jupyter-notebook-tutorial/)\n",
    "\n",
    "All of our lessons will be presented in Jupyter notebooks due to their interactive nature (.ipynb file extension). They consist of two main attributes, a `kernel` and `cells`. \n",
    "* A `kernel` interprets and executes the code. Here we are using the kernel for python; however, you can specify a kernel for another language like R. \n",
    "* A `cell` is a container for either text or code to be executed. \n",
    "\n",
    "To run the python code in a cell, you just hit shift + enter. Try it with the code below."
   ]
  },
  {
   "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": [
    "#### Basic math operators: +, -, *, /, ** <a id='math'></a>\n",
    "\n",
    "The simplest way we can use python is to use is as a calculator!  You can use python to do addition, subtraction, division, multiplication, and exponentiation. Let's walk through some simple math calculations. \n",
    "\n",
    "$$ 2 + 3 $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ \\frac{6}{2} * 20 - 100 $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-40.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(6/2) * 20 - 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ 2^{8} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "256"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Was the above result what you expected? If you used `^` then your result was 10; however, if you used `**` then your result was 256. This demonstrates why it's important to check the answers you get from your code to make sure the results seem reasonable. You might not always get an error when your code is incorrect :)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use of the assignment operator (=) <a id='assign'></a>\n",
    "\n",
    "What if you want to store some value (like the result of the above calculation) and use it for another task later? Here, you can assign it to a variable with the assignment operator `=`. \n",
    "\n",
    "For example, let's assign the value 22 to variable `x` as, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 22"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the code above did not return any result. That's because it is now stored in the variable called `x`!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try assigning the values 1, 2, and 3 to the variables `x`, `y`, and `z` respectively. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "z = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you'd like to see what the values of the variables were, you can use the `print()` function. Here, the input of the function (what goes inside the parantheses) is whatever you'd like to display to the terminal. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have variables assigned, you can use them to do basic operations. For example, try calculating the following. Be sure to use the assingment operator when necessary and print your results to check that they make sense. \n",
    "\n",
    "1. Assign the variable `a` as the result of $4 + 5*2$\n",
    "2. Compute $5 + a$\n",
    "3. Assign the variable b as the result of $\\frac{a}{2.5}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n",
      "19\n",
      "5.6\n"
     ]
    }
   ],
   "source": [
    "a = 4 + 5*2\n",
    "print(a)\n",
    "print(5 + a)\n",
    "b = a / 2.5\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Of note**, you can name a variable anything you'd like (although it's best to be descriptive for you and others who will end up reading your code). However, a variable name must start with a letter and *not* a number. For fun, try assigning the value 3 as the variable `1variable` and see what the result is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-10-2eacdbd5a895>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-10-2eacdbd5a895>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    1variable = 3\u001b[0m\n\u001b[1;37m     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "1variable = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data types: integer, float, string, boolean <a id='data'></a>\n",
    "\n",
    "Programming languages often include different data types that can be used for different tasks (e.g. arithmetic, comparison, debugging etc.). Here we'll discuss four of the most common types:\n",
    "1. *integer*: whole number\n",
    "2. *float*: decimal number\n",
    "3. *string*: text\n",
    "4. *boolean*: True or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Integers** <br>\n",
    "\n",
    "Integers are positive or negative whole numbers with no decimals. We've already been using them it today's lesson. For example, print the variables `x`, `y`, `z`, and `a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "print(y)\n",
    "print(z)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Floats** <br>\n",
    "\n",
    "Floats, short for floating point real values, are positive or negative numbers with decimals. As with integers, you can use them to do arithmetic or assign them to variables. Try defining and printing the following expressions.  \n",
    "\n",
    "* f1 assigned to value 4.5 \n",
    "* f2 assigned to value -3.0\n",
    "* f1 + f2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5\n"
     ]
    }
   ],
   "source": [
    "f1 = 4.5\n",
    "f2 = -3.0\n",
    "print(f1 + f2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Strings** <br>\n",
    "\n",
    "Strings refer to text (ie they're a series of characters) and can be (1) assigned to variables for data manipulation or (2) can be used in print statements for debugging or monitoring tasks. You define them by placing the text within single or double quotation marks as, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GCGCTCAAT TACTAGGCA\n",
      "string variable 1 is GCGCTCAAT\n"
     ]
    }
   ],
   "source": [
    "oligo1 = 'GCGCTCAAT'\n",
    "oligo2 = 'TACTAGGCA'\n",
    "print(oligo1, oligo2)\n",
    "print('string variable 1 is', oligo1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Booleans** <br>\n",
    "\n",
    "Booleans are either `True` or `False`. Note the capitilization of the first letter. They are often used for comparisons (e.g. the output of $1 > 2$ would result in `False`). Additionally, it's important to note that True behaves as 1 and False behaves as 0 in arithmetic operations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "t = True\n",
    "f = False\n",
    "\n",
    "print(2*t)\n",
    "print(2*f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comparison operators: >, <, ==, >=, <= <a id='compare'></a>\n",
    "\n",
    "Comparison operators (>, <, ==, >=, <=) can be used to compare two or more variables. The output of the comparison is a Boolean (ie `True` or `False`). Therefore, we often use comparison operators to set up condition statements (e.g. if this comparison statement is True, then do this task. If it is False, then do something else). You'll learn more about condition statements and control in Lesson 2. \n",
    "\n",
    "Let's set up a few comparisons and use print statements to see the results. \n",
    "\n",
    "$$ 2 > 1.5 $$\n",
    "$$ 4 <= 2 $$\n",
    "$$ 5 == 5.0 $$\n",
    "$$ 6 >= 6 $$\n",
    "$$ 7.4 < 3 $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(2 > 1.5)\n",
    "print(4 <= 2)\n",
    "print(5 == 5.0)\n",
    "print(6 >= 6)\n",
    "print(7.4 < 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Basic functions: type(), int(), float(), str(), bool()  <a id='function'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've already started using one basic function, `print()`. Each function has a goal and does a task. How it works is it takes whatever is specified within the parantheses (the arguments), performs the task, and then outputs the results. Functions are extraordinarily useful for reproducible code and you'll learn more about them in Lesson 3. \n",
    "\n",
    "For now, let's explore some other basic functions. The function `type()` returns the data type of the argument you give it. See the example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('hello world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are other useful functions that let you specify the data type or coerce the data type into another. `int()`, `float()`, `bool()`, and `str()` let you specify data as an integer, float, boolean, or string. Let's take a look at how this works for the `int()` and `str()` functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(2.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'20'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### In Class Exercises <a id='homework'></a>\n",
    "\n",
    "The following exercises will help you understand the concepts taught in this lesson better.\n",
    "\n",
    "1. Like in algebra, parentheses can be used to specify the order of operations. What would you expect to be the result of the following expressions? (Try to predict the answer before checking your answers in python.)\n",
    "$$1 + 3*3$$\n",
    "$$(1 + 3)*3$$\n",
    "$$(4*4) + 5$$\n",
    "$$1 > 3$$\n",
    "$$\"1\" > \"3\"$$\n",
    "$$14 >= 2*7$$\n",
    "$$0 == \\mathrm{False}$$\n",
    "$$\\mathrm{True} == 1^{0}$$\n",
    "$$\\mathrm{int}(\\mathrm{True}) == \\mathrm{str}(1^{0})$$\n",
    "$$\\mathrm{float(\"one\")}$$\n",
    "\n",
    "2. Create two new variables, comp_oligo1 and comp_oligo2, that are the complementary DNA sequences of oligo1 and oligo2 (hint: A <-> T and G <-> C)\n",
    "\n",
    "3. Compute the melting temperature of oligo1 and oligo2 using the following equation: $$\\mathrm{T_{m}} = 2(\\mathrm{A} + \\mathrm{T}) + 4(\\mathrm{G} + \\mathrm{C})$$ where A, T, G, and C refer to the number of A, T, G, C nucleotides in the primer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "12\n",
      "21\n",
      "False\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: 'one'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-d1b400deffed>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mTrue\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'one'\u001b[0m\u001b[1;33m)\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: could not convert string to float: 'one'"
     ]
    }
   ],
   "source": [
    "#question 1\n",
    "\n",
    "print(1+3*3)\n",
    "print((1+3)*3)\n",
    "print((4*4)+5)\n",
    "print(1>3)\n",
    "print('1' > '3')\n",
    "print(14 >= 3*7)\n",
    "print(0 == False)\n",
    "print(True == 1**0)\n",
    "print(int(True) == str(1**0))\n",
    "print(float('one'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#question 2\n",
    "\n",
    "comp_oligo1 = 'CGCGAGTTA'\n",
    "comp_oligo2 = 'ATGATCCGT'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28 26\n"
     ]
    }
   ],
   "source": [
    "#question 3\n",
    "\n",
    "temp_oligo1 = 2*(2 + 2) + 4*(3 + 2)\n",
    "temp_oligo2 = 2*(2 + 3) + 4*(2 + 2)\n",
    "\n",
    "print(temp_oligo1, temp_oligo2)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "c4d4cf0f866ef5d608adbb3b8114bb30b4107b67947e423d500be3fa738ca8f5"
  },
  "kernelspec": {
   "display_name": "Python 3.8.5 ('base')",
   "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"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}