notebooks/week0_lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 0 - Basic Python concepts and functions\n",
    "\n",
    "### Aims\n",
    "\n",
    "- To recapitulate Python's basic functionality (syntax, data types, structures, conditioning and I/O)\n",
    "- To learn and/or practice writing functions in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Python\n",
    "\n",
    "### Printing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello from python!') # to print some text, enclose it between single quotation marks\n",
    "print(\"I'm here today!\")    # or double quotation marks\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": [
    "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": "markdown",
   "metadata": {},
   "source": [
    "### Variables\n",
    "\n",
    "A variable can be assigned to a simple value or the outcome of a more complex expression. 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": {},
   "source": [
    "### Simple data types\n",
    "\n",
    "Python has four main data types: integer, float, string and boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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\n",
    "\n",
    "Using Python as a calculator to do simple mathematical operations in integer and float numbers"
   ]
  },
  {
   "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": {},
   "source": [
    "### Data structures\n",
    "\n",
    "There are also different types of data structures in Python to store the main basic data types shown above:\n",
    "\n",
    "- Lists\n",
    "- Sets\n",
    "- Tuples\n",
    "- Dictionaries\n",
    "\n",
    "##### Lists\n",
    "\n",
    "A list is an ordered collection of mutable elements e.g. the elements inside a list can be modified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['red', 'blue', 'green', \"yellow\"]       # 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)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "print(e)\n",
    "print(f)\n",
    "print(g)\n",
    "print(h)\n",
    "print(i)\n",
    "print(\"------------\")\n",
    "print(a)\n",
    "print(copy_of_a)\n",
    "print(another_a)\n",
    "a[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Sets\n",
    "\n",
    "A set is an unordered collection of unique elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Tuples\n",
    "\n",
    "A tuple is an ordered collection of immutable elements e.g. tuples are similar to lists, but the elements inside a tuple cannot be modified. Most of the list operations shown above can be used on tuples as well, with the exception of 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)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "t = a, c, d                    # tuple packing\n",
    "x, y, z = t                    # tuple unpacking\n",
    "print(t)\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dictionaries\n",
    "\n",
    "A dictionary is an unordered collection of key-value pairs where keys must be unique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {'A': 'Adenine', 'C': 'Cytosine'}        # dictionary\n",
    "b = a['A']                                   # translate item\n",
    "c = a.get('A', 'no value found')             # return default value\n",
    "print('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",
    "print(b)\n",
    "print(c)\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(d)\n",
    "print(e)\n",
    "print(f)\n",
    "del a['A']                                   # delete key and associated value\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with strings\n",
    "\n",
    "A string is an ordered collection of immutable characters or tuple of characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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)\n",
    "print(char)\n",
    "print(b)\n",
    "print(c)\n",
    "print(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('TCA')                # substring location, return -1 when not found\n",
    "print(dna)\n",
    "print(seq)\n",
    "print(e)\n",
    "print(f)\n",
    "print(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": [
    "### Conditions\n",
    "\n",
    "A conditional `if` or `elif` statement is used to specify that some block of code should only be executed if a conditional expression is **True**. Often the final `else` statement works when all the conditions before are **False**. \n",
    "\n",
    "Python uses indentation to represent which statements are inside a block of code e.g. the line after the `if` statement is indented (tab)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 1, 0           # assign different values to a and b, and execute the cell to test\n",
    "if a + b == 3:\n",
    "    print('Three')\n",
    "elif a + b == 1:\n",
    "    print('One')\n",
    "else:\n",
    "    print('?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparisons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 1            # equal\n",
    "1 != 2            # not equal\n",
    "2 > 1             # greater than\n",
    "2 < 1             # smaller than\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 using `for` or `while`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['red', 'blue', 'green']\n",
    "for color in a:\n",
    "    print(color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### while"
   ]
  },
  {
   "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 a `for` or `while` loop:\n",
    "\n",
    "- The `break` statement immediately causes all looping to finish, and execution is resumed at the next statement after the loop. \n",
    "- 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 the looping at this point (the TAG stop codon)\n",
    "    else:\n",
    "        print(codon)\n",
    "\n",
    "        \n",
    "# continue\n",
    "values = [10, -5, 3, -1, 7]\n",
    "total = 0\n",
    "for v in values:\n",
    "    if v < 0:\n",
    "        continue # Don't quit the loop but skip the iterations where the integer is negative   \n",
    "    total += v\n",
    "\n",
    "print(values, 'sum:', sum(values), 'total:', total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading and writing 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",
    "We will use one of the files containing clinical and genomic data from anonymized patients published as part of the METABRIC consortium, a large-scale collaborative study of breast cancer worldwide (PMID: 22522925). The data file `metabric_clinical_and_expression_data.csv` is available in the `data` folder in: https://github.com/AstraZeneca/data-science-python-course"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reading from file\n",
    "with open(\"../data/metabric_clinical_and_expression_data.csv\") as f:\n",
    "    for line in f:\n",
    "        print(line.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Passing the `w` argument in `open()` tells Python that you want to create and write to a new file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# writing to a file\n",
    "with open('../data/programming.txt', 'w') as f:\n",
    "    f.write(\"I love programming in Python!\\n\")\n",
    "    f.write(\"I love making scripts.\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Keep in mind** this will erase the contents of the file if it already exists. \n",
    "\n",
    "Passing the `a` argument instead tells Python you want to append to the end of an existing file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# appending to a file \n",
    "with open('../data/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 [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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(list.extend)  # help on list function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For help within the Jupyter Notebook, try the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "### Overview\n",
    "\n",
    "A function is basically a block of code that only runs when it is called. Functions are a general programming tool, and can be found in many programming languages. All functions operate in three steps:\n",
    "\n",
    "1. Call: the function is called with some inputs\n",
    "2. Compute: based on the inputs, the function does something\n",
    "3. Return: the function outputs the result of the computation\n",
    "\n",
    "Python has many functions pre-loaded, for example the print function. In this example, the function is **called** with some text as the input, the **computation** is doing something to the text (keeping it the same), and the **return** is the printing of text to screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"I just called the print function\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As well as the input, some functions also have additional options which change how the function works. These additional options are called **arguments**. For example, the print function has a *sep* argument which allows the user to specify which character to use as the text separator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"By\", \"default\", \"text\", \"is\", \"separated\", \"by\", \"spaces\")\n",
    "print(\"We\", \"can\", \"choose\", \"to\", \"separate\", \"by\", \"dashes\", sep=\"$\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some useful functions in Python are:\n",
    "- type() : returns the variable type for an object\n",
    "- len() : returns the length of a list or tuple\n",
    "- abs() : returns the absolute values of a numeric variable\n",
    "- sorted() : returns a sorted copy of a list or tuple\n",
    "- map() : applies a function to every element of a list or tuple, and returns a corresponding list of the returns of the function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining your own function\n",
    "\n",
    "#### Why?\n",
    "\n",
    "Functions allow you to wrap up a chunk of code and execute it repeatedly without having to type the same code each time. This has four main advantages:\n",
    "\n",
    "1. Accuracy: by typing the code once, you only have one chance to make a mistake or typo (and if you discover a mistake, you only have to correct it once!)\n",
    "\n",
    "2. Flexibility: you can change or expand the behaviour of a function by making a change in the function code, and this change will apply across your script\n",
    "\n",
    "3. Readability: if someone reads your code, they only have to read the function code to understand how it works, instead of reading chunks of repeated code\n",
    "\n",
    "4. Portability: you can easily copy a function from one script and paste it in another script, instead of having to extract general-purpose lines of code that are embedded in a script written for a specific purpose\n",
    "\n",
    "#### How?\n",
    "\n",
    "To declare a new function, the **def** statement is used to name the function, specify its inputs, add the computation steps, and specify its output. This results in a **function definition**, and the function can then be called later in the script. All function definitions must have three elements:\n",
    "\n",
    "1. Name: you can call your function anything, but usually verbs are better than nouns (e.g. echo_text rather than text_echoer). Python will not check whether a function already exists with the name that you choose, so **do not use the same name as an existing function** e.g. print()\n",
    "\n",
    "2. Input: almost all functions take at least one input, either data to perform computaton on, or an option to change how the computation proceeds. You don't have to specify an input, but you **must** add a set of brackets after the function name, whether this contains any inputs or not\n",
    "\n",
    "3. Return: the return statement is required to signify the end of the function definition. You don't have to return anything at the end of the function, but the return statement must still be there\n",
    "\n",
    "Below is a simple example of a function that takes one input (the text to be printed), and returns the text to the user. We assign the results of calling the function to a new variable, and print the results. As you can see, every line that you want to include in the function definition must be indented, including the **return** statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_text(input_text):\n",
    "    output_text = input_text\n",
    "    return(output_text)\n",
    "\n",
    "result = print_text(\"Hello world\")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable scope\n",
    "\n",
    "A key difference between code inside a function and elsewhere in a script is the **variable scope**: that is, where in the script variables can be accessed. If a variable is declared outside a function, it is a **global variable**: it can be accessed from within a function, or outside a function. In contrast, if a variable is declared inside a function, it is a **local variable**: it can only be accessed from inside the function, but not outside. The code below demonstrates this - the *counter* variable is declared inside the function, to keep track of the number of words that have been checked, and it is accessed without trouble by the print message inside the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this function checks whether each word in a list of words contains a Z\n",
    "def check_Z(word_list):\n",
    "    Z_status = []\n",
    "    # this counter is a local variable\n",
    "    counter = 0\n",
    "    for i in word_list:\n",
    "        counter += 1\n",
    "        if \"Z\" in i:\n",
    "            Z_status.append(True)\n",
    "        else:\n",
    "            Z_status.append(False)\n",
    "        # accessing the local variable inside the function works fine\n",
    "        print(\"Word {} checked\".format(counter))\n",
    "    return(Z_status)\n",
    "\n",
    "results = check_Z([\"Zoo\", \"Zimbabwe\", \"Ocelot\"])\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if we add an extra line at the end of the script which attempts to access the *counter* variable outside the function, we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this function checks whether each word in a list of words contains a Z\n",
    "def check_Z(word_list):\n",
    "    Z_status = []\n",
    "    Z_progress = []\n",
    "    # this counter is a local variable\n",
    "    counter = 0\n",
    "    for i in word_list:\n",
    "        counter += 1\n",
    "        Z_progress.append(counter)\n",
    "        if \"Z\" in i:\n",
    "            Z_status.append(True)\n",
    "        else:\n",
    "            Z_status.append(False)\n",
    "        # accessing the local variable inside the function works fine\n",
    "        print(\"Word {} checked\".format(counter))\n",
    "    return((Z_status, Z_progress))\n",
    "\n",
    "check_Z([\"Zoo\", \"Zimbabwe\", \"Ocelot\"])\n",
    "# accessing the local variable outside the function doesn't work\n",
    "print(\"Final counter value = {}\".format(counter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As this shows, variables declared inside a function are effectively invisible to all code that is outside the function. This can be frustrating, but overall it is a very good thing - without this behaviour, we would need to check the name of every variable within every function we are using to ensure that there are no clashes!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advanced functions\n",
    "\n",
    "#### Setting defaults for inputs\n",
    "\n",
    "For some functions, it is useful to specify a default value for an input. This makes it optional for the user to set their own value, but allows the function to run successfully if this input is not specified. To do this, we simply add an equals sign and a value after the input name. For example, we may want to add a *verbose* input to the **print_text()** function to print progress messages while a function runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_text(input_text, verbose=False):\n",
    "    if verbose:\n",
    "        print(\"Reading input text\")\n",
    "    output_text = input_text\n",
    "    if verbose:\n",
    "        print(\"Preparing to return text\")\n",
    "    return(output_text)\n",
    "\n",
    "print_text(\"Hello\", False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default setting for the *verbose* input is *False*, so the behaviour of the function will not change if the *verbose* input is not specified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_text(\"Hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we now have the option to provide a value to the *verbose* input, overriding the default value and getting progress messages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_text(\"Hello world\", verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we specify a default value for any input, we must put this input after the other inputs that do not have defaults. For example, the new version of **print_text()** will not work if we switch the order of the inputs in the function definition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_text(input_text, verbose=False):\n",
    "    if verbose:\n",
    "        print(\"Reading input text\")\n",
    "    output_text = input_text\n",
    "    if verbose:\n",
    "        print(\"Preparing to return text\")\n",
    "    return(output_text)\n",
    "\n",
    "print_text(\"Hello world\", True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions calling other functions\n",
    "\n",
    "One useful application of functions is to split a complex task into a series of simple steps, each carried out by a separate function, and then write a master function that calls all of those separate functions in the correct order. Having a series of simple functions makes it easier. In this way, an entire workflow can be constructed that is easy to adjust, and scalable across a large number of datasets. For example, we might have a number of sample names, and for each we want to:\n",
    "\n",
    "1. Find the longest part of the name\n",
    "2. Check whether that part begins with a vowel\n",
    "3. Convert the lowercase letters to uppercase, and vice versa\n",
    "\n",
    "Once we have done this, we want to gather the converted sample names into a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_name_longest_part(input_name):\n",
    "    parts = input_name.split(\"-\")\n",
    "    longest_part = \"\"\n",
    "    for i in parts:\n",
    "        if len(i) > len(longest_part):\n",
    "            longest_part = i\n",
    "    return(longest_part)\n",
    "\n",
    "# print(find_name_longest_part(\"1-32-ALPHA-C\"))\n",
    "\n",
    "def check_start_vowel(input_word):\n",
    "    vowels = [\"a\", \"e\", \"i\", \"o\", \"u\"]\n",
    "    word_to_test = input_word.lower()\n",
    "    if word_to_test[0] in vowels:\n",
    "        return(True)\n",
    "    else:\n",
    "        return(False)\n",
    "\n",
    "# print(check_start_vowel(\"ALPHA\"))\n",
    "\n",
    "def convert_case(input_word):\n",
    "    output_word = \"\"\n",
    "    for i in input_word:\n",
    "        if i.islower():\n",
    "            output_word += i.upper()\n",
    "        else:\n",
    "            output_word += i.lower()\n",
    "    return(output_word)\n",
    "\n",
    "# print(convert_case(\"ALPha\"))\n",
    "\n",
    "def convert_sample_name_parts(sample_names):\n",
    "    converted_names = []\n",
    "    for i in sample_names:\n",
    "        longest_part = find_name_longest_part(i)\n",
    "        if check_start_vowel(longest_part):\n",
    "            converted_names.append(convert_case(longest_part))\n",
    "    return(converted_names)\n",
    "\n",
    "convert_sample_name_parts([\"1-32-ALPHa-C\", \"1-33-PHI-omega\", \"1-34-BETA-sigMA\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### External functions\n",
    "\n",
    "#### Importing modules\n",
    "\n",
    "One of the great things about Python is the enormous number of functions that can be loaded and used. By default, Python only loads a basic set of functions when it is launched (or when a Jupyter notebook is opened), but extra functions can be loaded at any time by importing extra **modules**. To import a module, use the **import** command. For example, we can import the **os** module, which contains a number of functions that help us to interact with the operating system:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once a module has been imported, all of the functions contained within that module are available to use. For example, the **os** module has a **getcwd()** function, which returns the current working directory. To call this function, we must specify the module name and the function name together, in the form MODULE.FUNCTION:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some of the most useful data science modules in Python are not included with a standard Python installation, but must be installed separately. If you are using conda, you should always [install modules through conda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-pkgs.html) as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importing specific functions from modules\n",
    "\n",
    "Some modules are very large, so we may not want to import the whole module if we only need to use one function. Instead, we can specify one or more functions to be loaded using the **from** command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import getcwd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a function has been loaded using this syntax, it does **not** need to be prefaced with the module name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "getcwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aliasing\n",
    "\n",
    "Sometimes it is useful to be able to refer to a module by another name in our script, for example to reduce the amount of typing by shortening the name. To do this, we can use the **as** command to assign another name to a module as we import it, a technique known as **aliasing**. For example, we can import the **numpy** module and alias it as **np**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now whenever we want to call a function from this module, we use the alias rather than the original name. For example, the **zeros()** function allows us to create an array of specific proportions, with each element as a zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.zeros((3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also alias a function name if we import it using the **from** command. However, as with naming your own function, it is critical to avoid using the name of a function that already exists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import getcwd as get_current_wd\n",
    "get_current_wd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What not to do\n",
    "\n",
    "In some code, you may see all of the functions being imported from a module using the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At first glance this looks more convenient than importing the module as a whole, because we no longer need to preface the function name with the module name when calling it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "getcwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, you should avoid this. This is because if the module contains a function with the same name as a function that is already loaded, Python will replace that pre-loaded function with the new function without telling you. \n",
    "\n",
    "This has three consequences:\n",
    "\n",
    "1. The pre-loaded function is no longer available\n",
    "2. Debugging is now much more difficult, because you don't know which function is being called\n",
    "3. If you call the function and expect to get the pre-loaded version, you will get unexpected (and potentially disastrous) behaviour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment\n",
    "\n",
    "1. Look at the METABRIC data file `metabric_clinical_and_expression_data.csv` on breast cancer referred above. Answer the following questions:\n",
    "\n",
    "    - For how many unique patients we have data available?\n",
    "    - How many patients were older than 75 when diagnosed with breast cancer? \n",
    "    - What were the earliest and oldest ages of diagnosis?\n",
    "    - How many patients were treated with Chemotherapy and Radiotherapy?\n",
    "    - How many patients had less than three mutations in the genes investigated?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Below there is a list of 5 protein sequences, specified in the single amino acid code where one letter corresponds to one amino acid. Write a function that finds the most abundant amino acid in a given protein sequence, but prints a warning message if the protein sequence is shorter than 10 amino acids. Run your function on each of the proteins in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "proteins = [\n",
    "    \"MEAGPSGAAAGAYLPPLQQ\",\n",
    "    \"VFQAPRRPGIGTVGKPIKLLANYFEVDIPK\",\n",
    "    \"IDVYHY\",\n",
    "    \"EVDIKPDKCPRRVNREVV\",\n",
    "    \"EYMVQHFKPQIFGDRKPVYDGKKNIYTVTALPIGNER\"\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. The code below is intended to specify a function which looks up the capital city of a given country, and calls this function on a list of two countries. However, it currently has a bug which stops it from running. There are three possibilities for the nature of this bug:\n",
    "\n",
    "    - Its arguments are in the wrong order\n",
    "    - It uses a variable that is out of scope\n",
    "    - It is missing the return statement\n",
    "\n",
    "What is the bug?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "capital_cities = {\n",
    "    \"Sweden\": \"Stockholm\",\n",
    "    \"UK\": \"London\",\n",
    "    \"USA\": \"Washington DC\"\n",
    "}\n",
    "\n",
    "def find_capital_city(verbose=True, country):\n",
    "    if country in capital_cities:\n",
    "        capital_city = capital_cities[country]\n",
    "        if verbose:\n",
    "            print(\"Capital city located\")\n",
    "    else:\n",
    "        capital_city = \"CAPITAL CITY NOT FOUND\"\n",
    "    return(capital_city)\n",
    "\n",
    "countries = [\"USA\", \"UK\", \"Sweden\", \"Belgium\"]\n",
    "for i in countries:\n",
    "    print(find_capital_city(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. In the data folder, you will find a file \"imagine_lyrics.txt\", which contains the lyrics to the song Imagine by John Lennon. Your task is to find out which word is used most frequently in the lyrics. There are many ways to approach this, but however you solve it, remember to break up your code into functions! Some words aren't very interesting e.g. \"the\", \"a\", \"and\" so we might want to exclude these from consideration when finding the most frequent word in a set of lyrics. Include an option to exclude a custom list of words, and test how the results change when excluding \"the\", \"a\" & \"and\"."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}