intro_to_python/0a-Intro_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A short intro to Python\n",
    "=======================\n",
    "\n",
    "`\n",
    "Author : Alexandre Gramfort\n",
    "`\n",
    "\n",
    "based on the work of J.R. Johansson (robert@riken.jp) http://dml.riken.jp/~rob/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is Python?\n",
    "---------------\n",
    "\n",
    "[Python](http://www.python.org/) is a modern, general-purpose, object-oriented, high-level programming language.\n",
    "\n",
    "General characteristics of Python:\n",
    "\n",
    "* **clean and simple language:** Easy-to-read and intuitive code, easy-to-learn minimalistic syntax, maintainability scales well with size of projects\n",
    "* **expressive language:** Fewer lines of code, fewer bugs, easier to maintain.\n",
    "\n",
    "Technical details:\n",
    "\n",
    "* **dynamically typed:** No need to define the type of variables, function arguments or return types.\n",
    "* **automatic memory management:** No need to explicitly allocate and deallocate memory for variables and data arrays. No memory leak bugs. \n",
    "* **interpreted:** No need to compile the code. The Python interpreter reads and executes the python code directly.\n",
    "\n",
    "Advantages:\n",
    "\n",
    "* **Ease of programming**: minimize development time, debug and code maintainance.\n",
    "* **Encourage good programming practices**:\n",
    " * Modular, *relatively* good system for packaging and re-use of code.\n",
    " * Documentation tightly integrated with the code.\n",
    " * Forces code indentation\n",
    "* A **large standard library**, and a **large collection of add-on packages**.\n",
    "\n",
    "Disadvantages:\n",
    "\n",
    "* Since Python is an **interpreted** and **dynamically typed** programming language, the execution of python can be code slow compared to compiled statically typed programming languages, such as C and Fortran. \n",
    "* Somewhat decentralized, with different environment, packages and documentation spread out at different places. Can make it harder to get started."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What makes python suitable for scientific computing?\n",
    "----------------------------------------------------\n",
    "\n",
    "<img src=\"https://raw.github.com/jrjohansson/scientific-python-lectures/master/images/optimizing-what.png\" width=\"600\">\n",
    "\n",
    "* Python has a strong position in scientific computing: \n",
    "    * Large community of users, easy to find help and documentation.\n",
    "\n",
    "* Extensive ecosystem of scientific libraries and environments\n",
    "    * numpy: http://numpy.scipy.org - Numerical Python\n",
    "    * scipy: http://www.scipy.org -  Scientific Python\n",
    "    * matplotlib: http://www.matplotlib.org - graphics library\n",
    "\n",
    "* Great performance due to close integration with time-tested and highly optimized codes written in C and Fortran:\n",
    "    * blas, altas blas, lapack, arpack, Intel MKL, ...\n",
    "\n",
    "* Good support for \n",
    "    * Parallel processing with processes and threads (have a look at http://pythonhosted.org/joblib/)\n",
    "    * Interprocess communication (MPI)\n",
    "    * GPU computing (OpenCL and CUDA)\n",
    "\n",
    "* Readily available and suitable for use on high-performance computing clusters. \n",
    "\n",
    "* No license costs, no unnecessary use of research budget."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python interpreter\n",
    "\n",
    "The standard way to use Python is via the Python interpreter. It is a program that reads and executes the python code in files passed to it as arguments. At the command prompt, the command ``python`` is used to invoke the Python interpreter.\n",
    "\n",
    "For example, to run a file ``my_program.py`` that contains python code from the command prompt, use::\n",
    "\n",
    "    $ python my_program.py\n",
    "\n",
    "We can also start the interpreter by simply typing ``python`` at the command line, and interactively type python code into the interpreter. \n",
    "\n",
    "<!-- <img src=\"files/images/python-screenshot.jpg\" width=\"600\"> -->\n",
    "<img src=\"https://raw.github.com/jrjohansson/scientific-python-lectures/master/images/python-screenshot.jpg\" width=\"600\">\n",
    "\n",
    "**Works but not good enough** when developing scientific applications...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IPython\n",
    "\n",
    "IPython is a powerful and user friendly interactive shell.\n",
    "\n",
    "<!-- <img src=\"files/images/ipython-screenshot.jpg\" width=\"600\"> -->\n",
    "<img src=\"https://raw.github.com/jrjohansson/scientific-python-lectures/master/images/ipython-screenshot.jpg\" width=\"600\">\n",
    "\n",
    "Some of the many useful features of IPython includes:\n",
    "\n",
    "* Command history, which can be browsed with the up and down arrows on the keyboard.\n",
    "* Tab auto-completion.\n",
    "* In-line editing of code.\n",
    "* Object introspection, and automatic extract of documentation strings from python objects like classes and functions.\n",
    "* Good interaction with operating system shell.\n",
    "* Support for multiple parallel back-end processes, that can run on computing clusters or cloud services like Amazon EE2.\n",
    "\n",
    "WATCH : https://www.youtube.com/watch?v=2G5YTlheCbw\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IPython notebook (jupyter)\n",
    "--------------------------\n",
    "\n",
    "[IPython notebook](<http://ipython.org/ipython-doc/dev/interactive/htmlnotebook.html/) is an HTML-based notebook environment for Python, similar to Mathematica or Maple.\n",
    "\n",
    "<!-- <img src=\"files/images/ipython-notebook-screenshot.jpg\" width=\"800\"> -->\n",
    "<img src=\"https://raw.github.com/jrjohansson/scientific-python-lectures/master/images/ipython-notebook-screenshot.jpg\" width=\"800\">\n",
    "\n",
    "To start a new IPython Jupyter notebook session, run the following command:\n",
    "\n",
    "    $ jupyter notebook\n",
    "\n",
    "from a directory where you want the notebooks to be stored. This will open a new browser window (or a new tab in an existing window) with an index page where existing notebooks are shown and from which new notebooks can be created."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spyder\n",
    "------\n",
    "\n",
    "[Spyder](http://code.google.com/p/spyderlib/) is a MATLAB-like IDE for scientific computing with python. It has the many advantages of a traditional IDE environment, for example that everything from code editing, execution and debugging is carried out in a single environment, and work on different calculations can be organized as projects in the IDE environment.\n",
    "\n",
    "<!-- <img src=\"files/images/spyder-screenshot.jpg\" width=\"800\"> -->\n",
    "<img src=\"https://raw.github.com/jrjohansson/scientific-python-lectures/master/images/spyder-screenshot.jpg\" width=\"800\">\n",
    "\n",
    "Some advantages of Spyder:\n",
    "\n",
    "* Powerful code editor, with syntax high-lighting, dynamic code introspection and integration with the python debugger.\n",
    "* Variable explorer, IPython command prompt.\n",
    "* Integrated documentation and help."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyCharm\n",
    "-------\n",
    "\n",
    "[PyCharm](http://www.jetbrains.com/pycharm/) is a powerful IDE dedicated to Python (free since version 3).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(filename='images/pycharm-screenshot.jpg', width=800)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Versions of Python\n",
    "\n",
    "There are still currently two versions of python: Python 2 and Python 3. Python 3 is now the standard.\n",
    "\n",
    "To see which version of Python you have, run\n",
    "    \n",
    "    $ python --version\n",
    "    Python 2.7.15\n",
    "\n",
    "    $ python3 --version\n",
    "    Python 3.6.7\n",
    "\n",
    "Several versions of Python can be installed in parallel, as shown above.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation\n",
    "\n",
    "*Anaconda* (recommended)\n",
    "\n",
    "See http://www.continuum.io/downloads"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python program files\n",
    "\n",
    "* Python code is usually stored in text files with the file ending \"`.py`\":\n",
    "\n",
    "        myprogram.py\n",
    "\n",
    "* Every line in a Python program file is assumed to be a Python statement, or part thereof. \n",
    "\n",
    "    * The only exception is comment lines, which start with the character `#` (optionally preceded by an arbitrary number of white-space characters, i.e., tabs or spaces). Comment lines are usually ignored by the Python interpreter.\n",
    "\n",
    "\n",
    "* To run our Python program from the command line we use:\n",
    "\n",
    "        $ python myprogram.py\n",
    "\n",
    "* On UNIX systems it is common to define the path to the interpreter on the first line of the program (note that this is a comment line as far as the Python interpreter is concerned):\n",
    "\n",
    "        #!/usr/bin/env python\n",
    "\n",
    "  If we do, and if we additionally set the file script to be executable, we can run the program like this:\n",
    "\n",
    "        $ ./myprogram.py\n",
    "\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls scripts/hello-world*.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cat scripts/hello-world.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python scripts/hello-world.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Character encoding\n",
    "\n",
    "The standard character encoding is ASCII, but we can use any other encoding, for example UTF-8. To specify that UTF-8 is used we include the special line\n",
    "\n",
    "    # -*- coding: UTF-8 -*-\n",
    "\n",
    "at the top of the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cat scripts/hello-world-in-french.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python scripts/hello-world-in-french.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other than these two *optional* lines in the beginning of a python code file, no additional code is required for for initializing a program. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IPython notebooks\n",
    "\n",
    "This document is not a .py file but an IPython notebook stored as a file in the [JSON](http://en.wikipedia.org/wiki/JSON) format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Playing with numbers\n",
    "--------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6 * 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 4  # assign value 4 to variable a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(a)  # what is the type of a?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variable names in Python can contain alphanumerical characters `a-z`, `A-Z`, `0-9` and some special characters such as `_`. Normal variable names must start with a letter. \n",
    "\n",
    "By convension, variable names start with a lower-case letter, and Class names start with a capital letter. \n",
    "\n",
    "In addition, there are a number of Python keywords that cannot be used as variable names. These keywords are:\n",
    "\n",
    "    and, as, assert, break, class, continue, def, del, elif, else, except, \n",
    "    exec, finally, for, from, global, if, import, in, is, lambda, not, or,\n",
    "    pass, print, raise, return, try, while, with, yield\n",
    "\n",
    "Note: Be aware of the keyword **lambda**, which could easily be a natural variable name in a scientific program. But being a keyword, it cannot be used as a variable name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# int a = 1;  # in C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 2.1\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1.5 + 0.5j\n",
    "print(a.real)\n",
    "print(a.imag)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 < 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "test = (3 > 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7 * 3.  # int x float -> float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 ** 10  # exponent (^ in Matlab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "8 % 3  # modulo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**WARNING**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 // 2  # !!!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 / 2.  # OK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 / float(2)  # OK too"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules\n",
    "\n",
    "Most of the functionality in Python is provided by *modules*.\n",
    "\n",
    "The Python Standard Library is a large collection of modules to access the operating system, do file I/O, string management, network communication, and much more.\n",
    "\n",
    "### References\n",
    " \n",
    " * The Python Language Reference: http://docs.python.org/2/reference/index.html\n",
    " * The Python Standard Library: http://docs.python.org/2/library/\n",
    "\n",
    "To use a module in a python program it first has to be imported. A module can be imported using the `import` statement. For example, to import the module `math`, which contains many standard mathematical functions, we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This includes the whole module and makes it available for use later in the program. For example, we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "print(math.cos(2 * math.pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we can chose to import all symbols (functions and variables) in a module to the current namespace (so that we don't need to use the prefix \"`math.`\" every time we use something from the `math` module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *\n",
    "\n",
    "x = cos(2 * pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is pattern can be very convenient, but in large programs that include many modules it is often a good idea to keep the symbols from each module in their own namespaces, by using the `import math` pattern. This would elminate potentially confusing problems with name space collisions.\n",
    "\n",
    "As a third alternative, we can chose to import only a few selected symbols from a module by explicitly listing which ones we want to import instead of using the wildcard character `*`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import cos, pi\n",
    "\n",
    "x = cos(2 * pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looking at what a module contains, and its documentation\n",
    "\n",
    "Once a module is imported, we can list the symbols it provides using the `dir` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "print(dir(math))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And using the funciton **`help`** we can get a description of each function (most functions have docstrings). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(math.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### or with IPython use **\"?\"**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "math.exp?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "math.log?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.log(10, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.ceil(2.7)  # round to the next integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the `help` function directly on modules: Try\n",
    "\n",
    "    help(math) \n",
    "\n",
    "Some very useful modules form the Python standard library are `os`, `sys`, `math`, `shutil`, `re`, `subprocess`, `multiprocessing`, `threading`. \n",
    "\n",
    "A complete lists of standard modules for Python 2 and Python 3 are available at http://docs.python.org/2/library/ and http://docs.python.org/3/library/, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EXCERCISE : Calculate the next power of 2 of a number n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n = 1234\n",
    "# new_pow2 = "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More on Types\n",
    "\n",
    "Test if variables are of certain types:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the `isinstance` method for testing types of variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1.1\n",
    "isinstance(x, float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Type casting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = float(x)  # cast as float\n",
    "print(y, type(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 1j\n",
    "float(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complex variables **cannot be cast** to floats or integers:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators and comparisons\n",
    "\n",
    "Most operators and comparisons in Python work as one would expect:\n",
    "\n",
    "* Arithmetic operators `+`, `-`, `*`, `/`, `//` (integer division), '**' power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1*2, 1+1, 1*3, 3//2, 2**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 // 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(3 < 2) or (4 == 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Comparison operators `>`, `<`, `>=` (greater or equal), `<=` (less or equal), `==` equality, `is` identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 > 1, 2 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 > 2, 2 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 >= 2, 2 <= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# equality\n",
    "1 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# objects identical?\n",
    "a = b = 'hi'\n",
    "\n",
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compound types: Strings, List and dictionaries\n",
    "\n",
    "### Strings\n",
    "\n",
    "Strings are the variable type that is used for storing text messages. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Hello world\"\n",
    "# or\n",
    "s = 'Hello world'\n",
    "print(type(s))\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# length of the string: the number of characters\n",
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# replace a substring in a string with somethign else\n",
    "s2 = s.replace(\"world\", \"test\")\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index a character in a string using `[]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Heads up MATLAB users:** Indexing start at 0!\n",
    "\n",
    "We can use extract a part of a string using the syntax `[start:stop]`, which extracts characters between index `start` and `stop`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start, stop = 0, 5\n",
    "print(s[start:stop])\n",
    "print(s[0:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(s[start:stop]))\n",
    "print(stop - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(s[2:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(s) - 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we omit either (or both) of `start` or `stop` from `[start:stop]`, the default is the beginning and the end of the string, respectively:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[6:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also define the step size using the syntax `[start:stop:step]` (the default value for `step` is 1, as we saw above):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[::1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This technique is called *slicing*. Read more about the syntax here: http://docs.python.org/release/2.7.3/library/functions.html?highlight=slice#slice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a very rich set of functions for text processing. See for example http://docs.python.org/2/library/string.html for more information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EXERCISE : Given a string s defined below. Make it lower case and replace any occurance of 'o' with 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"HeLlO wOrLd!\"\n",
    "# TODO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('-' * 80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String formatting examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"str1\", \"str2\", \"str3\")  # The print statement concatenates strings with a space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"str1\", 1.0, False, -1j)  # The print statements converts all arguments to strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"str1\" + \"str2\" + \"str3\") # strings added with + are concatenated without space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"str1\" * 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"value = %f\" % 1.0)       # we can use C-style string formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"value = %1.2f\" % 1.0)       # we can use C-style string formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "subject_nb = 3\n",
    "print(\"subject%03d\" % subject_nb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this formatting creates a string\n",
    "s = \"value1 = %.2f. value2 = %d\" % (3.1415, 1.5)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this formatting creates a string\n",
    "s = \"value1 = %s. value2 = %s\" % (3.1415, 1.5)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# alternative, more intuitive way of formatting a string \n",
    "s = 'value1 = {0}, value2 = {1}'.format(3.1415, 1.5)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List\n",
    "\n",
    "Lists are very similar to strings, except that each element can be of any type.\n",
    "\n",
    "The syntax for creating lists in Python is `[...]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, 3, 4]\n",
    "\n",
    "print(type(l))\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the same slicing techniques to manipulate lists as we could use on strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[1::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(l)\n",
    "print(l[1:3])\n",
    "print(l[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Heads up MATLAB users:** Indexing starts at 0!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elements in a list do not all have to be of the same type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 'a', 1.0, 1-1j]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python lists can be inhomogeneous and arbitrarily nested:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nested_list = [1, [2, [3, [4, [5]]]]]\n",
    "nested_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists play a very important role in Python, and are for example used in loops and other flow control structures (discussed below). There are number of convenient functions for generating lists of various types, for example the `range` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(1, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = 10\n",
    "stop = 30\n",
    "step = 2\n",
    "list(range(start, stop, step))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(-10, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert a string to a list by type casting:\n",
    "s2 = list(\"hello\")\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sorting lists (inplace)\n",
    "s2.sort()\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to return a sorted copy use \"sorted\"\n",
    "s2 = list(\"hello\")\n",
    "s3 = sorted(s2)\n",
    "print(s2)\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding, inserting, modifying, and removing elements from lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a new empty list\n",
    "l = []\n",
    "\n",
    "# add an elements using `append`\n",
    "l.append(\"A\")  # same as : l += [\"A\"]\n",
    "l.append(\"d\")\n",
    "l.append(\"d\")\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can modify lists by assigning new values to elements in the list. In technical jargon, lists are *mutable*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[1] = \"p\"\n",
    "l[2] = \"p\"\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[1:3] = [\"d\", \"d\"]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert at element a specific index using `insert`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l.insert(0, \"i\")\n",
    "l.insert(1, \"n\")\n",
    "l.insert(2, \"s\")\n",
    "l.insert(3, \"e\")\n",
    "l.insert(4, \"r\")\n",
    "l.insert(5, \"t\")\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove first element with specific value using 'remove'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l.remove(\"A\")\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove an element at a specific location using `del`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del l[7]\n",
    "del l[6]\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List concatenation with '+'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l + l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See `help(list)` for more details, or read the online documentation "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Tuples are like lists, except that they cannot be modified once created, that is they are *immutable*. \n",
    "\n",
    "In Python, tuples are created using the syntax `(..., ..., ...)`, or even `..., ...`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "point = (10, 20)\n",
    "\n",
    "print(point, type(point))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "point = 10, 20\n",
    "\n",
    "print(point, type(point))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can unpack a tuple by assigning it to a comma-separated list of variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = point\n",
    "\n",
    "print(\"x =\", x)\n",
    "print(\"y =\", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to assign a new value to an element in a tuple we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "point[0] = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "Dictionaries are also like lists, except that each element is a key-value pair. The syntax for lists are `{key1 : value1, ...}`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = {\"parameter1\" : 1.0,\n",
    "          \"parameter2\" : 2.0,\n",
    "          \"parameter3\" : 3.0,}\n",
    "\n",
    "# or equivalent\n",
    "\n",
    "params = dict(parameter1=1.0, parameter2=2.0, parameter3=3.0)\n",
    "\n",
    "print(type(params))\n",
    "print(params)  # what do you observed about the order of keys?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"parameter1 =\", params[\"parameter1\"])\n",
    "print(\"parameter2 =\", params[\"parameter2\"])\n",
    "print(\"parameter3 =\", params[\"parameter3\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params[\"parameter1\"] = \"A\"\n",
    "params[\"parameter2\"] = \"B\"\n",
    "\n",
    "# add a new entry\n",
    "params[\"parameter4\"] = \"D\"\n",
    "\n",
    "print(\"parameter1 =\", params[\"parameter1\"])\n",
    "print(\"parameter2 =\", params[\"parameter2\"])\n",
    "print(\"parameter3 =\", params[\"parameter3\"])\n",
    "print(\"parameter4 =\", params[\"parameter4\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"parameter1\" in params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params[\"parameter5\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# delete a key\n",
    "del params[\"parameter3\"]\n",
    "print(params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_runs_per_subjects = {'subj1': {'age': 34, 'n_runs': 4}, 'subj2': {'age': 32, 'n_runs': 3}}\n",
    "n_runs_per_subjects['subj1']['age']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{1: 'subj1', 2: 'subj2'}[1][-1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional statements: if, elif, else\n",
    "\n",
    "The Python syntax for conditional execution of code use the keywords `if`, `elif` (else if), `else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statement1 = False\n",
    "statement2 = False\n",
    "\n",
    "if statement1:  # PAY ATTENTION TO THE :\n",
    "    print(\"statement1 is True\")  # INDENTATION IS MANDATORY\n",
    "elif statement2:\n",
    "    print(\"statement2 is True\")\n",
    "else:\n",
    "    print(\"statement1 and statement2 are False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, the extent of a code block is defined by the indentation level (ideally four white spaces). This means that we have to **be careful to indent our code correctly**, or else we will get syntax errors. \n",
    "\n",
    "**Examples:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statement1 = statement2 = True\n",
    "\n",
    "if statement1:\n",
    "    if statement2:\n",
    "        print(\"both statement1 and statement2 are True\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bad indentation!\n",
    "if statement1:\n",
    "    if statement2:\n",
    "    print(\"both statement1 and statement2 are True\") # this line is not properly indented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "statement1 = False \n",
    "\n",
    "if statement1:\n",
    "    print(\"printed if statement1 is True\")\n",
    "    \n",
    "    print(\"still inside the if block\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if statement1:\n",
    "    print(\"printed if statement1 is True\")\n",
    "    \n",
    "print(\"now outside the if block\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "\n",
    "In Python, loops can be programmed in a number of different ways. The most common is the `for` loop, which is used together with iterable objects, such as lists. The basic syntax is:\n",
    "\n",
    "\n",
    "**`for` loops**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in [1, 2, 3]:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `for` loop iterates over the elements of the supplied list, and executes the containing block once for each element. Any kind of list can be used in the `for` loop. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(4): # by default range start at 0\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: `range(4)` does not include 4 !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(-3,3):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for word in [\"scientific\", \"computing\", \"with\", \"python\"]:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for subj in [\"subj1\", \"subj2\", \"subj3\"]:\n",
    "    print('do something for subject %s' % subj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for subj in \"subj1\":\n",
    "    print('do something for subject %s' % subj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in 'Hello world!':\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To iterate over key-value pairs of a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key, value in params.items():\n",
    "    print(key, \" = \", value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "n_runs_per_subjects = {'subj1': 4, 'subj2': 3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for subj, n_runs in n_runs_per_subjects.items():\n",
    "    print(\"There is %d runs for subject %s\" % (n_runs, subj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes it is useful to have access to the indices of the values when iterating over a list. We can use the `enumerate` function for this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, x in enumerate(range(-3,3)):\n",
    "    print(idx, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EXERCISE :\n",
    "\n",
    "* Given a string e.g. \"HelLO world!!\", compute the number of occurence of each letter (capital or not).\n",
    "* HINT : Iterate over lower case letters and use a dictionnary to count\n",
    "* HINT : str object has a lower method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = \"HelLO world!!\"\n",
    "# ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**List comprehensions: Creating lists using `for` loops**:\n",
    "\n",
    "A convenient and compact way to initialize lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [x**2 for x in range(0,5) if x % 2 == 0]\n",
    "\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`while` loops**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "\n",
    "while i < 5:\n",
    "    print(i)\n",
    "    \n",
    "    i = i + 1\n",
    "    \n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the `print \"done\"` statement is not part of the `while` loop body because of the difference in indentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "A function in Python is defined using the keyword `def`, followed by a function name, a signature within parenthises `()`, and a colon `:`. The following code, with one additional level of indentation, is the function body."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def func0():\n",
    "    print(\"test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func0()\n",
    "out = func0()\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optionally, but highly recommended, we can define a so called \"docstring\", which is a description of the functions purpose and behaivor. The docstring should follow directly after the function definition, before the code in the function body."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def func1(s):\n",
    "    \"\"\"\n",
    "    Print a string 's' and tell how many characters it has    \n",
    "    \"\"\"\n",
    "    print(s, \"has\", len(s), \"characters\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(func1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "func1?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func1(\"test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func1([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions that returns a value use the `return` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    \"\"\"\n",
    "    Return the square of x.\n",
    "    \"\"\"\n",
    "    return x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "square(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can return multiple values from a function using tuples (see above):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def powers(x):\n",
    "    \"\"\"\n",
    "    Return a few powers of x.\n",
    "    \"\"\"\n",
    "    return x ** 2, x ** 3, x ** 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "powers(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(powers(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x2, x3, x4 = powers(3)\n",
    "print(x3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EXERCISE : Write the factorial function fact(n) = n * (n-1) * (n-2) ... 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fact(n):\n",
    "    # TODO\n",
    "    return None\n",
    "\n",
    "print(fact(5))\n",
    "print(math.factorial(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default argument and keyword arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def myfunc(x, p=2, debug=False):  # debug has a default value = False\n",
    "    if debug:\n",
    "        print(\"evaluating myfunc for x =\", x, \"using exponent p =\", p)\n",
    "    return x**p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we don't provide a value of the `debug` argument when calling the the function `myfunc` it defaults to the value provided in the function definition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunc(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunc(5, debug=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *keyword* arguments : If we explicitly list the name of the arguments in the function calls, they do not need to come in the same order as in the function definition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunc(p=3, debug=True, x=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EXERCISE : implement Quicksort\n",
    "\n",
    "The [wikipedia page](http://en.wikipedia.org/wiki/Quicksort) describes the quicksort algorithm in pseudo-code:\n",
    "\n",
    "    function quicksort('array')\n",
    "       if length('array') <= 1\n",
    "            return 'array'\n",
    "       select and remove a pivot value 'pivot' from 'array'\n",
    "       create empty lists 'less' and 'greater'\n",
    "       for each 'x' in 'array'\n",
    "           if 'x' <= 'pivot' then append 'x' to 'less'\n",
    "           else append 'x' to 'greater'\n",
    "       return concatenate(quicksort('less'), 'pivot', quicksort('greater'))\n",
    "\n",
    "Convert this pseudo-code in valid Python code.\n",
    "\n",
    "**Hints**:\n",
    "\n",
    "- the length of a list is obtained with `len(l)`\n",
    "\n",
    "- two lists can be concatenated with `l1 + l2`\n",
    "\n",
    "- `l.pop()` removes the last element from a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes\n",
    "\n",
    "Classes are the key features of object-oriented programming. A class is a structure for representing an object and the operations that can be performed on the object. \n",
    "\n",
    "In Python a class can contain *attributes* (variables) and *methods* (functions).\n",
    "\n",
    "In python a class are defined almost like a functions, but using the `class` keyword, and the class definition usually contains a number of class method definitions (a function in a class).\n",
    "\n",
    "* Each class method should have an argurment `self` as it first argument. This object is a self-reference.\n",
    "\n",
    "* Some class method names have special meaning, for example:\n",
    "\n",
    " * `__init__`: The name of the method that is invoked when the object is first created.\n",
    " * `__str__` : A method that is invoked when a simple string representation of the class is needed, as for example when printed.\n",
    " * There are many more, see http://docs.python.org/2/reference/datamodel.html#special-method-names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Point(object):\n",
    "    \"\"\"\n",
    "    Simple class for representing a point in a Cartesian coordinate system.\n",
    "    \"\"\"\n",
    "    def __init__(self, x, y):\n",
    "        \"\"\"\n",
    "        Create a new Point at x, y.\n",
    "        \"\"\"\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def translate(self, dx, dy):\n",
    "        \"\"\"\n",
    "        Translate the point by dx and dy in the x and y direction.\n",
    "        \"\"\"\n",
    "        self.x += dx\n",
    "        self.y += dy\n",
    "    \n",
    "    def __add__(self, point):\n",
    "        return Point(self.x + point.x, self.y + point.y)\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"Point at [%f, %f]\" % (self.x, self.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To create a new instance of a class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Point(0, 0) # this will invoke the __init__ method in the Point class\n",
    "print(p1)         # this will invode the __str__ method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To invoke a class method in the class instance `p`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1.translate(0.25, 1.5)\n",
    "print(p1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Point(0, 0)\n",
    "p2 = Point(1, 1)\n",
    "print(p1 + p2)\n",
    "print(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that calling class methods can modifiy the state of the that particular class instance, but does not effect other class instances or any global variables.\n",
    "\n",
    "That is one of the nice things about object-oriented design: code such as functions and related variables are group in separate and independent entities. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exceptions\n",
    "\n",
    "In Python errors are managed with a special language construct called \"Exceptions\". When errors occur exceptions can be raised, which interrupts the normal program flow and fallback to somewhere else in the code where the closest try-except statements is defined.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To generate an exception we can use the `raise` statement, which takes an argument that must be an instance of the class `BaseExpection` or a class dervied from it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raise Exception(\"description of the error\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A typical use of exceptions is to abort functions when some error condition occurs, for example:\n",
    "\n",
    "    def my_function(arguments):\n",
    "    \n",
    "        if not verify(arguments):\n",
    "            raise Expection(\"Invalid arguments\")\n",
    "        \n",
    "        # rest of the code goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To gracefully catch errors that are generated by functions and class methods, or by the Python interpreter itself, use the `try` and  `expect` statements:\n",
    "\n",
    "    try:\n",
    "        # normal code goes here\n",
    "    except:\n",
    "        # code for error handling goes here\n",
    "        # this code is not executed unless the code\n",
    "        # above generated an error\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print \"test\"\n",
    "    # generate an error: the variable test is not defined\n",
    "    print(test)\n",
    "except:\n",
    "    print(\"Caught an expection\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get information about the error, we can access the `Expection` class instance that describes the exception by using for example:\n",
    "\n",
    "    except Exception as e:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"test\")\n",
    "    # generate an error: the variable test is not defined\n",
    "    print(test)\n",
    "except Exception as e:\n",
    "    print(\"Caught an expection:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further reading\n",
    "\n",
    "* http://www.python.org/dev/peps/pep-0008 - Style guide for Python programming. Highly recommended. \n",
    "* http://www.greenteapress.com/thinkpython/ - A free book on Python programming.\n",
    "* [Python Essential Reference](http://www.amazon.com/Python-Essential-Reference-4th-Edition/dp/0672329786) - A good reference book on Python programming.\n",
    "* http://learnpythonthehardway.org\n",
    "* http://en.wikibooks.org/wiki/Python_Programming\n",
    "* http://scipy-lectures.github.io"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.8 ('mne_aix')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "96118219f514f0f7c28e51c58abb2aa3e9c527721ceabff83c3dd194a32d9fc1"
   }
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}