notebooks/python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python tutorial\n",
    "\n",
    "## [Scientific Computing with Python](http://scicompy.yoavram.com)\n",
    "## Yoav Ram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Hello Jupyter!\n",
    "\n",
    "To execute code in Jupyter notebook press `Shift+Enter` (or `Shift+Return`) or press `Control+Enter` (or `Command+Return`). The former will execute and advance, the later will execute and stay.\n",
    "You can also use the ▶️ button on the command pallete above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Python!\n"
     ]
    }
   ],
   "source": [
    "print(\"Welcome to Python!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`print` is a builtin function, and it can print text along with some execution -- in general `print` accepts as many arguments as we want, and separates them with spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The product of 7 and 8 is 56\n"
     ]
    }
   ],
   "source": [
    "print(\"The product of 7 and 8 is\", 7 * 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: `print`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print to the screen the following sentences:  \n",
    "\n",
    "- \"I love Python!\"\n",
    "- \"7 + 6 = RESULT\", replacing `RESULT` with the computation of 6+7\n",
    "- \"my name is NAME\", replacing `NAME` with your name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables\n",
    "\n",
    "A variable is a _name_ that references a an _object_ in memory.\n",
    "An object has a _value_ and a _type_.\n",
    "\n",
    "To bind an _object_ to a _variable_, we use the _assignment_ operator `=`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once a variable has been declared, we can use its name to get its value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Types\n",
    "\n",
    "These are the basic Python data types:\n",
    "\n",
    "| Type | Description | Range | Use |\n",
    "|--------|-----------|-------|--------|\n",
    "| `int`  | Integers | -oo to oo | counting, indexing |\n",
    "| `float` | Decimal fractions | limited precision, depends on machine | calculations |\n",
    "| `complex` | Complex numbers | just two floats | complex calculations  |\n",
    "| `str` | Strings | unicode | text, categories |\n",
    "| `bool` | Booleans | `True` and `False` | boolean logic |\n",
    "\n",
    "We can determine a variable's type using the `type` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `int`\n",
    "The **`int`** type is for integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in Python 3 integers have unlimited precision:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 13891783871827487875832758374287348205743285742386738476843768327683467432876284368236487283476847684376843768207185275128758785712853783275137587357138757\n",
    "type(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but the larger the number the more memory it requires:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(513, 4)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n.bit_length(), a.bit_length()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `float`\n",
    "\n",
    "**`float`** is for decimal point numbers, and is usually implemented using a double in C:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5.12312983\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get info on float precision with this specific Python build, call (we'll learn about `import` in another session):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.float_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `complex`\n",
    "\n",
    "**`complex`** is for complex numbers, in which each component is a `float`. Note that the imaginary part is denoted by `j` rather than `i`, probably because `i` is a common name for loop indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1+0j)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1j)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = 4.5 + 3j\n",
    "type(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(z.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We saw three numerical types: `int`, `float`, and `complex`. \n",
    "\n",
    "The standard library includes additional numeric types. The *fractions* module deals with rational fractions; the *decimal* module deals with floating-point numbers with user-definable precision."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `str`\n",
    "\n",
    "**`str`** is for strings, used for both characters and text. \n",
    "Will deal with strings later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `bool`\n",
    "\n",
    "Lastly, **`bool`** is for boolean variables that are either `True` or `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value = True # Camelcase\n",
    "type(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variable names\n",
    "* You *can't include spaces*. \n",
    "* In principle, you can use any unicode symbol.\n",
    "* You can override words that have special meaning in python (for example `print`), but don't do it unless you have a good reason.\n",
    "* The convention is to use *lowercase only* and separate words with *underscores*: `num_atoms`, `first_template`.\n",
    "* For more details on Python style conventions, see [PEP8](https://www.python.org/dev/peps/pep-0008/), the Python style guide.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "יואב\n"
     ]
    }
   ],
   "source": [
    "שם = 'יואב'\n",
    "print(שם)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comments\n",
    "\n",
    "Everything between a hashtag symbol `#` and the end of the line is a comment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This will be printed\n",
      "Another example\n"
     ]
    }
   ],
   "source": [
    "print(\"This will be printed\")\n",
    "# print(\"This will not be printed\")\n",
    "print(\"Another example\") # of a comment "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tip:** In the notebook you can comment and uncomment complete lines by selecting them and pressing `Ctrl+/`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operators\n",
    "\n",
    "## Arithmetic operators\n",
    "\n",
    "| Symbol | Operator                    | Use    |\n",
    "|--------|-----------------------------|--------|\n",
    "| +      | Addition                    | x + y  |\n",
    "| -      | Substraction                | x - y  |\n",
    "| *      | Multiplication              | x * y  |\n",
    "| **     | Power                   | x ** y |\n",
    "| /      | Decimal division            | x / y  |\n",
    "| //     | Integer division            | x // y |\n",
    "| %      | Integer remainder           | x % y  |\n",
    "\n",
    "This is fairly straightforward except maybe integer division `//` and power `**`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Substract:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a - b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multipy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Power:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a**b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decimal division:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a / b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integer division:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a // b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remainder (modulo):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a % b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Pythagoras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define two variables, `a` and `b`, and give them numeric values of your choice. \n",
    "\n",
    "Assume these are the lengths of the edges of a right angle triangle, and use numeric operators to calculate the length of the hypotenuse (יתר). \n",
    "\n",
    "Print out the result.  \n",
    "\n",
    "Reminder: $c^2 = a^2 + b^2$  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hint**: to calculate the squared root of c, use c\\*\\*0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison operators\n",
    "These operators are used to compare values. They always return boolean values: `True` or `False`.\n",
    "\n",
    "| Symbol | Operator          | Use    |\n",
    "|--------|-------------------|--------|\n",
    "| ==     | Equals            | x == y |\n",
    "| !=     | Not equals        | x != y |\n",
    "| <      | Smaller than      | x < y  |\n",
    "| >      | Larger than       | x > y  |\n",
    "| <=     | Smaller or equals | x <= y |\n",
    "| >=     | Larger or equals  | x >= y |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a == b    # Note: '==', not '='"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a > b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b > a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a != b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b < 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b <= 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For strings, comparison operators are based on **lexicographical order**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food = 'Noodles'\n",
    "drink = 'Ice Tea'\n",
    "food == drink"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food > drink"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food <= drink"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food == 'Noodles'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical operators\n",
    "\n",
    "| Keyword | Use     |\n",
    "|---------|---------|\n",
    "| and     | a and b |\n",
    "| or      | a or b  |\n",
    "| not     | not a   |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a > b and a != b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a != b and a < b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a != b or a < b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boolean = a > b\n",
    "type(boolean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boolean and b == 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also think of logical operators as 2X2 matrices, or alternatively - Venn diagrams.\n",
    "\n",
    "![logic_venn](https://raw.githubusercontent.com/yoavram/Py4Life/master/lec1_images/logic_venn.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditional statements\n",
    "## `if` statements\n",
    "\n",
    "The `if` statement allows us to condition the program flow on its data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 2\n",
    "\n",
    "if a > b:\n",
    "    print('Yes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "if a < b:\n",
    "    print('Yes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the colon and the indented block. The syntax is always:\n",
    "\n",
    "```py\n",
    "if condition:  \n",
    "    statement1\n",
    "    statement2\n",
    "    statement3\n",
    "    ...\n",
    "```\n",
    "\n",
    "The condition does not need to be surrounded by round brackets `(...)`.\n",
    "\n",
    "**Whitespaces mark block code**: Only commands within the indented block are conditional. Other commands will be executed, no matter if the condition is met or not. There is no use of curly brackets or `end` command: unindenting will close the code block.\n",
    "\n",
    "Also, the condition does not need to be surrounded by round brackets `(...)`.\n",
    "\n",
    "__Note__: the condition expression is always converted to a boolean -- if it's not already a boolean, it will be implicitly converted into one. \n",
    "The indented commands only occur if the boolean has a `True` value.\n",
    "Therefore, we can use logical operators to create more complex conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `if` example: divisibility\n",
    "\n",
    "Let's write a program that checks if a number is devisible by 17. Remember the modulo operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "442 is devisible by 17!\n",
      "End of program\n"
     ]
    }
   ],
   "source": [
    "n = 442\n",
    "\n",
    "if n % 17 == 0:\n",
    "    print(n, 'is devisible by 17!')\n",
    "\n",
    "print('End of program')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `else` statements\n",
    "\n",
    "We can add _else_ statements to perform commands in case the condition is __not__ met, or in other words, if the boolean is False.\n",
    "\n",
    "![if else flow](https://raw.githubusercontent.com/yoavram/Py4Life/master/lec1_images/if_else_flow.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "586 is not devisible by 17!\n",
      "End of program\n"
     ]
    }
   ],
   "source": [
    "n = 586\n",
    "\n",
    "if n % 17 == 0:\n",
    "    print(n, 'is devisible by 17!')\n",
    "else:\n",
    "    print(n, 'is not devisible by 17!')\n",
    "    \n",
    "print('End of program')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `elif` statements\n",
    "\n",
    "When using _elif_ statements, multiple conditions are tested one by one. Once a condition is met, the corresponding indented commands are performed. If none of the conditions is `True`, the `else` block (if exists) is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "586 is not devisible by 17, but it is even!\n",
      "End of program\n"
     ]
    }
   ],
   "source": [
    "n = 586\n",
    "\n",
    "if n % 17 == 0:\n",
    "    print(n, 'is devisible by 17!')\n",
    "elif n % 2 == 0:\n",
    "    print(n, 'is not devisible by 17, but it is even!')\n",
    "else:\n",
    "    print(n, 'is not devisible by 17, and it is odd!')\n",
    "    \n",
    "print('End of program')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: leap year"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A leap year is a year that has 366 days (adding February 29th). A year is a leap year if it is divisible by 400, or divisible by 4 but not by 100. \n",
    "\n",
    "For example, 2012 and 2000 are leap years, but 1900 isn't. \n",
    "\n",
    "Test a year of your choice by  using an appropriate `if` statement and print the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `while` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use `while` loops to do something again and again, as long as a condition is met.  \n",
    "\n",
    "![while](http://www.tutorialspoint.com/images/python_while_loop.jpg)\n",
    "\n",
    "The syntax is very similar to that of `if` statement.\n",
    "\n",
    "Let's count how many times it takes to get a random number greater than 90. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33\n",
      "86\n",
      "40\n",
      "20\n",
      "Found a number greater than 90 ( 92 ) after  5 trials.\n"
     ]
    }
   ],
   "source": [
    "from random import randint # we will get back to import later on\n",
    "\n",
    "trials = 1\n",
    "random_num = randint(1, 100)\n",
    "\n",
    "while random_num <= 90:        # condition\n",
    "    print(random_num)           # indented block\n",
    "    random_num = randint(1,100) # indented block\n",
    "    trials = trials + 1\n",
    "print ('Found a number greater than 90 (', random_num, ') after ', trials, 'trials.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Collatz Conjecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Collatz Conjecture (also known as the 3n+1 conjecture) is the conjecture that the following process is finite for every natural number:\n",
    "\n",
    "> If the number n is even divide it by two, if it is odd multiply it by 3 and add 1. Repeat this process until you get the number 1.\n",
    "\n",
    "Write a program to check if the Collatz conjecture is true for a number of your choice. Print every step of the process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![CollatzXKCD](http://imgs.xkcd.com/comics/collatz_conjecture.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "Strings are ordered collections of _characters_. \n",
    "\n",
    "_Ordered collections_ means that elements are numbered with _indexes_: 0, 1, 2, 3, 4...  \n",
    "Note that the first index is 0, __not__ 1!\n",
    "\n",
    "We can create new string usings single- or double-quotes: `'` or `\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jupyter\n",
      "I love Python\n"
     ]
    }
   ],
   "source": [
    "x = \"Jupyter\"\n",
    "y = 'I love Python'\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are objects of type `str`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiline strings\n",
    "\n",
    "Multiline strings can be defined using `\"\"\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Customer: 'Not much of a cheese shop really, is it?'\n",
      "Shopkeeper: 'Finest in the district, sir.'\n",
      "Customer: 'And what leads you to that conclusion?'\n",
      "Shopkeeper: 'Well, it's so clean.'\n",
      "Customer: 'It's certainly uncontaminated by cheese.'\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cheeseshop_dialog =\"\"\"Customer: 'Not much of a cheese shop really, is it?'\n",
    "Shopkeeper: 'Finest in the district, sir.'\n",
    "Customer: 'And what leads you to that conclusion?'\n",
    "Shopkeeper: 'Well, it's so clean.'\n",
    "Customer: 'It's certainly uncontaminated by cheese.'\n",
    "\"\"\"\n",
    "print(cheeseshop_dialog)\n",
    "type(cheeseshop_dialog)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenation \n",
    "We can concatenate strings using the addition operator `+`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jupyter2018\n"
     ]
    }
   ],
   "source": [
    "print(x + \"2018\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversion\n",
    "We can convert string to numbers and vice versa (if it is appropriate)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y + 1 = 5\n"
     ]
    }
   ],
   "source": [
    "x = \"4\"\n",
    "y = int(x)\n",
    "print(\"y + 1 =\", y + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otherwise, we get an error message..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-76-ce758d702252>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"x + 1 =\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "print(\"x + 1 =\", x + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 4\n"
     ]
    }
   ],
   "source": [
    "x = str(y)\n",
    "print(\"x =\", x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y*2 = 6.28\n"
     ]
    }
   ],
   "source": [
    "x = \"3.14\"\n",
    "y = float(x)\n",
    "print(\"y*2 =\", y * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings as sequences\n",
    "\n",
    "Strings are text but can represent other things, too. For example, DNA sequences.\n",
    "\n",
    "Again we can concat strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AAAATGGGG\n"
     ]
    }
   ],
   "source": [
    "upstream = \"AAA\"\n",
    "downstream = \"GGG\"\n",
    "dna = upstream + \"ATG\" + downstream\n",
    "print(dna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can find the length of a string using the command `len`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of the DNA variable is 9\n",
      "Now it is 15\n"
     ]
    }
   ],
   "source": [
    "n = len(dna)\n",
    "print(\"The length of the DNA variable is\", n)\n",
    "\n",
    "dna = dna + \"AGCTGA\"\n",
    "print(\"Now it is\", len(dna))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Augmented assignment\n",
    "\n",
    "We can use augmented assignment to make `dna = dna + x` into `dna += x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AAAATGGGGAGCTGA\n",
      "AAAATGGGGAGCTGAAGCTGA\n"
     ]
    }
   ],
   "source": [
    "print(dna)\n",
    "dna += \"AGCTGA\"\n",
    "print(dna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Augmented assignment also work with numbers and other operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "x *= 7\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Access: Indexing\n",
    "\n",
    "We can acces specific characters (sequence items) in a string using square brackets `[i]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"A musician wakes from a terrible nightmare.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "i\n"
     ]
    }
   ],
   "source": [
    "print(text[0])\n",
    "print(text[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python uses **zero-count** indexing: the first element has index 0.\n",
    "\n",
    "In addition, there is also support for **reverse indexing** using negative numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "print(text[-1])\n",
    "print(text[-4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the last element is accessed using -1 index, and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Access: Slicing\n",
    "We can extract subsets of a string by using _slicing_, with the corresponding indexes.  \n",
    "Remember: indexes start from **0**!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access specific indexes of the list (_starting from 0_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "i\n"
     ]
    }
   ],
   "source": [
    "# get the 1st and 6th letters\n",
    "print(text[0])\n",
    "print(text[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexes work from the tail as well, using negative indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".\n",
      "m\n"
     ]
    }
   ],
   "source": [
    "# get the last letter\n",
    "print(text[-1])\n",
    "# get 5th letter from the end\n",
    "print(text[-5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get a range of indexes using _\\[start:end\\]_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "musici\n"
     ]
    }
   ],
   "source": [
    "# get the 3rd to 8th letters\n",
    "print(text[2:8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the _start_ position is included, but not the _end_ position. We actually take the characters with indexes 2,3,4,5,6,7."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are shortcuts for taking the first and last characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A mus\n",
      "A mus\n",
      "usician wakes from a terrible nightmare.\n",
      "re.\n"
     ]
    }
   ],
   "source": [
    "# get the first 5 letters\n",
    "print(text[0:5])\n",
    "# or simply:\n",
    "print(text[:5])\n",
    "\n",
    "# get 3rd to last letters:\n",
    "print(text[3:])\n",
    "\n",
    "# last 3 letters\n",
    "print(text[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: String access"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sequence below (named _seq_) consists of 20 characters. \n",
    "\n",
    "1. Print the 2nd and 7th characters.\n",
    "2. Print the 2nd character from the end.\n",
    "3. Slice the first half of the sequence.  \n",
    "4. Slice the second half of the sequence.  \n",
    "5. Slice the middle 10 characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = \"CAAGTAATGGCAGCCATTAA\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String formatting\n",
    "\n",
    "There are three ways to do this:\n",
    "1. Using `%` (the old way)\n",
    "2. Using the `format` method (the new way)\n",
    "3. Using [f-strings](https://docs.python.org/3/reference/lexical_analysis.html#f-strings) (the very new way)\n",
    "\n",
    "We'll mostly use the `format` method\n",
    "\n",
    "The `format` method works on a string template, with placeholders marked by curly brackets (who said Python doesn't like curly brackets?).\n",
    "The method arguments are parsed to be the values for the placeholders, by order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Adam Price, would you like 1 or 2 apples?\n"
     ]
    }
   ],
   "source": [
    "message = \"Hello {}, would you like {} or {} apples?\"\n",
    "message = message.format(\"Adam Price\", 1, 2)\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also specify placeholder's replacement using indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Adam, my name is Wendy, if your name is not Adam, please let me know\n"
     ]
    }
   ],
   "source": [
    "message = 'Hello {0}, my name is {1}, if your name is not {0}, please let me know'\n",
    "message = message.format('Adam', 'Wendy')\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can also use named placeholders and specify the values as keyword arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Adam, my name is Wendy, if your name is not Adam, please let me know\n"
     ]
    }
   ],
   "source": [
    "message = 'Hello {guest}, my name is {host}, if your name is not {guest}, please let me know'\n",
    "message = message.format(guest='Adam', host='Wendy')\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Format automatically handles numbers and other string conversions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Snowhite and the 7 dwarfs\n",
      "Snowhite and the 7.0 dwarfs\n",
      "Snowhite and the (7+0j) dwarfs\n"
     ]
    }
   ],
   "source": [
    "print(\"Snowhite and the {} dwarfs\".format(7))\n",
    "print(\"Snowhite and the {} dwarfs\".format(7.0))\n",
    "print(\"Snowhite and the {} dwarfs\".format(7+0j))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we can specify how to convert numbers, if we want; for example, we can specify the number of decimal digits we want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Snowhite and the 7 dwarfs\n",
      "Snowhite and the 7.0554 dwarfs\n",
      "Snowhite and the 7.055433 dwarfs\n"
     ]
    }
   ],
   "source": [
    "x = 7.0554332\n",
    "print(\"Snowhite and the {:.0f} dwarfs\".format(x))\n",
    "print(\"Snowhite and the {:.4f} dwarfs\".format(x))\n",
    "print(\"Snowhite and the {:.6f} dwarfs\".format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See all formatting options in the [docs](https://docs.python.org/3.6/library/string.html#format-string-syntax)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: bottles of beer\n",
    "\n",
    "Write a template and fill it with values using `format` to produce the following text:\n",
    "\n",
    "```\n",
    "3 bottles of beer on the wall, 3 bottles of beer.\n",
    "Take one down, pass it around, 2 bottles of beer on the wall...\n",
    "2 bottles of beer on the wall, 2 bottles of beer.\n",
    "Take one down, pass it around, 1 bottles of beer on the wall...\n",
    "1 bottles of beer on the wall, 1 bottles of beer.\n",
    "Take one down, pass it around, 0 bottles of beer on the wall...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String methods\n",
    "\n",
    "Strings have many methods for text processing.\n",
    "\n",
    "We can change a string to lowercase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a musician wakes from a terrible nightmare.\n"
     ]
    }
   ],
   "source": [
    "text = text.lower()\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and back to uppercase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A MUSICIAN WAKES FROM A TERRIBLE NIGHTMARE.\n"
     ]
    }
   ],
   "source": [
    "text = text.upper()\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can replace characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AAAAUGGGGAGCUGAAGCUGA\n"
     ]
    }
   ],
   "source": [
    "dna = 'AAAATGGGGAGCTGAAGCTGA'\n",
    "rna = dna.replace(\"T\", \"U\")\n",
    "print(rna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Count\n",
    "We can count characters. \n",
    "\n",
    "For example, let's count the number of histidine (`H`) and proline (`P`) in the [amino-acid](http://upload.wikimedia.org/wikipedia/commons/a/a9/Amino_Acids.svg) sequence of the [Human Insulin](http://www.uniprot.org/blast/?about=P01308) enzyme:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# of histidine: 2\n",
      "# of proline: 6\n"
     ]
    }
   ],
   "source": [
    "insulin = 'MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN'\n",
    "print(\"# of histidine:\", insulin.count('H'))\n",
    "print(\"# of proline:\", insulin.count('P'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Find substrings\n",
    "We can find a substring within a string.\n",
    "For example, we can look for the character `D` in the insulin sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n"
     ]
    }
   ],
   "source": [
    "pos = insulin.index('D')\n",
    "print(pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D\n"
     ]
    }
   ],
   "source": [
    "print(insulin[pos])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is the index (position) of the first `D` found in the sequence.\n",
    "\n",
    "We can also look for longer substrings, representing motiffs. For example, let's find the position of the Insulin [B-chain](http://www.uniprot.org/blast/?about=P01308[25-54]) - a specific subsequence - in the entire protein sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Position: 24\n"
     ]
    }
   ],
   "source": [
    "b_chain = \"FVNQHLCGSHLVEALYLVCGERGFFYTPKT\"\n",
    "position = insulin.index(b_chain)\n",
    "print(\"Position:\", position)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "print(len(b_chain))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Original: FVNQHLCGSHLVEALYLVCGERGFFYTPKT\n",
      "Found:    FVNQHLCGSHLVEALYLVCGERGFFYTPKT\n"
     ]
    }
   ],
   "source": [
    "found = insulin[position : position + len(b_chain)] # slicing (notice the ':')\n",
    "print(b_chain == found)\n",
    "print(\"Original:\", b_chain)\n",
    "print(\"Found:   \", found)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Split\n",
    "\n",
    "We can split a string on every occurence of a separator character:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['banana', 'ananas', 'potato', 'tomato']\n"
     ]
    }
   ],
   "source": [
    "names = \"banana,ananas,potato,tomato\"\n",
    "foods = names.split(\",\")\n",
    "print(foods)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do we get?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(foods)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Lists are similar to strings in being sequential, only they can contain **any type of data**, not just characters. They are also mutable (we'll get back to that distinction).\n",
    "\n",
    "Lists could even include mixed variable types.\n",
    "\n",
    "We define a list just like any other variable, but use `[ ]` to surround the list elements and `,` to separate the elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Human', 'Gorilla', 'Chimpanzee']\n"
     ]
    }
   ],
   "source": [
    "# a list of strings\n",
    "apes = [\"Human\", \"Gorilla\", \"Chimpanzee\"]\n",
    "print(apes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Gorila](http://upload.wikimedia.org/wikipedia/commons/thumb/c/c0/Western_Lowland_Gorilla_at_Bronx_Zoo_2_cropped.jpg/338px-Western_Lowland_Gorilla_at_Bronx_Zoo_2_cropped.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 13, 2, 400]\n"
     ]
    }
   ],
   "source": [
    "# a list of numbers\n",
    "nums = [7, 13, 2, 400]\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 'Mouse', True]\n"
     ]
    }
   ],
   "source": [
    "# a mixed list\n",
    "mixed = [12, 'Mouse', True]\n",
    "print(mixed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Access\n",
    "\n",
    "You can access list elements just like strings, using indexes (starting from 0):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Human\n",
      "Chimpanzee\n"
     ]
    }
   ],
   "source": [
    "print(apes[0])\n",
    "print(apes[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are dynamic and mutable - you can append, remove and insert into them. This is done using _list methods_.\n",
    "\n",
    "We can access and change list elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Human', 'Gorilla', 'Bonobo']\n"
     ]
    }
   ],
   "source": [
    "new_apes = apes.copy() # make a copy of the apes list\n",
    "new_apes[2] = 'Bonobo'\n",
    "print(new_apes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This __does NOT__ work with strings though..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AAAATGGGGAGCTGAAGCTGA\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-133-7258de83b3f4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdna\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mdna\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'G'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "print(dna)\n",
    "dna[5] = 'G'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is because strings are **immutable** whereas lists are **mutable**. We'll get back to this notion soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List methods\n",
    "\n",
    "Lists also have many methods. \n",
    "The most useful ones we'll see here make use of the fact that lists are **mutable**.\n",
    "\n",
    "`append` adds an element to the end of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Human', 'Gorilla', 'Chimpanzee', 'Macaco']\n"
     ]
    }
   ],
   "source": [
    "apes.append(\"Macaco\")\n",
    "print(apes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`insert` adds an element at a given index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Human', 'Gorilla', 'Kofiko', 'Chimpanzee', 'Macaco']\n"
     ]
    }
   ],
   "source": [
    "apes.insert(2, \"Kofiko\")\n",
    "print(apes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`remove` finds and deletes an element from list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Gorilla', 'Kofiko', 'Chimpanzee', 'Macaco']\n"
     ]
    }
   ],
   "source": [
    "apes.remove(\"Human\")\n",
    "print(apes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pop` deletes an elements from a list by its index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Macaco\n",
      "['Gorilla', 'Kofiko', 'Chimpanzee']\n"
     ]
    }
   ],
   "source": [
    "print(apes.pop(3))\n",
    "print(apes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can concatenate lists, just like strings, using the addition operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Gorilla', 'Kofiko', 'Chimpanzee', 'Orangutan', 'Baboon']\n"
     ]
    }
   ],
   "source": [
    "print(apes + [\"Orangutan\", \"Baboon\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Organutan](http://upload.wikimedia.org/wikipedia/commons/thumb/b/be/Orang_Utan%2C_Semenggok_Forest_Reserve%2C_Sarawak%2C_Borneo%2C_Malaysia.JPG/220px-Orang_Utan%2C_Semenggok_Forest_Reserve%2C_Sarawak%2C_Borneo%2C_Malaysia.JPG)\n",
    "\n",
    "Searching in lists is done using `index`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 Kofiko\n"
     ]
    }
   ],
   "source": [
    "i = apes.index('Kofiko')\n",
    "print(i, apes[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EAFP vs. LBYL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the value is not found a `ValueError` is raised.\n",
    "We can catch the error with a try-except block.\n",
    "This idiom is called *EAFP* - easier to ask for forgiveness than permission.\n",
    "It is a based on a quote of [Admiral Grace Hopper](https://en.wikiquote.org/wiki/Grace_Hopper), the famous computer scientists.\n",
    "\n",
    "![Grace Hopper](https://upload.wikimedia.org/wikipedia/commons/thumb/a/ad/Commodore_Grace_M._Hopper%2C_USN_%28covered%29.jpg/192px-Commodore_Grace_M._Hopper%2C_USN_%28covered%29.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Panda not in apes list\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    i = apes.index('Panda')\n",
    "except ValueError:\n",
    "    print('Panda not in apes list')\n",
    "else:\n",
    "    print('Panda in index', i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also check if something is in a list before accesing it; this is called *LBYL* - look before you leap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Panda not in apes list\n"
     ]
    }
   ],
   "source": [
    "if 'Panda' in apes:\n",
    "    i = apes.index('Panda')\n",
    "    print('Panda in index', i)\n",
    "else:\n",
    "    print('Panda not in apes list')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although exceptions are somewhat less efficient than `if` in terms of performance, in the former example we do only a single lookup (just `index`, no `in` test) and moreover, it is stable in multi-threaded applications.\n",
    "In the latter example a different thread could in principle change the dictionary between the test (`in`) and the lookup (`index`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting lists\n",
    "  \n",
    "We can sort lists using the `sorted` method.  \n",
    "If the list is made __entirely__ of strings, then sorting is straightforward -- it will be sorted lexicographically (think about the way '<' and '>' work on strings)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Chimpanzee', 'Gorilla', 'Kofiko']\n"
     ]
    }
   ],
   "source": [
    "sorted_apes = sorted(apes)\n",
    "print(sorted_apes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But beware of mixed lists!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Gorilla', 'Kofiko', 'Chimpanzee', 1, 2, 3]\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-148-11ab856c0bde>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmixed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mapes\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmixed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmixed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "mixed = apes + [1, 2, 3]\n",
    "print(mixed)\n",
    "print(sorted(mixed))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Access: Slicing\n",
    "  \n",
    "We can slice lists just like we did with strings, to get partial lists.  \n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[33, 55, 45, 87, 88, 95, 34, 76, 87, 56]\n",
      "[77, 89, 92]\n"
     ]
    }
   ],
   "source": [
    "# get the first 10 measurements\n",
    "print(measurements[:10])\n",
    "# get the last 3 measurements\n",
    "print(measurements[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Lists\n",
    "\n",
    "- Use the lists `birds` and `snakes` to create a single list of strings with the animal names. \n",
    "- Add the string `Mus musculus` to the list. \n",
    "- Remove the `Corvus corone` from the list. \n",
    "- Print the 2nd to 5th elements of the resulting list, sorted alphabetically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "birds = ['Gallus gallus', 'Corvus corone', 'Passer domesticus']\n",
    "snakes = ['Ophiophagus hannah', 'Vipera palaestinae', 'Python bivittatus']\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` loops\n",
    "\n",
    "Say we want to print each element of our list:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python’s `for` loop syntax allows us to iterate over the elements of a `list`, or any `iterable` value. Python's `for` is similar to the `foreach` statement in other languages, rather than `for(i=0; i<n; i++)`:\n",
    "\n",
    "```py\n",
    "for loop_variable in iterable:\n",
    "    statement1\n",
    "    statement2\n",
    "    statement3\n",
    "    ...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gorilla is an ape\n",
      "Kofiko is an ape\n",
      "Chimpanzee is an ape\n"
     ]
    }
   ],
   "source": [
    "for ape in apes:\n",
    "    print(ape, \"is an ape\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Python loop](http://2.bp.blogspot.com/-7lXe1_Gou3k/UX92PWche3I/AAAAAAAAAFA/JxD4u8St-9g/s1600/python+loop.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping over strings\n",
    "\n",
    "Let's go over the Insulin AA sequnce and count the number of prolines manualy. Reminder: `insulin` is a `str`, not `list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# of prolines: 6\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "for aa in insulin:\n",
    "    # the next line is equivalent to\n",
    "    # if aa == \"P\": count = count + 1\n",
    "    count += aa == \"P\"\n",
    "print(\"# of prolines:\", count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do you remember another way of doing this?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: string loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complete the code below to count the _ratio_ of electrically-charged amino acids in the Insulin sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "charged = ['R','H','K','D','E']\n",
    "insulin = 'MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERGFFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN'\n",
    "\n",
    "# Your code here\n",
    "\n",
    "print(\"Ratio of charged amino acids is:\", charged_ratio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `range`\n",
    "\n",
    "Sometimes we want to loop over consecutive numbers.\n",
    "\n",
    "This is accomplished using the `range` function.\n",
    "\n",
    "`range` accepts one, two, or three arguments: the bottom and upper limits and the step size.  \n",
    "The bottom limit can be omitted - the default is zero - and the step can be omitted, too - the default is one.\n",
    "The upper limit is __not__ included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10): # == range(0, 10, 1)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 110 120 130 140 150 160 170 180 190 200 210 220 230 240 250 260 270 280 290 300 310 320 330 340 350 360 370 380 390 400 410 420 430 440 450 460 470 480 490 500 510 520 530 540 550 560 570 580 590 600 610 620 630 640 650 660 670 680 690 700 710 720 730 740 750 760 770 780 790 800 810 820 830 840 850 860 870 880 890 900 910 920 930 940 950 960 970 980 990 "
     ]
    }
   ],
   "source": [
    "for i in range(100, 1000, 10):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can turn the range into a list -- so what is `range`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use `range` to loop on the indices of a list instead of the elements themselves.\n",
    "This is useful in some cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gorilla\n",
      "Kofiko\n",
      "Chimpanzee\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(apes)):\n",
    "    print(apes[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `enumerate`\n",
    "\n",
    "Another elegant way to iterate over lists is with the `enumerate` function. `enumerate` provides two loop variables for every item in the list -- the index and the element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The ape at index 0 is Gorilla\n",
      "The ape at index 1 is Kofiko\n",
      "The ape at index 2 is Chimpanzee\n"
     ]
    }
   ],
   "source": [
    "for i, ape in enumerate(apes):\n",
    "    print(\"The ape at index\", i, \"is\", ape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: primality check\n",
    "\n",
    "Implement a simple primality check for the variable `n=97` (or some other value of your choice).\n",
    "\n",
    "For each number `k` between 2 and `n` (or some other range if you prefer), check if `k` is a divider of `n` (using the modulo operation, right?).\n",
    "If `k` is a divider you can break the loop using `break`.\n",
    "\n",
    "**Note** `for` can have an `else` clause that will be executed if we exited the `for` normally, without a `break` or an exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "97 is a prime number\n"
     ]
    }
   ],
   "source": [
    "n = 97 # try other numbers\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "[Tuples](https://docs.python.org/3.5/tutorial/datastructures.html#tuples-and-sequences) are another data structure for sequential data. They, too, can contain any type and mixed types. The main difference between tuples and lists is that tuples are **immutable**.\n",
    "\n",
    "Tuples are denoted by round brackets `()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(15, 76, 'a')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (15, 76, 'a')\n",
    "print(t)\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are commonly packed and unpacked in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 15 b: 76 c: a\n",
      "(15, 76)\n"
     ]
    }
   ],
   "source": [
    "a, b, c = t # unpacking\n",
    "print('a:', a, 'b:', b, 'c:', c)\n",
    "t = a, b # packing\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create empty and singleton tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t0 = ()\n",
    "type(t0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = (5,) # notice the comma\n",
    "type(t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionaries** are hashtables or maps: a data structure used to store collections of elements to be accessed with a _key_.\n",
    "Keys can be of any _immutable_ type - strings, integers, floats, etc.\n",
    "Each key refers to a single _value_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "taxonomy = {\n",
    "    'Pan troglodytes': 'Mammalia', \n",
    "    'Gallus gallus': 'Aves', \n",
    "    'Xenopus laevis': 'Amphibia', \n",
    "    'Vipera palaestinae': 'Reptilia'\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this dictionary, the _keys_ are the organisms and the _values_ are the taxonomic classification of each organism. Both are of type `str`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Access\n",
    "Accessing a dictionary record is similar to what we did with lists, only this time we'll use a _key_ instead of an _index_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mammalia\n",
      "Aves\n"
     ]
    }
   ],
   "source": [
    "print(taxonomy['Pan troglodytes'])\n",
    "print(taxonomy['Gallus gallus'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing and adding records\n",
    "We can change the dictionary by simply assigning a new value to a key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mammals\n"
     ]
    }
   ],
   "source": [
    "taxonomy['Pan troglodytes'] = 'Mammals'\n",
    "print(taxonomy['Pan troglodytes'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can use this syntax to add new records: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actinopterygii\n"
     ]
    }
   ],
   "source": [
    "taxonomy['Danio rerio'] = 'Actinopterygii'\n",
    "print(taxonomy['Danio rerio'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Note 1__: The fact that we can change elements of the dictionary and dynamically add more elements suggests that `dict` is a **mutable** type.\n",
    "\n",
    "__Note 2__: A dictionary may not contain multiple records with the same _key_, but it may contain many keys with the same _value_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping over dictionaries\n",
    "\n",
    "By default, `for` loops over the dictionary keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pan troglodytes is of class Mammals\n",
      "Gallus gallus is of class Aves\n",
      "Xenopus laevis is of class Amphibia\n",
      "Vipera palaestinae is of class Reptilia\n",
      "Danio rerio is of class Actinopterygii\n"
     ]
    }
   ],
   "source": [
    "for organism in taxonomy:\n",
    "    print('{} is of class {}'.format(organism, taxonomy[organism]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: the order of the keys in the dictionary items is **arbitrary** in Python <=3.5, and **ordered** in Python 3.6, but the fact it is ordered is an implelemtation detail rather than part of the specification, so we should not rely on this order. If you need a **explicitly ordered** dictionary, use [OrderedDict](https://docs.python.org/3/library/collections.html#collections.OrderedDict).\n",
    "\n",
    "We can even change values while looping, as this doesn't affect the keys collection (changing what you loop over is dangerous!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries as containers\n",
    "We can check if a dictionary contains a *key* using the `in` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Vipera palaestinae' in taxonomy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Bos taurus' in taxonomy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: secret\n",
    "\n",
    "Given in the code below is a dictionary (named `code`) where the keys represent encrypted characters and the values are the corresponding decrypted characters. Use the dictionary to decrypt an ecnrypted message (named `secret`) and print out the resulting cleartext message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "secret = \"\"\"Mq osakk le eh ue usq qhp, mq osakk xzlsu zh Xcahgq,\n",
    "mq osakk xzlsu eh usq oqao ahp egqaho,\n",
    "mq osakk xzlsu mzus lcemzhl gehxzpqhgq ahp lcemzhl oucqhlus zh usq azc, mq osakk pqxqhp ebc Zokahp, msauqjqc usq geou dat rq,\n",
    "mq osakk xzlsu eh usq rqagsqo,\n",
    "mq osakk xzlsu eh usq kahpzhl lcebhpo,\n",
    "mq osakk xzlsu zh usq xzqkpo ahp zh usq oucqquo,\n",
    "mq osakk xzlsu zh usq szkko;\n",
    "mq osakk hqjqc obccqhpqc, ahp qjqh zx, mszgs Z pe heu xec a dedqhu rqkzqjq, uszo Zokahp ec a kaclq iacu ex zu mqcq obrfblauqp ahp ouacjzhl, usqh ebc Qdizcq rqtehp usq oqao, acdqp ahp lbacpqp rt usq Rczuzos Xkqqu, mebkp gacct eh usq oucbllkq, bhuzk, zh Lep’o leep uzdq, usq Hqm Meckp, mzus akk zuo iemqc ahp dzlsu, ouqio xecus ue usq cqogbq ahp usq kzrqcauzeh ex usq ekp.\"\"\"\n",
    "\n",
    "code = {'w': 'x', 'L': 'G', 'c': 'r', 'x': 'f', 'G': 'C', 'E': 'O', 'h': 'n', 'O': 'S', 'y': 'q', 'R': 'B', 'd': 'm', 'f': 'j', 'i': 'p', 'o': 's', 'g': 'c', 'a': 'a', 'u': 't', 'k': 'l', 'q': 'e', 'r': 'b', 'V': 'Z', 'X': 'F', 'N': 'K', 'B': 'U', 'T': 'Y', 'M': 'W', 'U': 'T', 'm': 'w', 'C': 'R', 'J': 'V', 't': 'y', 'S': 'H', 'v': 'z', 'e': 'o', 'D': 'M', 'p': 'd', 'K': 'L', 'A': 'A', 'P': 'D', 'l': 'g', 's': 'h', 'W': 'X', 'H': 'N', 'j': 'v', 'z': 'i', 'I': 'P', 'b': 'u', 'Z': 'I', 'F': 'J', 'Y': 'Q', 'Q': 'E', 'n': 'k'}\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sets\n",
    "\n",
    "A [set](https://docs.python.org/3.5/tutorial/datastructures.html#sets) is an **unordered collection** with **unique elements**, similar to the mathematical concept of a [set](https://en.wikipedia.org/wiki/Set_%28mathematics%29) (קבוצה). \n",
    "\n",
    "Curly braces (`{}`) or the `set()` function can be used to create sets. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'pear', 'orange', 'apple', 'banana'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}\n",
    "print(basket) # duplicates have been removed\n",
    "type(basket)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic uses include eliminating duplicate entries (as above, one apple and one orange were eliminated), and fast membership testing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('orange' in basket)\n",
    "print('crabgrass' in basket)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set objects also support set-theoretical operations like union, intersection, difference, and symmetric difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a', 'd', 'c', 'r', 'b'}\n",
      "{'a', 'l', 'm', 'z', 'c'}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = set('abracadabra')\n",
    "b = set('alacazam')\n",
    "print(a)\n",
    "print(b)\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Letters in `a` but not in `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b', 'd', 'r'}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a - b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Letters in either `a` or `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c', 'd', 'l', 'm', 'r', 'z'}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a | b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Letters in both `a` and `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'c'}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a & b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Letters in `a` or `b` but not both:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b', 'd', 'l', 'm', 'r', 'z'}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a ^ b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create an empty set you have to use `set()`, not `{}`; the latter creates an empty dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ø = set()\n",
    "print(Ø)\n",
    "type(Ø)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that a `set` is mutable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a', 'd', 'c', 'r', 'b'}\n",
      "{'a', 'd', 'z', 'c', 'r', 'b'}\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "a.add('z')\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `frozenset`\n",
    "\n",
    "There is also a immutable set, called `frozenset`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'frozenset'> frozenset({'a', 'd', 'c', 'r', 'b'})\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'frozenset' object has no attribute 'add'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m-----------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0mTraceback (most recent call last)",
      "\u001b[0;32m<ipython-input-31-e575f812ee11>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfrozenset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'abracadabra'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'z'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'frozenset' object has no attribute 'add'"
     ]
    }
   ],
   "source": [
    "a = frozenset('abracadabra')\n",
    "print(type(a), a)\n",
    "a.add('z')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "We _define_ functions with the __def__ command.\n",
    "The general syntax is:\n",
    "\n",
    "```py\n",
    "def function_name(input1, input2, input3,...):\n",
    "    # some processes\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    return output1, output2, ...\n",
    "```\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply(x, y):\n",
    "    z = x * y\n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "y = multiply(x, 2)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n"
     ]
    }
   ],
   "source": [
    "z = multiply(7, 5)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: secret (2)\n",
    "\n",
    "Let's turn the code from the last exercise into a function.\n",
    "Write a function called `decrypt` that takes two arguments, `secret` and `code`, and returns a string which is the cleartext (decrypted) message. Then call the function to decrypt the secret from above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "secret = \"\"\"Mq osakk le eh ue usq qhp, mq osakk xzlsu zh Xcahgq,\n",
    "mq osakk xzlsu eh usq oqao ahp egqaho,\n",
    "mq osakk xzlsu mzus lcemzhl gehxzpqhgq ahp lcemzhl oucqhlus zh usq azc, mq osakk pqxqhp ebc Zokahp, msauqjqc usq geou dat rq,\n",
    "mq osakk xzlsu eh usq rqagsqo,\n",
    "mq osakk xzlsu eh usq kahpzhl lcebhpo,\n",
    "mq osakk xzlsu zh usq xzqkpo ahp zh usq oucqquo,\n",
    "mq osakk xzlsu zh usq szkko;\n",
    "mq osakk hqjqc obccqhpqc, ahp qjqh zx, mszgs Z pe heu xec a dedqhu rqkzqjq, uszo Zokahp ec a kaclq iacu ex zu mqcq obrfblauqp ahp ouacjzhl, usqh ebc Qdizcq rqtehp usq oqao, acdqp ahp lbacpqp rt usq Rczuzos Xkqqu, mebkp gacct eh usq oucbllkq, bhuzk, zh Lep’o leep uzdq, usq Hqm Meckp, mzus akk zuo iemqc ahp dzlsu, ouqio xecus ue usq cqogbq ahp usq kzrqcauzeh ex usq ekp.\"\"\"\n",
    "\n",
    "code = {'w': 'x', 'L': 'G', 'c': 'r', 'x': 'f', 'G': 'C', 'E': 'O', 'h': 'n', 'O': 'S', 'y': 'q', 'R': 'B', 'd': 'm', 'f': 'j', 'i': 'p', 'o': 's', 'g': 'c', 'a': 'a', 'u': 't', 'k': 'l', 'q': 'e', 'r': 'b', 'V': 'Z', 'X': 'F', 'N': 'K', 'B': 'U', 'T': 'Y', 'M': 'W', 'U': 'T', 'm': 'w', 'C': 'R', 'J': 'V', 't': 'y', 'S': 'H', 'v': 'z', 'e': 'o', 'D': 'M', 'p': 'd', 'K': 'L', 'A': 'A', 'P': 'D', 'l': 'g', 's': 'h', 'W': 'X', 'H': 'N', 'j': 'v', 'z': 'i', 'I': 'P', 'b': 'u', 'Z': 'I', 'F': 'J', 'Y': 'Q', 'Q': 'E', 'n': 'k'}\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Documenting your functions\n",
    "\n",
    "Documenting functions is done by adding a *docstring* element below the function definition. Docstrings are enclosed by `\"\"\"`. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decrypt(secret, code):\n",
    "    \"\"\"Decrypt a message using a substitution code.\n",
    "    \n",
    "    The function only decrypts characters that appear in `code`; other characters remain as they appear in `secret`.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    secret : str\n",
    "        an encrypted message\n",
    "    code : dict\n",
    "        a substitution code, where the keys are encrypted characters and the values are the cleartext characters.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    str\n",
    "        the decrypted cleartext message.\n",
    "    \"\"\"\n",
    "    return ''.join(code.get(c, c) for c in secret) # this is advanced python code\n",
    "print(decrypt(secret, code))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can easily access the documentation of a function using the `help()` command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function decrypt in module __main__:\n",
      "\n",
      "decrypt(secret, code)\n",
      "    Decrypt a message using a substitution code.\n",
      "    \n",
      "    The function only decrypts characters that appear in `code`; other characters remain as they appear in `secret`.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    secret : str\n",
      "        an encrypted message\n",
      "    code : dict\n",
      "        a substitution code, where the keys are encrypted characters and the values are the cleartext characters.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    str\n",
      "        the decrypted cleartext message.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(decrypt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Colophon\n",
    "This notebook was written by [Yoav Ram](http://python.yoavram.com) and is part of the [_Scientific Computing with Python_](https://scicompy.yoavram.com/) course at IDC Herzliya.\n",
    "\n",
    "The notebook was written using [Python](http://python.org/) 3.6.5.\n",
    "Dependencies listed in [environment.yml](../environment.yml).\n",
    "\n",
    "This work is licensed under a CC BY-NC-SA 4.0 International License.\n",
    "\n",
    "![Python logo](https://www.python.org/static/community_logos/python-logo.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:SciComPy]",
   "language": "python",
   "name": "conda-env-SciComPy-py"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}