w1/en-w1-s04-c2-python-notions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"licence\">\n",
    "<span>Licence CC BY-NC-ND</span>\n",
    "<span>François Rechenmann &amp; Thierry Parmentelat</span>\n",
    "<span><img src=\"media/inria-25-alpha.png\" /></span>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some python basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you know how to use a notebook, let us see some basic notions of python.\n",
    "\n",
    "**You are reminded that the usual way to read a notebook is to select the first cell, and then to use *Shift+Enter* to navigate down to the end of the notebook**, so that you are sure to evaluate all the code cells."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your goal here really is to give you a glimpse at python. Of course if you are already familiar with the language, you can skip this notebook. Conversely, if you do not know the language at all, be aware that we will introduce all the notions again as we go."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to do all the usual computations in Python, like with a pocket calculator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# on small integers\n",
    "256 - 27"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I took this chance to show you that a line starting with a sharp sign `#` is **ignored**, it is a **comment**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or just the same on very large integers\n",
    "6786897689768976893324534535 * 34535678909876543567890876"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or on floating numbers\n",
    "3.14159 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The case of division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Division in python behaves as follows."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * you always get **a float** when doing a simple division with a single slash `/`, even if between 2 integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "100/8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * and to obtain the quotient of an integer division, you need to use a double slash `//`, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "100//8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables and assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course as soon as computations must be made, it is required to store a result in a variable. In python, assignment is quite simply done with the equal sign `=`, as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 12\n",
    "b = 36\n",
    "c = a * b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, if we're willing to spend a little effort on presentation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# it is possible to pass several parameters to print\n",
    "# they are then all printed out, with a SPACE in between\n",
    "print(\"c=\", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  `print` or not `print` ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will notice that we have sometimes used `print`, and sometimes not. The logic is as follows: whenever a cell is evaluated, the **last** result is printed by default. This is why we obtain below the value of `c` even though we have not explicitly called `print`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But now I do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c = 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this does not cause anything to be printed. What happens here is, this code fragment - it is called an assignment - does not return any result. And in this case we need to explicitly call `print` this time if we wish to see the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 300\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "According to this logic, one may have to call `print` when some intermediate results are of interest, or if we wish to improve the way things are shown."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 12\n",
    "print(\"a=\", a)\n",
    "b = 36\n",
    "print(\"b=\", 36)\n",
    "c = a + b//2\n",
    "print(\"c=\", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python of course allows to deal with strings of characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can use either double quotes \"\" \n",
    "first_name = \"John\"\n",
    "# or single quotes ''\n",
    "last_name = 'Doe'\n",
    "print(first_name, last_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to concatenate several strings, we add them with the + sign\n",
    "full_name = first_name + \" \" + last_name\n",
    "print(\"Full name:\", full_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `for` loop on a string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is very easy to scan a string with a `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DNA = \"AGCTGTCGCG\"\n",
    "for letter in DNA:\n",
    "    print('the sequence contains', letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Objects typed as lists allow to store several results while remembering the order between them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A list is built using square brackets []\n",
    "list1 = [ 1, 2 ]\n",
    "# you can mix different types of objects in a list\n",
    "list2 = [ \"three\", 4.]\n",
    "print(list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# like with strings, lists can be concatenated with a +\n",
    "list3 = list1 + list2\n",
    "print(list3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, you can add items at the end of a list with the `append` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding string \"five\" at the end of our list\n",
    "list3.append(\"five\")\n",
    "print(list3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional test `if`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can test an expression with a `if` .. `elif` .. `else` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "if x < 4:\n",
    "    print(\"small\")\n",
    "elif x < 20:\n",
    "    print(\"medium\")\n",
    "else:\n",
    "    print(\"large\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions : `def` and `return`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One way to write code that you can re-use, is to define a **function**. For example instead of the previous cell we could have defined a function instead, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we define a function that returns a string\n",
    "# 'small', 'medium' or 'large' depending of the value of x\n",
    "def triage(x):\n",
    "    # it is IMPORTANT to indent the text area \n",
    "    # that contains the function body\n",
    "    if x < 4:\n",
    "        return \"small\"\n",
    "    elif x < 20:\n",
    "        return \"medium\"\n",
    "    else:\n",
    "        return \"large\"\n",
    "    \n",
    "# if we come back to the first column here, \n",
    "# we are effectively ending the function definition for triage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can notice that after evaluating this cell, **nothing gets printed**. It is the expected behaviour, because we have just **defined** a function, but we have **not called it**.\n",
    "\n",
    "Now that the function is defined, we can call it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = triage(10)\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note here:\n",
    "\n",
    "  * the `def` keyword that allows us to define the `triage` function,\n",
    "  * the syntax for calling `triage(10)`, and the fact that we store the result in the `message` variable,\n",
    "  * the `return` keyword inside the function body, that specifies what the result should be for `triage` - and so, what will in this case be stored in `message` ultimately\n",
    "\n",
    "Like here, it is **often the smartest approach** to design a function that **computes** a result without printing it, and to proceed with the printing outside of the function only if/when it is necessary, rather than printing anything in the function itself. This is because in most cases, actually printing anything is generally optional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With all this in place, we can now run the same code several times with different values for `x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(triage(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(triage(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(triage(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax and indentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Those of you who are familiar with languages like C, C++ or Java, and many others actually, may be surprised to notice the total absence of markers like `{` and `}` or `begin/end` pairs to work as delimiters in the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python, the syntax actually relies a lot - almost exclusively in fact - on code indentation, like you can see on the few previous examples, which allows to get entirely rid of such begin or end markers. What remains only is the necessity to insert a `:` with statements like `if`, `for` and `def`.\n",
    "\n",
    "Admittedly this choice may sound odd the first time, but you will see very soon how pleasant this syntax turns out to be for both reading and writing python code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `for` loop on a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can do a `for` loop on other things than strings, on almost everything where that makes sense actually, and in particular on list objects; we could thus have written the last 3 cells like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "subjects = [0, 8, 20]\n",
    "for subject in subjects:\n",
    "    print(triage(subject))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries (also called maps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "python also provides a very convenient data type, called a dictionary. To keep things as simple as possible, here is how to use them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let us create a dictionary to store people's age from their name\n",
    "age_of = { 'jean' : 12, 'eric' : 25, 'anne' : 48 }\n",
    "age_of"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This dictionary can thus be thought of as a list of couples (key ➞ value); here we have 3 keys that are the 3 strings `jean`, `eric` and `anne`. Notice right away that unlike lists, this structure is **not ordered**. \n",
    "\n",
    "From a dictionary we can look up the values attached to a key, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let us look up the value attached to key 'anne'\n",
    "age_of['anne']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The thing to remember about dictionaries is that the **performance** of such a look-up operation **does not depend on the dictionary size** (or at least not in a linear way). It is the main purpose of a dictionary to be able to store a great deal of data without slowing down their future use. We will have opportunities to talk about this point again later on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A variable is not a string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also note that in our last code cell, the quotes `'` are mandatory:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we removed the `'` we would get this error:\n",
    "```\n",
    ">>> age_of[anne]\n",
    "---------------------------------------------------------------------------\n",
    "NameError                                 Traceback (most recent call last)\n",
    "<ipython-input-220-a83ba2c48145> in <module>()\n",
    "      1 # when we remove the ' we get a NameError\n",
    "----> 2 age_of[anne]\n",
    "\n",
    "NameError: name 'anne' is not defined\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That fragment would be valid if we had defined a variable named `anne`. \n",
    "It is important to distinguish between \n",
    "\n",
    " * the `anne` **variable** - that in our case is not defined, because we never did anything like `anne = some thing`, \n",
    " * the `'anne'` string, which here is actually present in the dictionary as a key.\n",
    "    \n",
    "Which means that the fragment below is valid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_name = 'anne'\n",
    "age_of[first_name]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### An example of a complete function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a conclusion for this quick introduction, here is a small piece of code that allows to\n",
    "\n",
    " * accept as an incoming parameter a string `dna`; we assume that this string contains only 'A' or 'T'\n",
    " * compute (and return) a **list**, made of as many elements as `dna` has letters, each of them being 'up' when the incoming string contains a 'A', or 'down' for `T`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def directions(dna):\n",
    "    # initialize result\n",
    "    result = []\n",
    "    # scan dna\n",
    "    for letter in dna:\n",
    "        # is it an A\n",
    "        if letter == 'A':\n",
    "            # add to result the string 'up'\n",
    "            result.append('up')\n",
    "        # almost the same for T\n",
    "        elif letter == 'T':\n",
    "            result.append('down')\n",
    "        # otherwise show an error message\n",
    "        else:\n",
    "            print(\"unexpected letter\", letter)\n",
    "    # here we have all that we wanted in the 'result' list\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which gives us on a few inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "directions('ATAT')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "directions('TTTAAA')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Version of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code in this course has been written for Python-3.6, but should also work with older versions of Python3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Performances"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The python language is very convenient, because it is interpreted, and so it allows to compute things interactively, as well as to study variants, or to gather averages or other statistical data, and to visualize data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, you need to remember that for algorithms that require a lot of computation, python can turn out to be rather slow. We will have an opportunity to come back to that in particular about the Needleman and Wunsch algorithm in Week 4, Sequence 9."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please just remember, at this stage, that the algorithms that we will see in this course are mainly designed for teaching, and that in some cases they are very unefficient as compared to what would be achievable using a compiled language like C or C++."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In practice, the trend is to use **libraries of functions** that implement base algorithms written in a **compiled language** of that kind, and that are made **available to python** through *wrappers*, i.e. python functions that call the compiled code. This way we can have the pros of both approaches, namely **great flexibility** for interactive use, while preserving **optimal performance**.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again this introduction is an excessively fast overview of the python language (1% maybe..) designed to get us started. You will find a very large number of resources on the Internet if you wish to learn the language in more details, but this is not at all our focus here."
   ]
  }
 ],
 "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.7.0"
  },
  "livereveal": {
   "height": 800,
   "start_slideshow_at": "selected",
   "theme": "simple",
   "transition": "cube",
   "width": 1200
  },
  "notebookname": "Some python basics",
  "version": "1.0"
 },
 "nbformat": 4,
 "nbformat_minor": 1
}