python_basic_1_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# An introduction to solving biological problems with Python\n",
    "\n",
    "## Day 1 - Session 2: Simple data types\n",
    "\n",
    "- [Simple data types](#Simple-data-types): [Integers](#Integers), [Floats](#Floats), [Strings](#Strings) and [Booleans](#Booleans)\n",
    "- [Comments](#Comments)\n",
    "- [Arithmetic](#Arithmetic)\n",
    "- [Exercises 1.2.1](#Exercises-1.2.1)\n",
    "- [Saving code in files](#Saving-code-in-files)\n",
    "- [Exercises 1.2.2](#Exercises-1.2.2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple data types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python (and computers in general) treats different types of data differently. Python has 4 main basic data types. Types are useful to constrain some operations to a certain category of variables. For example it doesn't really make sense to try to divide a string.\n",
    "\n",
    "We will see some examples of these in use shortly, but for now let's see all of the basic types available in python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integers\n",
    "\n",
    "Integers represent whole numbers, as you would use when counting items, and can be positive or negative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "i = -7\n",
    "j = 123\n",
    "print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Floats\n",
    "\n",
    "Floating point numbers, often simply referred to as <tt>float</tt>s, are numbers expressed in the decimal system, i.e. 2.1, 999.998, -0.000004 etc. The value 2.0 would also be interpreted as a floating point number, but the value 2, without the decimal point will not; it will be interpreted as an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 3.14159\n",
    "y = -42.3\n",
    "print(x * y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Floating point numbers can also carry an <tt>e</tt> suffix that states which power of ten they operate at."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "k = 1.5e3\n",
    "l = 3e-2\n",
    "print(k)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings\n",
    "\n",
    "Strings represent text, i.e. \"strings\" of characters. They can be delimited by single quotes <tt>‘</tt> or double quotes <tt>“</tt>, but you have to use the same delimiter at both ends. Unlike some programming languages, such as Perl, there is no difference between the two types of quote, although using one type does allow the other type to appear inside the string as a regular character.\n",
    "\n",
    "Normally a python statement ends at the end of the line, but if you want to type a string over several lines you can enclose it in triple quotation marks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = \"ATGTCGTCTACAACACT\"\n",
    "t = 'Serine'\n",
    "u = \"It's a string with apostrophes\"\n",
    "v = \"\"\"A string that extends\n",
    "over multiple lines\"\"\"\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Booleans\n",
    "\n",
    "Boolean values represent truth or falsehood, as used in logical operations, for example. Not surprisingly, there are only two values, and in Python they are called <tt>True</tt> and <tt>False</tt>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = True\n",
    "b = False\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The <tt>None</tt> object\n",
    "\n",
    "The None object is special built-in value which can be thought of as **representing nothingness or that something is undefined**. For example, it can be used to indicate that a variable exists, but has not yet been set to anything specific."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "z = None\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Object type\n",
    "\n",
    "You can check what type python thinks an expression is with the <tt>type</tt> function, which you can call with the name <tt>type</tt> immediately followed by parentheses enclosing the expression you want to check (either a variable or a value), e.g. <tt>type(3)</tt>. (This is the general form for calling functions, we'll see lots more examples of functions later...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = True\n",
    "print(a, \"is of\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "i = -7\n",
    "print(i, \"is of\", type(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 12.7893\n",
    "print(x, \"is of\", type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = \"ATGTCGTCTACAACACT\"\n",
    "print(s, \"is of\", type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "z = None\n",
    "print(z, \"is of\", type(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comments\n",
    "\n",
    "When you are writing a program it is often convenient to annotate your code to remind you what you were (intending) it to do. In programming these annotations are known as _comments_. You can include a comment in python by prefixing some text with a <tt>#</tt> character. All text following the <tt>#</tt> will then be ignored by the interpreter. You can start a comment on its own line, or you can include it at the end of a line of code.\n",
    "\n",
    "It is also often useful to temporarily remove some code from a script without deleting it. This is known as _commenting out_ some code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"Hi\") # this will be ignored\n",
    "# as will this\n",
    "print(\"Bye\")\n",
    "# print \"Never seen\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports all the standard arithmetical operations on numerical types, and mostly uses a similar syntax to several other computer languages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 4.5\n",
    "y = 2\n",
    "\n",
    "print('x', x, 'y', y)\n",
    "print('addition x + y =', x + y) \n",
    "print('subtraction x - y =', x - y) \n",
    "print('multiplication x * y =', x * y) \n",
    "print('division x / y =', x / y) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 4.5\n",
    "y = 2\n",
    "\n",
    "print('x', x, 'y', y)\n",
    "print('division x / y =', x / y)\n",
    "print('floored division x // y =', x // y) \n",
    "print('modulus (remainder of x/y) x % y =', x % y) \n",
    "print('exponentiation x ** y =', x ** y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual in maths, division and multiplication have higher precedence than addition and subtraction, but arithmetic expressions can be grouped using parentheses to override the default precedence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 13\n",
    "y = 5\n",
    "\n",
    "print('x * (2 + y) =', x * (2 + y))\n",
    "print('(x * 2) + y =', (x * 2) + y)\n",
    "print('x * 2 + y =', x * 2 + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can mix (some) types in arithmetic expressions and python will apply rules as to the type of the result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "13 + 5.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can force python to use a particular type by converting an expression explicitly, using helpful named functions: <tt>float</tt>, <tt>int</tt>, <tt>str</tt> etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "float(3) + float(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "int(3.14159) + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The addition operator `+` allows you also to concatenate strings together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print('number' + str(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Division in Python 2 sometimes trips up new (and experienced!) programmers. If you divide 2 integers you will only get an integer result. If you want a floating point result you should explicitly cast at least one of the arguments to a <tt>float</tt>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"3/4 =\", 3/4) # in Python 2, you would get 0\n",
    "print(\"3.0/4 =\", 3.0/4)\n",
    "print(\"float(3)/4 =\", float(3)/4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few shortcut assignment statements to make modifying variables directly faster to type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 3\n",
    "x += 1 # equivalent to x = x + 1\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 2\n",
    "y = 10\n",
    "y *= x\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These shortcut operators are available for all arithmetic and logical operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises 1.2.1\n",
    "\n",
    "In the interpreter:\n",
    "\n",
    "Assign numerical values to 2 variables, calculate the mean of these two variables and store the result in another variable. Print out the result to the screen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving code in files\n",
    "\n",
    "### Excecute code in files\n",
    "\n",
    "As we mentioned earlier, you can also save python code in a file and then execute it later. We typically save python code in a file ending with the extension <tt>.py</tt>. The file, or _script_, can then be executed simply by supplying the name of the file as an argument to the <tt>python</tt> command in the terminal.\n",
    "\n",
    "The first thing you may want to do, before going any further, is to verify the version of python you are running. To do so, open a terminal window and execute this command:\n",
    "\n",
    "```bash\n",
    "python --version\n",
    "```\n",
    "\n",
    "You should be running Python 3.5.x.\n",
    "\n",
    "The first file we will be looking at is located in the `scripts` directory and it is called `hello.py`. To execute the script, open a terminal window, navigate to the `scripts` directory and execute the code in the script `hello.py` by running `python hello.py` in your terminal:\n",
    "\n",
    "```bash\n",
    "ls\n",
    "cd scripts\n",
    "python hello.py\n",
    "```\n",
    "\n",
    "Shell commands:\n",
    "- `ls`: to list directory contents\n",
    "- `pwd`: to return working directory name\n",
    "- `cd to/this/directory/`: to change directory\n",
    "\n",
    "### Edit code in files\n",
    "\n",
    "You can use any text editor you know to edit your file, but the file should be saved as plain text, so programs like Microsoft Word aren't the best choice. Many text editors will highlight python syntax for you which can help avoid syntax errors.\n",
    "\n",
    "To open any Python scripts in a text editor, open [Gedit](https://wiki.gnome.org/Apps/Gedit) or [Atom](https://atom.io/) and use the File menu, navigate to the `scripts` directory and open `hello.py`. \n",
    "\n",
    "You can now modify the `print` statement, save the file and go back to the terminal window you've just opened to run the code again by using the command `python hello.py`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises 1.2.2\n",
    "\n",
    "Create a new Python file to solve these exercises. It is good practice to create a new file each time you solve a new problem.\n",
    "\n",
    "1. Look up the <a href=\"http://en.wikipedia.org/wiki/DNA_codon_table\">genetic code</a>. Create four string variables that store possible DNA encodings of serine (S), leucine (L), tyrosine (Y) and cysteine (C). Where multiple codings are available, just pick one for now.\n",
    "2. Create a variable containing a possible DNA sequence for the protein sequence SYLYC. (Note that the addition operator <tt>+</tt> allows you to concatenate strings together.) Print the DNA sequence.\n",
    "3. Include a comment in your file to remind you the purpose of the script."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next session\n",
    "\n",
    "Go to our next notebook: [python_basic_1_3](python_basic_1_3.ipynb)"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}