python_fm_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# Working with Python: functions and modules\n",
    "\n",
    "- Our course webpage: http://pycam.github.io\n",
    "- Python website: https://www.python.org/ \n",
    "\n",
    "## Session 1: Introduction to Python\n",
    "- [Printing](#Printing)\n",
    "- [Variables](#Variables)\n",
    "- [Simple data types](#Simple-data-types)\n",
    "- [Arithmetic operations](#Arithmetic-operations)\n",
    "- Collections: [Lists](#Lists) | [Dictionnaries](#Dictionnaries) | [Sets](#Sets) | [Tuples](#Tuples) | [Strings](#Strings)\n",
    "- [Conditional execution](#Conditional-execution) \n",
    "- [Comparison operations](#Comparison-operations)\n",
    "- [Loops](#Loops)\n",
    "- [Files](#Files)\n",
    "- [Getting help](#Getting-help)\n",
    "- [Exercise 1.1](#Exercise-1.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing\n",
    "\n",
    "You can include a ***comment*** in python by prefixing some text with a **`#` character**. All text following the `#` will then be ignored by the interpreter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello from python!') # to print some text, enclose it between quotation marks - single\n",
    "print(\"I'm here today!\")    # or double\n",
    "print(34)                   # print an integer\n",
    "print(2 + 4)                # print the result of an arithmetic operation\n",
    "print(\"The answer is\", 42)  # print multiple expressions, separated by comma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "A variable can be assigned to a simple value or the outcome of a more complex expression.\n",
    "The **`=` operator** is used to assign a value to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3     # assignment of a simple value\n",
    "print(x)\n",
    "y = x + 5 # assignment of a more complex expression\n",
    "print(y)\n",
    "i = 12\n",
    "print(i)\n",
    "i = i + 1 # assigment of the current value of a variable incremented by 1 to itself\n",
    "print(i)\n",
    "i += 1    # shorter version with the special += operator\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Simple data types\n",
    "\n",
    "Python has 4 main basic data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = 2           # integer\n",
    "b = 5.0         # float\n",
    "c = 'word'      # string\n",
    "d = 4 > 5       # boolean True or False\n",
    "e = None        # special built-in value to create a variable that has not been set to anything specific\n",
    "print(a, b, c, d, e)\n",
    "print(a, 'is of type', type(a)) # to check the type of a variable "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2             # assignment\n",
    "a += 1            # change and assign (*=, /=)\n",
    "3 + 2             # addition\n",
    "3 - 2             # subtraction\n",
    "3 * 2             # multiplication\n",
    "3 / 2             # integer (python2) or float (python3) division\n",
    "\n",
    "3 // 2            # integer division\n",
    "3 % 2             # remainder\n",
    "3 ** 2            # exponent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Lists\n",
    "\n",
    "A list is an ordered collection of mutable elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = ['red', 'blue', 'green']       # manual initialisation\n",
    "copy_of_a = a[:]                   # copy of a \n",
    "another_a = a                      # same as a\n",
    "b = list(range(5))                 # initialise from iteratable\n",
    "c = [1, 2, 3, 4, 5, 6]             # manual initialisation\n",
    "len(c)                             # length of the list\n",
    "d = c[0]                           # access first element at index 0\n",
    "e = c[1:3]                         # access a slice of the list, \n",
    "                                   # including element at index 1 up to but not including element at index 3\n",
    "f = c[-1]                          # access last element\n",
    "c[1] = 8                           # assign new value at index position 1\n",
    "g = ['re', 'bl'] + ['gr']          # list concatenation\n",
    "['re', 'bl'].index('re')           # returns index of 're'\n",
    "a.append('yellow')                 # add new element to end of list\n",
    "a.extend(b)                        # add elements from list `b` to end of list `a`\n",
    "a.insert(1, 'yellow')              # insert element in specified position\n",
    "'re' in ['re', 'bl']               # true if 're' in list\n",
    "'fi' not in ['re', 'bl']           # true if 'fi' not in list\n",
    "c.sort()                           # sort list in place\n",
    "h = sorted([3, 2, 1])              # returns sorted list\n",
    "i = a.pop(2)                       # remove and return item at index (default last)\n",
    "print(a, b, c, d, e, f, g, h, i)\n",
    "print(a, copy_of_a, another_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionnaries\n",
    "\n",
    "A dictionnary is an unordered collection of key-value pairs where keys must be unique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = {'A': 'Adenine', 'C': 'Cytosine'}        # dictionary\n",
    "b = a['A']                                   # translate item\n",
    "c = a.get('N', 'no value found')             # return default value\n",
    "'A' in a                                     # true if dictionary a contains key 'A'\n",
    "a['G'] = 'Guanine'                           # assign new key, value pair to dictonary a\n",
    "a['T'] = 'Thymine'                           # assign new key, value pair to dictonary a\n",
    "print(a)\n",
    "d = a.keys()                                 # get list of keys\n",
    "e = a.values()                               # get list of values\n",
    "f = a.items()                                # get list of key-value pairs\n",
    "print(b, c, d, e, f)\n",
    "del a['A']                                   # delete key and associated value\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "A set is an unordered collection of unique elements. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = {1, 2, 3}                                # initialise manually\n",
    "b = set(range(5))                            # initialise from iteratable\n",
    "c = set([1,2,2,2,2,4,5,6,6,6])               # initialise from list\n",
    "a.add(13)                                    # add new element to set\n",
    "a.remove(13)                                 # remove element from set\n",
    "2 in {1, 2, 3}                               # true if 2 in set\n",
    "5 not in {1, 2, 3}                           # true if 5 not in set\n",
    "d = a.union(b)                               # return the union of sets as a new set\n",
    "e = a.intersection(b)                        # return the intersection of sets as a new set\n",
    "print(a, b, c, d, e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "Tuple is an ordered collection of immutable elements. Tuples are similar to lists, but the elements un a tuple cannot be modified. Most of list operations seen above can be used on tuples except the assignment of new value at a certain index position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = (123, 54, 92)              # initialise manually\n",
    "b = ()                         # empty tuple\n",
    "c = (\"Ala\",)                   # tuple of a single string (note the trailing \",\")\n",
    "d = (2, 3, False, \"Arg\", None) # a tuple of mixed types\n",
    "print(a, b, c, d)\n",
    "t = a, c, d                    # tuple packing\n",
    "x, y, z = t                    # tuple unpacking\n",
    "print(t, x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "String is an ordered collection of immutable characters or tuple of characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "a = 'red'                          # assignment\n",
    "char = a[2]                        # access individual characters\n",
    "b = 'red' + 'blue'                 # string concatenation\n",
    "c = '1, 2, three'.split(',')       # split string into list\n",
    "d = '.'.join(['1', '2', 'three'])  # concatenate list into string\n",
    "print(a, char, b, c, d)            \n",
    "dna = 'ATGTCACCGTTT'               # assignment\n",
    "seq = list(dna)                    # convert string into list of character\n",
    "e = len(dna)                       # return string length\n",
    "f = dna[2:5]                       # slice string\n",
    "g = dna.find('TGA')                # substring location, return -1 when not found\n",
    "print(dna, seq, e, f, g)\n",
    "text = '   chrom start end    '    # assignment\n",
    "print('>', text, '<')\n",
    "print('>', text.strip(), '<')      # remove unwanted whitespace at both end of the string\n",
    "print('{:.2f}'.format(0.4567))     # formating string\n",
    "print('{gene:s}\\t{exp:+.2f}'.format(gene='Beta-Actin', exp=1.7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional execution\n",
    "\n",
    "A conditional **`if/elif`** statement is used to specify that some block of code should only be executed if a conditional expression evaluates to `True`, there can be a final **`else`** statement to do something if all of the conditions are `False`.\n",
    "Python uses **indentation** to show which statements are in a block of code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 1, 2           # assign different values to a and b\n",
    "if a + b == 3:\n",
    "    print('True')\n",
    "elif a + b == 1:\n",
    "    print('False')\n",
    "else:\n",
    "    print('?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 1            # equal value\n",
    "1 != 2            # not equal\n",
    "2 > 1             # larger\n",
    "2 < 1             # smaller\n",
    "\n",
    "1 != 2 and 2 < 3  # logical AND\n",
    "1 != 2 or 2 < 3   # logical OR\n",
    "not 1 == 2        # logical NOT\n",
    "\n",
    "a = list('ATGTCACCGTTT')\n",
    "b = a             # same as a\n",
    "c = a[:]          # copy of a\n",
    "'N' in a          # test if character 'N' is in a\n",
    "\n",
    "print('a', a)      # print a\n",
    "print('b', b)      # print b\n",
    "print('c', c)      # print c\n",
    "print('Is N in a?', 'N' in a)\n",
    "print('Are objects b and a point to the same memory address?', b is a)\n",
    "print('Are objects c and a point to the same memory address?', c is a)\n",
    "print('Are values of b and a identical?', b == a)\n",
    "print('Are values of c and a identical?', c == a)\n",
    "a[0] = 'N'         # modify a  \n",
    "print('a', a)      # print a\n",
    "print('b', b)      # print b\n",
    "print('c', c)      # print c\n",
    "print('Is N in a?', 'N' in a)\n",
    "print('Are objects b and a point to the same memory address?', b is a)\n",
    "print('Are objects c and a point to the same memory address?', c is a)\n",
    "print('Are values of b and a identical?', b == a)\n",
    "print('Are values of c and a identical?', c == a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "\n",
    "There are two ways of creating loops in Python, the **`for` loop** and the **`while` loop**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['red', 'blue', 'green']\n",
    "for color in a:\n",
    "    print(color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 1\n",
    "while number < 10:\n",
    "    print(number)\n",
    "    number += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has two ways of affecting the flow of the `for` or `while` loop inside the block. The **`break`** statement immediately causes all looping to finish, and execution is resumed at the next statement after the loop. The **`continue`** statement means that the rest of the code in the block is skipped for this particular item in the collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# break\n",
    "sequence = ['CAG','TAC','CAA','TAG','TAC','CAG','CAA']\n",
    "for codon in sequence:\n",
    "    if codon == 'TAG':\n",
    "        break            # Quit looping at this point\n",
    "    else:\n",
    "        print(codon)\n",
    "\n",
    "# continue\n",
    "values = [10, -5, 3, -1, 7]\n",
    "total = 0\n",
    "for v in values:\n",
    "    if v < 0:\n",
    "        continue         # Skip this iteration   \n",
    "    total += v\n",
    "print(values, 'sum:', sum(values), 'total:', total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Files\n",
    "\n",
    "To read from a file, your program needs to open the file and then read the contents of the file. You can read the entire contents of the file at once, or read the file line by line. The **`with`** statement makes sure the file is closed properly when the program has finished accessing the file.\n",
    "\n",
    "\n",
    "Passing the `'w'` argument to `open()` tells Python you want to write to the file. Be careful; this will erase the contents of the file if it already exists. Passing the `'a'` argument tells Python you want to append to the end of an existing file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reading from file\n",
    "with open(\"data/genes.txt\") as f:\n",
    "    for line in f:\n",
    "        print(line.strip())\n",
    "\n",
    "# writing to a file\n",
    "with open('programming.txt', 'w') as f:\n",
    "    f.write(\"I love programming in Python!\\n\")\n",
    "    f.write(\"I love making scripts.\\n\")\n",
    "    \n",
    "# appending to a file \n",
    "with open('programming.txt', 'a') as f:\n",
    "    f.write(\"I love working with data.\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting help\n",
    "\n",
    "[The Python 3 Standard Library](https://docs.python.org/3/library/index.html) is the reference documentation of all libraries included in Python as well as built-in functions and data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(len)          # help on built-in function\n",
    "help(list.extend)  # help on list function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# help within jupyter\n",
    "len?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1.1\n",
    "\n",
    "We are going to look at a [Gapminder](https://www.gapminder.org/) dataset, made famous by Hans Rosling from the Ted presentation [‘The best stats you’ve ever seen’](http://www.ted.com/talks/hans_rosling_shows_the_best_stats_you_ve_ever_seen).\n",
    "\n",
    "- Read the dataset from the file `data/gapminder.txt` \n",
    "- Find what are the oldest and youngest years in the dataset programatically \n",
    "- Calculate average life expectancy as well as global population increase between these two years\n",
    "- Find which country has the lowest life expectancy in 2002"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Next session\n",
    "\n",
    "Go to our next notebook: [python_functions_and_modules_2](python_fm_2.ipynb)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}