Lecture 00_Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center><font color=navy>Algorithmic Trading with Python</font></center>\n",
    "### <center>Introduction to Python Programming</center>\n",
    "#### <center>Ali Habibnia</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Python](http://www.python.org/) is a modern, general-purpose, object-oriented, high-level programming language.\n",
    "\n",
    "\n",
    "<img src=\"images/highlow.png\" width=\"500\">\n",
    "\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",
    "\n",
    "<img src=\"images/hello.png\" width=\"550\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "* The main advantage is ease of programming, minimizing the time required to develop, debug and maintain the code.\n",
    "* Well designed language that encourage many good programming practices:\n",
    " * Modular and object-oriented programming, good system for packaging and re-use of code. This often results in more transparent, maintainable and bug-free code.\n",
    " * Documentation tightly integrated with the code.\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 code can be slow compared to compiled statically typed programming languages, such as C and Fortran.   <font color=red>(Create an exe from Python with [py2exe](http://www.py2exe.org), C-like performance with [Cython](https://cython.org/))</font>\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?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"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",
    "* Good support for \n",
    "    * Parallel processing with processes and threads\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.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python environments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many different environments through which the python interpreter can be used. Each environment has different advantages and is suitable for different workflows. One strength of python is that it is versatile and can be used in complementary ways, but it can be confusing for beginners so we will start with a brief survey of python environments that are useful for scientific computing.\n",
    "\n",
    "*** Comparison of integrated development environments IDEs *** (https://en.wikipedia.org/wiki/Comparison_of_integrated_development_environments#Python)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python interpreter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The standard way to use the Python programming language is to use the Python interpreter to run python code. At the command prompt in Windows or terminal in Mac (terminal (shell) in Linux) , 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=\"images/python-screenshot.jpg\" width=\"600\">\n",
    "\n",
    "\n",
    "This is often how we want to work when developing scientific applications, or when doing small calculations. But the standard python interpreter is not very convenient for this kind of work, due to a number of limitations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IPython"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IPython is an interactive shell that addresses the limitation of the standard python interpreter, and it is a work-horse for scientific use of python. It provides an interactive prompt to the python interpreter with a greatly improved user-friendliness.\n",
    "\n",
    "<!-- <img src=\"files/images/ipython-screenshot.jpg\" width=\"600\"> -->\n",
    "<img src=\"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 EC2.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IPython notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[IPython notebook](http://ipython.org/notebook.html) is an HTML-based notebook environment for Python, similar to Mathematica or Maple. It is based on the IPython shell, but provides a cell-based environment with great interactivity, where calculations can be organized and documented in a structured way.\n",
    "\n",
    "<!-- <img src=\"files/images/ipython-notebook-screenshot.jpg\" width=\"800\"> -->\n",
    "<img src=\"images/ipython-notebook-screenshot.jpg\" width=\"800\">\n",
    "\n",
    "Although using a web browser as graphical interface, IPython notebooks are usually run locally, from the same computer that run the browser. To start a new IPython notebook session, run the following command:\n",
    "\n",
    "    $ ipython 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": [
    "### Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Jupyter Notebook is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and narrative text.\n",
    "\n",
    "\n",
    "\n",
    "<!-- <img src=\"files/images/ipython-notebook-screenshot.jpg\" width=\"800\"> -->\n",
    "<img src=\"images/jupyter-screenshot.png\" width=\"700\">\n",
    "\n",
    "\n",
    "\n",
    "The Notebook has support for over 40 programming languages, including Python, R, Julia, and Scala. This file - an/a Ipython/Jupyter notebook -  does not follow the standard pattern with Python code in a text file. Instead, a notebook is stored as a file in the [JSON](http://en.wikipedia.org/wiki/JSON) format. The advantage is that we can mix formatted text, Python code and code output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Spyder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[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=\"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": [
    "## Versions of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are currently two versions of python: Python 2 and Python 3. Python 3 will eventually supercede Python 2, but it is not backward-compatible with Python 2. A lot of existing python code and packages has been written for Python 2, and it is still the most wide-spread version. For these lectures either version will be fine, but it is probably easier to stick with Python 2 for now, because it is more readily available via prebuilt packages and binary installers.\n",
    "\n",
    "To see which version of Python you have, run\n",
    "    \n",
    "    $ python --version\n",
    "    Python 2.7.3\n",
    "    $ python3.2 --version\n",
    "    Python 3.2.3\n",
    "\n",
    "Several versions of Python can be installed in parallel, as shown above.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.10.0\n"
     ]
    }
   ],
   "source": [
    "! python --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Anaconda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The best way set-up an scientific Python environment is to use the cross-platform package manager `Anaconda`. First download and install from https://www.anaconda.com . Anaconda includes conda, conda-build, Python, and over 150 automatically installed scientific packages and their dependencies. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Ubuntu Linux, to installing python and all the requirements run:\n",
    "\n",
    "    $ sudo apt-get install python ipython ipython-notebook\n",
    "$ sudo apt-get install python-numpy python-scipy python-matplotlib python-sympy\n",
    "    $ sudo apt-get install spyder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MacOS X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Macports*\n",
    "\n",
    "Python is included by default in Mac OS X, but for our purposes it will be useful to install a new python environment using [Macports](http://www.macports.org/), because it makes it much easier to install all the required additional packages. Using Macports, we can install what we need with:\n",
    "\n",
    "    $ sudo port install py36-ipython +pyside+notebook+parallel+scientific\n",
    "    $ sudo port install py36-scipy py36-matplotlib py36-sympy\n",
    "    $ sudo port install py36-spyder\n",
    "\n",
    "These will associate the commands `python` and `ipython` with the versions installed via macports (instead of the one that is shipped with Mac OS X), run the following commands:\n",
    "\n",
    "    $ sudo port select python python36\n",
    "    $ sudo port select ipython ipython36"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Windows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Windows lacks a good packaging system, so the easiest way to setup a Python environment is to install a pre-packaged distribution. Some good alternatives are:\n",
    "\n",
    " * [Enthought Python Distribution](http://www.enthought.com/products/epd.php). EPD is a commercial product but is available free for academic use.\n",
    " * [Anaconda](http://continuum.io/downloads.html). The Anaconda Python distribution comes with many scientific computing and data science packages and is free, including for commercial use and redistribution. It also has add-on products such as Accelerate, IOPro, and MKL Optimizations, which have free trials and are free for academic use.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python program files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the functionality in Python is provided by *modules*. The Python Standard Library is a large collection of modules that provides *cross-platform* implementations of common facilities such as access to the operating system, file I/O, string management, network communication, and much more.\n",
    "\n",
    "* The Python Standard Library: http://docs.python.org/2/library/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": 3,
   "metadata": {},
   "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": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "x = math.cos(2 * math.pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "\n",
    "x = cos(2 * pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This 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": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once a module is imported, we can list the symbols it provides using the `dir` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print(dir(math))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And using the function `help` we can get a description of each function (almost .. not all functions have docstrings, as they are technically called, but the vast majority of functions are documented this way). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function log in module math:\n",
      "\n",
      "log(...)\n",
      "    log(x, [base=math.e])\n",
      "    Return the logarithm of x to the given base.\n",
      "    \n",
      "    If the base not specified, returns the natural logarithm (base e) of x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.302585092994046"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.3219280948873626"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(10, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables and types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Symbol names "
   ]
  },
  {
   "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 convention, 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": [
    "### Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "The assignment operator in Python is `=`. Python is a dynamically typed language, so we do not need to specify the type of a variable when we create one.\n",
    "\n",
    "Assigning a value to a new variable creates the variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# variable assignments\n",
    "x = 1.0\n",
    "my_variable = 12.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although not explicitly specified, a variable does have a type associated with it. The type is derived from the value that was assigned to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we assign a new value to a variable, its type can change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to use a variable that has not yet been defined we get an `NameError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4772/1056546137.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fundamental types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# integers\n",
    "x = 1\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# float\n",
    "x = 1.0\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# boolean\n",
    "b1 = True\n",
    "b2 = False\n",
    "\n",
    "type(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# complex numbers: note the use of `j` to specify the imaginary part\n",
    "z = 1.0 - 1.0j\n",
    "type(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 0.0\n"
     ]
    }
   ],
   "source": [
    "print(x.real, x.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type utility functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The module `types` contains a number of type name definitions that can be used to test if variables are of certain types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['AsyncGeneratorType', 'BuiltinFunctionType', 'BuiltinMethodType', 'CellType', 'ClassMethodDescriptorType', 'CodeType', 'CoroutineType', 'DynamicClassAttribute', 'EllipsisType', 'FrameType', 'FunctionType', 'GeneratorType', 'GenericAlias', 'GetSetDescriptorType', 'LambdaType', 'MappingProxyType', 'MemberDescriptorType', 'MethodDescriptorType', 'MethodType', 'MethodWrapperType', 'ModuleType', 'NoneType', 'NotImplementedType', 'SimpleNamespace', 'TracebackType', 'UnionType', 'WrapperDescriptorType', '_GeneratorWrapper', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_calculate_meta', '_cell_factory', 'coroutine', 'new_class', 'prepare_class', 'resolve_bases']\n"
     ]
    }
   ],
   "source": [
    "import types\n",
    "\n",
    "# print all types defined in the `types` module\n",
    "print(dir(types))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1.0\n",
    "\n",
    "# check if the variable x is a float\n",
    "type(x) is float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if the variable x is an int\n",
    "type(x) is int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the `isinstance` method for testing types of variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(x, float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function isinstance in module builtins:\n",
      "\n",
      "isinstance(obj, class_or_tuple, /)\n",
      "    Return whether an object is an instance of a class or of a subclass thereof.\n",
      "    \n",
      "    A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to\n",
      "    check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)\n",
      "    or ...`` etc.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(isinstance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type casting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 1.5\n",
    "\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = int(x)\n",
    "\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = float(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Complex variables cannot be cast to floats or integers. We need to use `z.real` or `z.imag` to extract the part of the complex number we want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0  ->  True <class 'bool'>\n",
      "-1.0  ->  True <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "y = bool(z.real)\n",
    "\n",
    "print(z.real, \" -> \", y, type(y))\n",
    "\n",
    "y = bool(z.imag)\n",
    "\n",
    "print(z.imag, \" -> \", y, type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators and comparisons"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most operators and comparisons in Python work as one would expect:\n",
    "\n",
    "* Arithmetic operators `+`, `-`, `*`, `/`, `//` (integer division), '**' power\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, -1, 2, 0.5)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2, 1 - 2, 1 * 2, 1 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.0, -1.0, 2.0, 0.5)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.0 + 2.0, 1.0 - 2.0, 1.0 * 2.0, 1.0 / 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Integer division of float numbers\n",
    "3.0 // 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note! The power operators in python isn't ^, but **\n",
    "2 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The boolean operators are spelled out as the words `and`, `not`, `or`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Comparison operators `>`, `<`, `>=` (greater or equal), `<=` (less or equal), `==` equality, `is` identical."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 1, 2 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, False)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 2, 2 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 >= 2, 2 <= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# equality\n",
    "[1,2] == [1,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compound types: Strings, List and dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are the variable type that is used for storing text messages. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Hello world\"\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# length of the string: the number of characters\n",
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello test\n"
     ]
    }
   ],
   "source": [
    "# replace a substring in a string with something 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": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Heads up MATLAB users:** Indexing start at 0!\n",
    "\n",
    "We can extract a part of a string using the syntax `[start:stop]`, which extracts characters between index `start` and `stop` -1 (the character at index `stop` is not included):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[4:5]"
   ]
  },
  {
   "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": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'world'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[6:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello world'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also define the step size using the syntax `[start:end:step]` (the default value for `step` is 1, as we saw above):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello world'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hlowrd'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": [
    "#### String formatting examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str1 str2 str3\n"
     ]
    }
   ],
   "source": [
    "print(\"str1\", \"str2\", \"str3\")  # The print statement concatenates strings with a space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str1 1.0 False (-0-1j)\n"
     ]
    }
   ],
   "source": [
    "print(\"str1\", 1.0, False, -1j)  # The print statements converts all arguments to strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str1str2str3\n"
     ]
    }
   ],
   "source": [
    "print(\"str1\" + \"str2\" + \"str3\") # strings added with + are concatenated without space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value = 1.000000\n"
     ]
    }
   ],
   "source": [
    "print(\"value = %f\" % 1.0)       # we can use C-style string formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value1 = 3.14. value2 = 1\n"
     ]
    }
   ],
   "source": [
    "# this formatting creates a string\n",
    "s2 = \"value1 = %.2f. value2 = %d\" % (3.1415, 1.5)\n",
    "\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value1 = 3.1415, value2 = 1.5\n"
     ]
    }
   ],
   "source": [
    "# alternative, more intuitive way of formatting a string \n",
    "s3 = 'value1 = {0}, value2 = {1}'.format(3.1415, 1.5)\n",
    "\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "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": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[2, 3]\n",
      "[1, 3]\n"
     ]
    }
   ],
   "source": [
    "print(l)\n",
    "\n",
    "print(l[1:3])\n",
    "\n",
    "print(l[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Heads up MATLAB users:** Indexing starts at 0!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'a', 1.0, (1-1j)]\n"
     ]
    }
   ],
   "source": [
    "l = [1, 'a', 1.0, 1-1j]\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python lists can be inhomogeneous and arbitrarily nested:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, [2, [3, [4, [5]]]]]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nested_list = [1, [2, [3, [4, [5]]]]]\n",
    "\n",
    "nested_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists play a very important role in Python. For example they are used in loops and other flow control structures (discussed below). There are a number of convenient functions for generating lists of various types, for example the `range` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(10, 30, 2)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = 10\n",
    "stop = 30\n",
    "step = 2\n",
    "\n",
    "range(start, stop, step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 12, 14, 16, 18, 20, 22, 24, 26, 28]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# in python 3 range generates an iterator, which can be converted to a list using 'list(...)'.\n",
    "list(range(start, stop, step))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(-10, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello world'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convert a string to a list by type casting:\n",
    "s2 = list(s)\n",
    "\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', 'H', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r', 'w']\n"
     ]
    }
   ],
   "source": [
    "# sorting lists\n",
    "s2.sort()\n",
    "\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding, inserting, modifying, and removing elements from lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'd', 'd']\n"
     ]
    }
   ],
   "source": [
    "# create a new empty list\n",
    "l = []\n",
    "\n",
    "# add an elements using `append`\n",
    "l.append(\"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": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'p', 'p']\n"
     ]
    }
   ],
   "source": [
    "l[1] = \"p\"\n",
    "l[2] = \"p\"\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['N', 'p', 'p']\n"
     ]
    }
   ],
   "source": [
    "l[0] = \"N\"\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['N', 'd', 'd']\n"
     ]
    }
   ],
   "source": [
    "l[1:3] = [\"d\", \"d\"]\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert an element at an specific index using `insert`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['i', 'n', 's', 'e', 'r', 't', 'N', 'd', 'd']\n"
     ]
    }
   ],
   "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": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['n', 's', 'e', 'r', 't', 'N', 'd', 'd']\n"
     ]
    }
   ],
   "source": [
    "l.remove(\"i\")\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove an element at a specific location using `del`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['n', 's', 'e', 'r', 't', 'N']\n"
     ]
    }
   ],
   "source": [
    "del l[7]\n",
    "del l[6]\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See `help(list)` for more details, or read the online documentation "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "point = (10, 20)\n",
    "\n",
    "print(point, type(point))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20) <class 'tuple'>\n"
     ]
    }
   ],
   "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": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 10\n",
      "y = 20\n"
     ]
    }
   ],
   "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": 81,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4772/2854329342.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mpoint\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m20\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "point[0] = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are also like lists, except that each element is a key-value pair. The syntax for dictionaries is `{key1 : value1, ...}`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "{'parameter1': 1.0, 'parameter2': 2.0, 'parameter3': 3.0}\n"
     ]
    }
   ],
   "source": [
    "params = {\"parameter1\" : 1.0,\n",
    "          \"parameter2\" : 2.0,\n",
    "          \"parameter3\" : 3.0,}\n",
    "\n",
    "print(type(params))\n",
    "print(params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parameter1 = 1.0\n",
      "parameter2 = 2.0\n",
      "parameter3 = 3.0\n"
     ]
    }
   ],
   "source": [
    "print(\"parameter1 = \" + str(params[\"parameter1\"]))\n",
    "print(\"parameter2 = \" + str(params[\"parameter2\"]))\n",
    "print(\"parameter3 = \" + str(params[\"parameter3\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parameter1 = A\n",
      "parameter2 = B\n",
      "parameter3 = 3.0\n",
      "parameter4 = D\n"
     ]
    }
   ],
   "source": [
    "params[\"parameter1\"] = \"A\"\n",
    "params[\"parameter2\"] = \"B\"\n",
    "\n",
    "# add a new entry\n",
    "params[\"parameter4\"] = \"D\"\n",
    "\n",
    "print(\"parameter1 = \" + str(params[\"parameter1\"]))\n",
    "print(\"parameter2 = \" + str(params[\"parameter2\"]))\n",
    "print(\"parameter3 = \" + str(params[\"parameter3\"]))\n",
    "print(\"parameter4 = \" + str(params[\"parameter4\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional statements: if, elif, else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Python syntax for conditional execution of code uses the keywords `if`, `elif` (else if), `else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "statement1 and statement2 are False\n"
     ]
    }
   ],
   "source": [
    "statement1 = False\n",
    "statement2 = False\n",
    "\n",
    "if statement1:\n",
    "    print(\"statement1 is True\")\n",
    "    \n",
    "elif statement2:\n",
    "    print(\"statement2 is True\")\n",
    "    \n",
    "else:\n",
    "    print(\"statement1 and statement2 are False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the first time, here we encounted a peculiar and unusual aspect of the Python programming language: Program blocks are defined by their indentation level. \n",
    "\n",
    "In Python, the extent of a code block is defined by the indentation level (usually a tab or say four white spaces). This means that we have to be careful to indent our code correctly, or else we will get syntax errors. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "both statement1 and statement2 are True\n"
     ]
    }
   ],
   "source": [
    "statement1 = statement2 = True\n",
    "\n",
    "if statement1:\n",
    "    if statement2:\n",
    "        print(\"both statement1 and statement2 are True\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block after 'if' statement on line 3 (Temp/ipykernel_4772/3545621536.py, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\habibnia\\AppData\\Local\\Temp/ipykernel_4772/3545621536.py\"\u001b[1;36m, line \u001b[1;32m4\u001b[0m\n\u001b[1;33m    print(\"both statement1 and statement2 are True\")  # this line is not properly indented\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block after 'if' statement on line 3\n"
     ]
    }
   ],
   "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": 90,
   "metadata": {},
   "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": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "now outside the if block\n"
     ]
    }
   ],
   "source": [
    "if statement1:\n",
    "    print(\"printed if statement1 is True\")\n",
    "    \n",
    "print(\"now outside the if block\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`for` loops**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "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": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "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": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3\n",
      "-2\n",
      "-1\n",
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for x in range(-3,3):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "scientific\n",
      "computing\n",
      "with\n",
      "python\n"
     ]
    }
   ],
   "source": [
    "for word in [\"scientific\", \"computing\", \"with\", \"python\"]:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To iterate over key-value pairs of a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parameter1 = A\n",
      "parameter2 = B\n",
      "parameter3 = 3.0\n",
      "parameter4 = D\n"
     ]
    }
   ],
   "source": [
    "for key, value in params.items():\n",
    "    print(key + \" = \" + str(value))"
   ]
  },
  {
   "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": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 -3\n",
      "1 -2\n",
      "2 -1\n",
      "3 0\n",
      "4 1\n",
      "5 2\n"
     ]
    }
   ],
   "source": [
    "for idx, x in enumerate(range(-3,3)):\n",
    "    print(idx, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehensions: Creating lists using `for` loops:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A convenient and compact way to initialize lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "l1 = [x**2 for x in range(0,5)]\n",
    "\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while` loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "done\n"
     ]
    }
   ],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function in Python is defined using the keyword `def`, followed by a function name, a signature within parentheses `()`, and a colon `:`. The following code, with one additional level of indentation, is the function body."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func0():   \n",
    "    print(\"test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n"
     ]
    }
   ],
   "source": [
    "func0()"
   ]
  },
  {
   "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": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func1(s):\n",
    "    \"\"\"\n",
    "    Print a string 's' and tell how many characters it has    \n",
    "    \"\"\"\n",
    "    \n",
    "    print(s + \" has \" + str(len(s)) + \" characters\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function func1 in module __main__:\n",
      "\n",
      "func1(s)\n",
      "    Print a string 's' and tell how many characters it has\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(func1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Big Data Economics has 18 characters\n"
     ]
    }
   ],
   "source": [
    "func1(\"Big Data Economics\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions that returns a value use the `return` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    \"\"\"\n",
    "    Return the square of x.\n",
    "    \"\"\"\n",
    "    return x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 107,
   "metadata": {},
   "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": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9, 27, 81)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "powers(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n"
     ]
    }
   ],
   "source": [
    "x2, x3, x4 = powers(3)\n",
    "\n",
    "print(x3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default argument and keyword arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a definition of a function, we can give default values to the arguments the function takes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(x, p=2, debug=False):\n",
    "    if debug:\n",
    "        print(\"evaluating myfunc for x = \" + str(x) + \" using exponent p = \" + str(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": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "625"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunc(5,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "evaluating myfunc for x = 5 using exponent p = 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunc(5, debug=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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. This is called *keyword* arguments, and is often very useful in functions that takes a lot of optional arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "evaluating myfunc for x = 7 using exponent p = 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "343"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunc(p=3, debug=True, x=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unnamed functions (lambda function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python we can also create unnamed functions, using the `lambda` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "f1 = lambda x: x**2\n",
    "    \n",
    "# is equivalent to \n",
    "\n",
    "def f2(x):\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 4)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1(2), f2(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This technique is useful for example when we want to pass a simple function as an argument to another function, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x25f2c47ca90>"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# map is a built-in python function\n",
    "map(lambda x: x**2, range(-3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 4, 1, 0, 1, 4, 9]"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# in python 3 we can use `list(...)` to convert the iterator to an explicit list\n",
    "list(map(lambda x: x**2, range(-3,4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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",
    "A class is defined almost like a function, 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 argument `self` as its 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": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Point:\n",
    "    \"\"\"\n",
    "    Simple class for representing a point in a Cartesian coordinate system.\n",
    "    \"\"\"\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 __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": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point at [0.000000, 0.000000]\n"
     ]
    }
   ],
   "source": [
    "p1 = Point(0, 0) # this will invoke the __init__ method in the Point class\n",
    "\n",
    "print(p1)         # this will invoke the __str__ method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To invoke a class method in the class instance `p`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point at [0.250000, 1.500000]\n",
      "Point at [1.000000, 1.000000]\n"
     ]
    }
   ],
   "source": [
    "p2 = Point(1, 1)\n",
    "\n",
    "p1.translate(0.25, 1.5)\n",
    "\n",
    "print(p1)\n",
    "print(p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that calling class methods can modifiy the state of 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 grouped in separate and independent entities. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the most important concepts in good programming is to reuse code and avoid repetitions.\n",
    "\n",
    "The idea is to write functions and classes with a well-defined purpose and scope, and reuse these instead of repeating similar code in different part of a program (modular programming). The result is usually that readability and maintainability of a program is greatly improved. What this means in practice is that our programs have fewer bugs, are easier to extend and debug/troubleshoot. \n",
    "\n",
    "Python supports modular programming at different levels. Functions and classes are examples of tools for low-level modular programming. Python modules are a higher-level modular programming construct, where we can collect related variables, functions and classes in a module. A python module is defined in a python file (with file-ending `.py`), and it can be made accessible to other Python modules and programs using the `import` statement. \n",
    "\n",
    "Consider the following example: the file `mymodule.py` contains simple example implementations of a variable, function and a class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting mymodule.py\n"
     ]
    }
   ],
   "source": [
    "%%file mymodule.py\n",
    "\"\"\"\n",
    "Example of a python module. Contains a variable called my_variable,\n",
    "a function called my_function, and a class called MyClass.\n",
    "\"\"\"\n",
    "\n",
    "my_variable = 0\n",
    "\n",
    "def my_function():\n",
    "    \"\"\"\n",
    "    Example function\n",
    "    \"\"\"\n",
    "    return my_variable\n",
    "    \n",
    "class MyClass:\n",
    "    \"\"\"\n",
    "    Example class.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        self.variable = my_variable\n",
    "        \n",
    "    def set_variable(self, new_value):\n",
    "        \"\"\"\n",
    "        Set self.variable to a new value\n",
    "        \"\"\"\n",
    "        self.variable = new_value\n",
    "        \n",
    "    def get_variable(self):\n",
    "        return self.variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can import the module `mymodule` into our Python program using `import`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mymodule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `help(module)` to get a summary of what the module provides:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module mymodule:\n",
      "\n",
      "NAME\n",
      "    mymodule\n",
      "\n",
      "DESCRIPTION\n",
      "    Example of a python module. Contains a variable called my_variable,\n",
      "    a function called my_function, and a class called MyClass.\n",
      "\n",
      "CLASSES\n",
      "    builtins.object\n",
      "        MyClass\n",
      "    \n",
      "    class MyClass(builtins.object)\n",
      "     |  Example class.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  get_variable(self)\n",
      "     |  \n",
      "     |  set_variable(self, new_value)\n",
      "     |      Set self.variable to a new value\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "\n",
      "FUNCTIONS\n",
      "    my_function()\n",
      "        Example function\n",
      "\n",
      "DATA\n",
      "    my_variable = 0\n",
      "\n",
      "FILE\n",
      "    c:\\users\\habibnia\\documents\\habibnia_algotrading_2023\\mymodule.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(mymodule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mymodule.my_variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mymodule.my_function() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_class = mymodule.MyClass() \n",
    "my_class.set_variable(10)\n",
    "my_class.get_variable()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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 statement is defined."
   ]
  },
  {
   "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 `BaseException` or a class derived from it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "ename": "Exception",
     "evalue": "description of the error",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4772/2782052409.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"description of the error\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mException\u001b[0m: description of the error"
     ]
    }
   ],
   "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 Exception(\"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  `except` 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": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n",
      "Caught an exception\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(\"test\")\n",
    "    # generate an error: the variable test is not defined\n",
    "    print(test)\n",
    "except:\n",
    "    print(\"Caught an exception\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get information about the error, we can access the `Exception` class instance that describes the exception by using for example:\n",
    "\n",
    "    except Exception as e:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n",
      "Caught an exception:name 'test' is not defined\n"
     ]
    }
   ],
   "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 exception:\" + str(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy -  multidimensional data arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I'll explain later what this line is all about!\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `numpy` package (module) is used in almost all numerical computation using Python. It is a package that provide high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and Fortran so when calculations are vectorized (formulated with vectors and matrices), performance is very good. \n",
    "\n",
    "To use `numpy` you need to import the module, using for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the `numpy` package the terminology used for vectors, matrices and higher-dimensional data sets is *array*. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating `numpy` arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a number of ways to initialize new numpy arrays, for example from\n",
    "\n",
    "* a Python list or tuples\n",
    "* using functions that are dedicated to generating numpy arrays, such as `arange`, `linspace`, etc.\n",
    "* reading data from files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, to create new vector and matrix arrays from Python lists we can use the `numpy.array` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a vector: the argument to the array function is a Python list\n",
    "v = array([1,2,3,4])\n",
    "\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a matrix: the argument to the array function is a nested Python list\n",
    "M = array([[1, 2], [3, 4]])\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `v` and `M` objects are both of the type `ndarray` that the `numpy` module provides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v), type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference between the `v` and `M` arrays is only their shapes. We can get information about the shape of an array by using the `ndarray.shape` property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of elements in the array is available through the `ndarray.size` property:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equivalently, we could use the function `numpy.shape` and `numpy.size`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far the `numpy.ndarray` looks awefully much like a Python list (or nested list). Why not simply use Python lists for computations instead of creating a new array type? \n",
    "\n",
    "There are several reasons:\n",
    "\n",
    "* Python lists are very general. They can contain any kind of object. They are dynamically typed. They do not support mathematical functions such as matrix and dot multiplications, etc. Implementing such functions for Python lists would not be very efficient because of the dynamic typing.\n",
    "* Numpy arrays are **statically typed** and **homogeneous**. The type of the elements is determined when the array is created.\n",
    "* Numpy arrays are memory efficient.\n",
    "* Because of the static typing, fast implementation of mathematical functions such as multiplication and addition of `numpy` arrays can be implemented in a compiled language (C and Fortran is used).\n",
    "\n",
    "Using the `dtype` (data type) property of an `ndarray`, we can see what type the data of an array has:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get an error if we try to assign a value of the wrong type to an element in a numpy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'hello'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4772/3388738246.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mM\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"hello\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: 'hello'"
     ]
    }
   ],
   "source": [
    "M[0,0] = \"hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want, we can explicitly define the type of the array data when we create it, using the `dtype` keyword argument: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 2.+0.j],\n",
       "       [3.+0.j, 4.+0.j]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = array([[1, 2], [3, 4]], dtype=complex)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Common data types that can be used with `dtype` are: `int`, `float`, `complex`, `bool`, `object`, etc.\n",
    "\n",
    "We can also explicitly define the bit size of the data types, for example: `int64`, `int16`, `float128`, `complex128`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using array-generating functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For larger arrays it is inpractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in `numpy` that generate arrays of different forms. Some of the more common are:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a range\n",
    "\n",
    "x = arange(0, 10, 1) # arguments: start, stop, step\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.00000000e+00, -9.00000000e-01, -8.00000000e-01, -7.00000000e-01,\n",
       "       -6.00000000e-01, -5.00000000e-01, -4.00000000e-01, -3.00000000e-01,\n",
       "       -2.00000000e-01, -1.00000000e-01, -2.22044605e-16,  1.00000000e-01,\n",
       "        2.00000000e-01,  3.00000000e-01,  4.00000000e-01,  5.00000000e-01,\n",
       "        6.00000000e-01,  7.00000000e-01,  8.00000000e-01,  9.00000000e-01])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(-1, 1, 0.1)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### linspace and logspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.41666667,  0.83333333,  1.25      ,  1.66666667,\n",
       "        2.08333333,  2.5       ,  2.91666667,  3.33333333,  3.75      ,\n",
       "        4.16666667,  4.58333333,  5.        ,  5.41666667,  5.83333333,\n",
       "        6.25      ,  6.66666667,  7.08333333,  7.5       ,  7.91666667,\n",
       "        8.33333333,  8.75      ,  9.16666667,  9.58333333, 10.        ])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using linspace, both end points ARE included\n",
    "linspace(0, 10, 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 3.03773178e+00, 9.22781435e+00, 2.80316249e+01,\n",
       "       8.51525577e+01, 2.58670631e+02, 7.85771994e+02, 2.38696456e+03,\n",
       "       7.25095809e+03, 2.20264658e+04])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logspace(0, 10, 10, base=e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mgrid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = mgrid[0:5, 0:5] # similar to meshgrid in MATLAB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [1, 1, 1, 1, 1],\n",
       "       [2, 2, 2, 2, 2],\n",
       "       [3, 3, 3, 3, 3],\n",
       "       [4, 4, 4, 4, 4]])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4],\n",
       "       [0, 1, 2, 3, 4]])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### random data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.13569055, 0.97682816, 0.09727751, 0.51451836, 0.82349785],\n",
       "       [0.73322829, 0.50587498, 0.2876229 , 0.31715421, 0.58226593],\n",
       "       [0.02211019, 0.65832623, 0.2369539 , 0.17985726, 0.13650897],\n",
       "       [0.79175424, 0.84535597, 0.77441506, 0.53063802, 0.22500849],\n",
       "       [0.81128031, 0.70671539, 0.28553655, 0.61000359, 0.16749559]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# uniform random numbers in [0,1]\n",
    "random.rand(5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.60710715,  0.70643016, -0.53116476, -0.38896771, -0.22832117],\n",
       "       [ 1.13287576, -1.59410671, -0.78148296, -1.00673107, -0.21684738],\n",
       "       [ 0.0884052 ,  0.60907094,  1.7292691 , -1.2617504 ,  0.7955056 ],\n",
       "       [-1.21029053, -1.17170074,  1.60578581,  1.50255788,  0.05256163],\n",
       "       [-1.3146418 ,  0.05434953, -1.94774502, -1.28153337,  1.48004237]])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# standard normal distributed random numbers\n",
    "random.randn(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a diagonal matrix\n",
    "diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 0],\n",
       "       [0, 0, 2, 0],\n",
       "       [0, 0, 0, 3],\n",
       "       [0, 0, 0, 0]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diagonal with offset from the main diagonal\n",
    "diag([1,2,3], k=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### zeros and ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones((3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comma-separated values (CSV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very common file format for data files is comma-separated values (CSV), or related formats such as TSV (tab-separated values). To read data from such files into Numpy arrays we can use the `numpy.genfromtxt` function. For example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = genfromtxt('stockholm_td_adj.dat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(14,4))\n",
    "ax.plot(data[:,0]+data[:,1]/12.0+data[:,2]/365, data[:,5])\n",
    "ax.axis('tight')\n",
    "ax.set_title('tempeatures in Stockholm')\n",
    "ax.set_xlabel('year')\n",
    "ax.set_ylabel('temperature (C)');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `numpy.savetxt` we can store a Numpy array to a file in CSV format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.19609668, 0.4506083 , 0.25528353],\n",
       "       [0.36252792, 0.67543197, 0.60083246],\n",
       "       [0.44181712, 0.83675827, 0.75089546]])"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = random.rand(3,3)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "savetxt(\"random-matrix.csv\", M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy's native file format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Useful when storing and reading back numpy array data. Use the functions `numpy.save` and `numpy.load`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.19609668, 0.4506083 , 0.25528353],\n",
       "       [0.36252792, 0.67543197, 0.60083246],\n",
       "       [0.44181712, 0.83675827, 0.75089546]])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load(\"random-matrix.npy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More properties of the numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.itemsize # bytes per element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.nbytes # number of bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.ndim # number of dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index elements in an array using square brackets and indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# v is a vector, and has only one dimension, taking one index\n",
    "v[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6754319660904897"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# M is a matrix, or a 2 dimensional array, taking two indices \n",
    "M[1,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we omit an index of a multidimensional array it returns the whole row (or, in general, a N-1 dimensional array) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.19609668, 0.4506083 , 0.25528353],\n",
       "       [0.36252792, 0.67543197, 0.60083246],\n",
       "       [0.44181712, 0.83675827, 0.75089546]])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.36252792, 0.67543197, 0.60083246])"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same thing can be achieved with using `:` instead of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.36252792, 0.67543197, 0.60083246])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:] # row 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.4506083 , 0.67543197, 0.83675827])"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:,1] # column 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign new values to elements in an array using indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "M[0,0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.4506083 , 0.25528353],\n",
       "       [0.36252792, 0.67543197, 0.60083246],\n",
       "       [0.44181712, 0.83675827, 0.75089546]])"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "# also works for rows and columns\n",
    "M[1,:] = 0\n",
    "M[:,2] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.4506083 , -1.        ],\n",
       "       [ 0.        ,  0.        , -1.        ],\n",
       "       [ 0.44181712,  0.83675827, -1.        ]])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing is the technical name for the syntax `M[lower:upper:step]` to extract part of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([1,2,3,4,5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array slices are *mutable*: if they are assigned a new value the original array from which the slice was extracted is modified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3] = [-2,-3]\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can omit any of the three parameters in `M[lower:upper:step]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # lower, upper, step all take the default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::2] # step is 2, lower and upper defaults to the beginning and end of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # first three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:] # elements from index 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negative indices counts from the end of the array (positive index from the begining):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-1] # the last element in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-3:] # the last three elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing works exactly the same way for multidimensional arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a block from the original array\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strides\n",
    "A[::2, ::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fancy indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fancy indexing is the name for when an array or list is used in-place of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 2, 3]\n",
    "A[row_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 22, 34])"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "col_indices = [1, 2, -1] # remember, index -1 means the last element\n",
    "A[row_indices, col_indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use index masks: If the index mask is an Numpy array of data type `bool`, then an element is selected (True) or not (False) depending on the value of the index mask at the position of each element: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = array([n for n in range(5)])\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_mask = array([True, False, True, False, False])\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same thing\n",
    "row_mask = array([1,0,1,0,0], dtype=bool)\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This feature is very useful to conditionally select elements from an array, using for example comparison operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. ,\n",
       "       6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = arange(0, 10, 0.5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True,  True,  True,  True, False, False, False,\n",
       "       False, False])"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = (5 < x) * (x < 7.5)\n",
    "\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 6. , 6.5, 7. ])"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions for extracting data from arrays and creating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### where"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The index mask can be converted to position index using the `where` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14], dtype=int64),)"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indices = where(mask)\n",
    "\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.5, 6. , 6.5, 7. ])"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[indices] # this indexing is equivalent to the fancy indexing x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### diag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the diag function we can also extract the diagonal and subdiagonals of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag(A, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### take"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `take` function is similar to fancy indexing described above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3, -2, -1,  0,  1,  2])"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2 = arange(-3,3)\n",
    "v2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 3, 5]\n",
    "v2[row_indices] # fancy indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v2.take(row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But `take` also works on lists and other objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  0,  2])"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "take([-3, -2, -1,  0,  1,  2], row_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### choose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constructs an array by picking elements from several arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -2,  5, -2])"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "which = [1, 0, 1, 0]\n",
    "choices = [[-2,-2,-2,-2], [5,5,5,5]]\n",
    "\n",
    "choose(which, choices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vectorizing code is the key to writing efficient numerical calculation with Python/Numpy. That means that as much as possible of a program should be formulated in terms of matrix and vector operations, like matrix-matrix multiplication."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalar-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the usual arithmetic operators to multiply, add, subtract, and divide arrays with scalar numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 = arange(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 0,  2,  4,  6,  8],\n",
       "        [20, 22, 24, 26, 28],\n",
       "        [40, 42, 44, 46, 48],\n",
       "        [60, 62, 64, 66, 68],\n",
       "        [80, 82, 84, 86, 88]]),\n",
       " array([[ 2,  3,  4,  5,  6],\n",
       "        [12, 13, 14, 15, 16],\n",
       "        [22, 23, 24, 25, 26],\n",
       "        [32, 33, 34, 35, 36],\n",
       "        [42, 43, 44, 45, 46]]))"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * 2, A + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element-wise array-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we add, subtract, multiply and divide arrays with each other, the default behaviour is **element-wise** operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    1,    4,    9,   16],\n",
       "       [ 100,  121,  144,  169,  196],\n",
       "       [ 400,  441,  484,  529,  576],\n",
       "       [ 900,  961, 1024, 1089, 1156],\n",
       "       [1600, 1681, 1764, 1849, 1936]])"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A # element-wise multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we multiply arrays with compatible shapes, we get an element-wise multiplication of each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   4,   9,  16],\n",
       "       [  0,  11,  24,  39,  56],\n",
       "       [  0,  21,  44,  69,  96],\n",
       "       [  0,  31,  64,  99, 136],\n",
       "       [  0,  41,  84, 129, 176]])"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about matrix mutiplication? There are two ways. We can either use the `dot` function, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 300,  310,  320,  330,  340],\n",
       "       [1300, 1360, 1420, 1480, 1540],\n",
       "       [2300, 2410, 2520, 2630, 2740],\n",
       "       [3300, 3460, 3620, 3780, 3940],\n",
       "       [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(A, v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, we can cast the array objects to the type `matrix`. This changes the behavior of the standard arithmetic operators `+, -, *` to use matrix algebra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = matrix(A)\n",
    "v = matrix(v1).T # make it a column vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0],\n",
       "        [1],\n",
       "        [2],\n",
       "        [3],\n",
       "        [4]])"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 300,  310,  320,  330,  340],\n",
       "        [1300, 1360, 1420, 1480, 1540],\n",
       "        [2300, 2410, 2520, 2630, 2740],\n",
       "        [3300, 3460, 3620, 3780, 3940],\n",
       "        [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [130],\n",
       "        [230],\n",
       "        [330],\n",
       "        [430]])"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[30]])"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inner product\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [131],\n",
       "        [232],\n",
       "        [333],\n",
       "        [434]])"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# with matrix objects, standard matrix algebra applies\n",
    "v + M*v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we try to add, subtract or multiply objects with incomplatible shapes we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = matrix([1,2,3,4,5,6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (6, 1))"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(M), shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_4772/2280171313.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mM\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mv\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\numpy\\matrixlib\\defmatrix.py\u001b[0m in \u001b[0;36m__mul__\u001b[1;34m(self, other)\u001b[0m\n\u001b[0;32m    216\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    217\u001b[0m             \u001b[1;31m# This promotes 1-D vectors to row vectors\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 218\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0masmatrix\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    219\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0misscalar\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mor\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mother\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'__rmul__'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    220\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mother\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\numpy\\core\\overrides.py\u001b[0m in \u001b[0;36mdot\u001b[1;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)"
     ]
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See also the related functions: `inner`, `outer`, `cross`, `kron`, `tensordot`. Try for example `help(kron)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array/Matrix transformations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we have used the `.T` to transpose the matrix object `v`. We could also have used the `transpose` function to accomplish the same thing. \n",
    "\n",
    "Other mathematical functions that transform matrix objects are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.+1.j, 0.+2.j],\n",
       "        [0.+3.j, 0.+4.j]])"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = matrix([[1j, 2j], [3j, 4j]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.-1.j, 0.-2.j],\n",
       "        [0.-3.j, 0.-4.j]])"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjugate(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hermitian conjugate: transpose + conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.-1.j, 0.-3.j],\n",
       "        [0.-2.j, 0.-4.j]])"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extract the real and imaginary parts of complex-valued arrays using `real` and `imag`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0., 0.],\n",
       "        [0., 0.]])"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "real(C) # same as: C.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 2.],\n",
       "        [3., 4.]])"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imag(C) # same as: C.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or the complex argument and absolute value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.78539816, 1.10714872],\n",
       "        [1.24904577, 1.32581766]])"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "angle(C+1) # heads up MATLAB Users, angle is used instead of arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 2.],\n",
       "        [3., 4.]])"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix computations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.+2.j , 0.-1.j ],\n",
       "        [0.-1.5j, 0.+0.5j]])"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.inv(C) # equivalent to C.I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1.00000000e+00+0.j, 0.00000000e+00+0.j],\n",
       "        [1.11022302e-16+0.j, 1.00000000e+00+0.j]])"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.I * C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determinant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0000000000000004+0j)"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.det(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.49999999999999967+0j)"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linalg.det(C.I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often it is useful to store datasets in Numpy arrays. Numpy provides a number of functions to calculate statistics of datasets in arrays. \n",
    "\n",
    "For example, let's calculate some properties from the Stockholm temperature dataset used above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77431, 7)"
      ]
     },
     "execution_count": 247,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reminder, the tempeature dataset is stored in the data variable:\n",
    "shape(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.197109684751585"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "mean(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The daily mean temperature in Stockholm over the last 200 years has been about 6.2 C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### standard deviations and variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.282271621340573, 68.59602320966341)"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "std(data[:,3]), var(data[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### min and max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.8"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lowest daily average temperature\n",
    "data[:,3].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.3"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# highest daily average temperature\n",
    "data[:,3].max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sum, prod, and trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum up all elements\n",
    "sum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# product of all elements\n",
    "prod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative sum\n",
    "cumsum(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 256,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cummulative product\n",
    "cumprod(d+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as: diag(A).sum()\n",
    "trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computations on subsets of arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compute with subsets of the data in an array using indexing, fancy indexing, and the other methods of extracting data from an array (described above).\n",
    "\n",
    "For example, let's go back to the temperature dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "'head' is not recognized as an internal or external command,\n",
      "operable program or batch file.\n"
     ]
    }
   ],
   "source": [
    "!head -n 3 stockholm_td_adj.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dataformat is: year, month, day, daily average temperature, low, high, location.\n",
    "\n",
    "If we are interested in the average temperature only in a particular month, say February, then we can create a index mask and use it to select only the data for that month using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.])"
      ]
     },
     "execution_count": 259,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique(data[:,1]) # the month column takes values from 1 to 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_feb = data[:,1] == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.212109570736596"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the temperature data is in column 3\n",
    "mean(data[mask_feb,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these tools we have very powerful data processing capabilities at our disposal. For example, to extract the average monthly average temperatures for each month of the year only takes a few lines of code: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "months = arange(1,13)\n",
    "monthly_mean = [mean(data[data[:,1] == month, 3]) for month in months]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.bar(months, monthly_mean)\n",
    "ax.set_xlabel(\"Month\")\n",
    "ax.set_ylabel(\"Monthly avg. temp.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculations with higher-dimensional data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When functions such as `min`, `max`, etc. are applied to a multidimensional arrays, it is sometimes useful to apply the calculation to the entire array, and sometimes only on a row or column basis. Using the `axis` argument we can specify how these functions should behave: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.8096961 , 0.50296079, 0.11166657],\n",
       "       [0.04633714, 0.35170253, 0.05172774],\n",
       "       [0.61940609, 0.28724611, 0.11318119]])"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = random.rand(3,3)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8096961025054616"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# global max\n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.8096961 , 0.50296079, 0.11318119])"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each column\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.8096961 , 0.35170253, 0.61940609])"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max in each row\n",
    "m.max(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many other functions and methods in the `array` and `matrix` classes accept the same (optional) `axis` keyword argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping, resizing and stacking arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shape of an Numpy array can be modified without copying the underlaying data, which makes it a fast operation even for large arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [],
   "source": [
    "n, m = A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30,\n",
       "        31, 32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape((1,n*m))\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30,\n",
       "        31, 32, 33, 34, 40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0,0:5] = 5 # modify the array\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # and the original variable is also changed. B is only a different view of the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the function `flatten` to make a higher-dimensional array into a vector. But this function create a copy of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.flatten()\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
       "       32, 33, 34, 40, 41, 42, 43, 44])"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[0:5] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  5,  5,  5,  5],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 275,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # now A has not changed, because B's data is a copy of A's, not refering to the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding a new dimension: newaxis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With `newaxis`, we can insert new dimensions in an array, for example converting a vector to a column or row matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 277,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make a column matrix of the vector v\n",
    "v[:, newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# column matrix\n",
    "v[:,newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# row matrix\n",
    "v[newaxis,:].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacking and repeating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using function `repeat`, `tile`, `vstack`, `hstack`, and `concatenate` we can create larger vectors and matrices from smaller ones:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tile and repeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
      ]
     },
     "execution_count": 282,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# repeat each element 3 times\n",
    "repeat(a, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 283,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tile the matrix 3 times \n",
    "tile(a, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 285,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### hstack and vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 287,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vstack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hstack((a,b.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy and \"deep copy\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To achieve high performance, assignments in Python usually do not copy the underlaying objects. This is important for example when objects are passed between functions, to avoid an excessive amount of memory copying when it is not necessary (technical term: pass by reference). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = array([[1, 2], [3, 4]])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now B is referring to the same array data as A \n",
    "B = A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# changing B affects A\n",
    "B[0,0] = 10\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to avoid this behavior, so that when we get a new completely independent object `B` copied from `A`, then we need to do a so-called \"deep copy\" using the function `copy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = copy(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-5,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 294,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now, if we modify B, A is not affected\n",
    "B[0,0] = -5\n",
    "\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating over array elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generally, we want to avoid iterating over the elements of arrays whenever we can (at all costs). The reason is that in a interpreted language like Python (or MATLAB), iterations are really slow compared to vectorized operations. \n",
    "\n",
    "However, sometimes iterations are unavoidable. For such cases, the Python `for` loop is the most convenient way to iterate over an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "v = array([1,2,3,4])\n",
    "\n",
    "for element in v:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row [1 2]\n",
      "1\n",
      "2\n",
      "row [3 4]\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "M = array([[1,2], [3,4]])\n",
    "\n",
    "for row in M:\n",
    "    print(\"row\", row)\n",
    "    \n",
    "    for element in row:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we need to iterate over each element of an array and modify its elements, it is convenient to use the `enumerate` function to obtain both the element and its index in the `for` loop: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row_idx 0 row [1 2]\n",
      "col_idx 0 element 1\n",
      "col_idx 1 element 2\n",
      "row_idx 1 row [3 4]\n",
      "col_idx 0 element 3\n",
      "col_idx 1 element 4\n"
     ]
    }
   ],
   "source": [
    "for row_idx, row in enumerate(M):\n",
    "    print(\"row_idx\", row_idx, \"row\", row)\n",
    "    \n",
    "    for col_idx, element in enumerate(row):\n",
    "        print(\"col_idx\", col_idx, \"element\", element)\n",
    "       \n",
    "        # update the matrix M: square each element\n",
    "        M[row_idx, col_idx] = element ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 299,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# each element in M is now squared\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectorizing functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned several times by now, to get good performance we should try to avoid looping over elements in our vectors and matrices, and instead use vectorized algorithms. The first step in converting a scalar algorithm to a vectorized algorithm is to make sure that the functions we write work with vector inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Theta(x):\n",
    "    \"\"\"\n",
    "    Scalar implemenation of the Heaviside step function.\n",
    "    \"\"\"\n",
    "    if x >= 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 301,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta(any([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, that didn't work because we didn't write the `Theta` function so that it can handle a vector input... \n",
    "\n",
    "To get a vectorized version of Theta we can use the Numpy function `vectorize`. In many cases it can automatically vectorize a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [],
   "source": [
    "Theta_vec = vectorize(Theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 303,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta_vec(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also implement the function to accept a vector input from the beginning (requires more effort but might give better performance):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Theta(x):\n",
    "    \"\"\"\n",
    "    Vector-aware implemenation of the Heaviside step function.\n",
    "    \"\"\"\n",
    "    return 1 * (x >= 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 305,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Theta(array([-3,-2,-1,0,1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 306,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# still works for scalars as well\n",
    "Theta(-1.2), Theta(2.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using arrays in conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using arrays in conditions,for example `if` statements and other boolean expressions, one needs to use `any` or `all`, which requires that any or all elements in the array evalutes to `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 307,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at least one element in M is larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).any():\n",
    "    print(\"at least one element in M is larger than 5\")\n",
    "else:\n",
    "    print(\"no element in M is larger than 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all elements in M are not larger than 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).all():\n",
    "    print(\"all elements in M are larger than 5\")\n",
    "else:\n",
    "    print(\"all elements in M are not larger than 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since Numpy arrays are *statically typed*, the type of an array does not change once created. But we can explicitly cast an array of some type to another using the `astype` functions (see also the similar `asarray` function). This always create a new array of new type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 310,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  4.],\n",
       "       [ 9., 16.]])"
      ]
     },
     "execution_count": 311,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 312,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]])"
      ]
     },
     "execution_count": 313,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* http://scipy.org/Tentative_NumPy_Tutorial\n",
    "* http://scipy.org/NumPy_for_Matlab_Users - A Numpy guide for MATLAB users."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SciPy - Library of scientific algorithms for Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    " This line configures matplotlib to show figures embedded in the notebook\n",
    " instead of opening a new window for each figure.\n",
    "'''\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The SciPy framework builds on top of the low-level NumPy framework for multidimensional arrays, and provides a large number of higher-level scientific algorithms. Some of the topics that SciPy covers are:\n",
    "\n",
    "* Special functions ([scipy.special](http://docs.scipy.org/doc/scipy/reference/special.html))\n",
    "* Integration ([scipy.integrate](http://docs.scipy.org/doc/scipy/reference/integrate.html))\n",
    "* Optimization ([scipy.optimize](http://docs.scipy.org/doc/scipy/reference/optimize.html))\n",
    "* Interpolation ([scipy.interpolate](http://docs.scipy.org/doc/scipy/reference/interpolate.html))\n",
    "* Fourier Transforms ([scipy.fftpack](http://docs.scipy.org/doc/scipy/reference/fftpack.html))\n",
    "* Signal Processing ([scipy.signal](http://docs.scipy.org/doc/scipy/reference/signal.html))\n",
    "* Linear Algebra ([scipy.linalg](http://docs.scipy.org/doc/scipy/reference/linalg.html))\n",
    "* Sparse Eigenvalue Problems ([scipy.sparse](http://docs.scipy.org/doc/scipy/reference/sparse.html))\n",
    "* Statistics ([scipy.stats](http://docs.scipy.org/doc/scipy/reference/stats.html))\n",
    "* Multi-dimensional image processing ([scipy.ndimage](http://docs.scipy.org/doc/scipy/reference/ndimage.html))\n",
    "* File IO ([scipy.io](http://docs.scipy.org/doc/scipy/reference/io.html))\n",
    "\n",
    "Each of these submodules provides a number of functions and classes that can be used to solve problems in their respective topics.\n",
    "\n",
    "To access the SciPy package in a Python program, we start by importing everything from the `scipy` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we only need to use part of the SciPy framework we can selectively include only those modules we are interested in. For example, to include the linear algebra package under the name `la`, we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.linalg as la"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# matplotlib - plotting in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib is an excellent 2D and 3D graphics library for generating scientific figures. Some of the many advantages of this library include:\n",
    "\n",
    "* Easy to get started\n",
    "* Support for $\\LaTeX$ formatted labels and texts\n",
    "* Great control of every element in a figure, including figure size and DPI. \n",
    "* High-quality output in many formats, including PNG, PDF, SVG, EPS, and PGF.\n",
    "* GUI for interactively exploring figures *and* support for headless generation of figure files (useful for batch jobs).\n",
    "\n",
    "One of the key features of matplotlib that I would like to emphasize, and that I think makes matplotlib highly suitable for generating figures for scientific publications is that all aspects of the figure can be controlled *programmatically*. This is important for reproducibility and convenient when one needs to regenerate the figure with updated data or change its appearance. \n",
    "\n",
    "More information at the Matplotlib web page: http://matplotlib.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get started using Matplotlib in a Python program, either include the symbols from the `pylab` module (the easy way):\n",
    "\n",
    "`Matplolib`\n",
    "It's a Python plotting library, inspired by MATLAB, meaning that the terms used (Axis, Figure, Plots) will be similar to those used in MATLAB.\n",
    "\n",
    "It can be used both within a Python system (via the object-oriented API) but also in more convenient form in Jupyter and IPython notebooks via the Pyplot interface.\n",
    "\n",
    "`Pyplot`\n",
    "PyPlot is a shell-like interface to Matplotlib, to make it easier to use for people who are used to MATLAB. Pyplot maintains state across calls. Useful for use in Jupyter or IPython notebooks.\n",
    "\n",
    "Your can import it via the matplotlib.pyplot namespace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pylab import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or import the `matplotlib.pyplot` module under the name `plt` (the tidy way):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple figure with MATLAB-like plotting API:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 5, 10) # Shift-Tab for help\n",
    "y = x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure()\n",
    "plot(x, y, 'r')\n",
    "xlabel('x')\n",
    "ylabel('y')\n",
    "title('title')\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the plotting related functions in MATLAB are covered by the `pylab` module. For example, subplot and color/symbol selection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "subplot(1,2,1)\n",
    "plot(x, y, 'r--')\n",
    "subplot(1,2,2)\n",
    "plot(y, x, 'g*-');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The good thing about the pylab MATLAB-style API is that it is easy to get started with if you are familiar with MATLAB, and it has a minumum of coding overhead for simple plots. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The matplotlib object-oriented API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main idea with object-oriented programming is to have objects that one can apply functions and actions on, and no object or program states should be global (such as the MATLAB-like API). The real advantage of this approach becomes apparent when more than one figure is created, or when a figure contains more than one subplot. \n",
    "\n",
    "To use the object-oriented API we start out very much like in the previous example, but instead of creating a new global figure instance we store a reference to the newly created figure instance in the `fig` variable, and from it we create a new axis instance `axes` using the `add_axes` method in the `Figure` class instance `fig`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "\n",
    "axes = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # left, bottom, width, height (range 0 to 1)\n",
    "\n",
    "axes.plot(x, y, 'r')\n",
    "\n",
    "axes.set_xlabel('x')\n",
    "axes.set_ylabel('y')\n",
    "axes.set_title('title');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although a little bit more code is involved, the advantage is that we now have full control of where the plot axes are placed, and we can easily add more than one axis to the figure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "\n",
    "axes1 = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes\n",
    "axes2 = fig.add_axes([0.2, 0.5, 0.4, 0.3]) # inset axes\n",
    "\n",
    "# main figure\n",
    "axes1.plot(x, y, 'r')\n",
    "axes1.set_xlabel('x')\n",
    "axes1.set_ylabel('y')\n",
    "axes1.set_title('title')\n",
    "\n",
    "# insert\n",
    "axes2.plot(y, x, 'g')\n",
    "axes2.set_xlabel('y')\n",
    "axes2.set_ylabel('x')\n",
    "axes2.set_title('insert title');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we don't care about being explicit about where our plot axes are placed in the figure canvas, then we can use one of the many axis layout managers in matplotlib. My favorite is `subplots`, which can be used like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots()\n",
    "\n",
    "axes.plot(x, y, 'r')\n",
    "axes.set_xlabel('x')\n",
    "axes.set_ylabel('y')\n",
    "axes.set_title('title');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEWCAYAAABhffzLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAiMElEQVR4nO3de7xVc/7H8ddnuhC5pePOhBoVuR7MaBiTyyBNGf0ajBiGECaX3CbGrcgMEpV0Y0dKTSqXJGGQwTi5K+SSMF1OU0opder7++N79jhjup1z1trftdZ+Px+P8zjn7L3PXp/Nd336ru/6fj9fc84hIiLF40ehAxARkcJS4hcRKTJK/CIiRUaJX0SkyCjxi4gUGSV+EZEio8SfUma2m5ktNbM663mNM7OmhYxLpDbUrgtDiT9FzGyWmR0N4Jyb7Zxr6JxbXfnc383snLARilSf2nXhKfGLiBQZJf6UMLMHgd2Axysvha+svOSta2a9gMOBfpXP9VvL329iZreb2Wwzm2dmA82sQaE/h0hVatdhKPGnhHOuMzAbaOecawiMrvJcD+Al4KLKy+SL1vIWvYGfAPsDTYGdgT/HHbfI+qhdh6HEXwTMzIAuwKXOuYXOuW+AW4BTwkYmUnNq1zVXN3QAUhAlwGbANH+uAGDAOmdOiKSA2nUNKfGny/pKqa7vuQXAcmBv59xX0YYkUmtq1wWmoZ50mQfsUd3nnHNrgMFAHzPbDsDMdjazX8USpUj1qF0XmBJ/utwKXGtmXwMdf/BcX6CjmS0ys7vX8rdXAR8Dr5rZEmAKsFecwYpsJLXrAjNtxCIiUlzU4xcRKTJK/CIiRUaJX0SkyCjxi4gUmVTM42/cuLFr0qRJ6DAko6ZNm7bAOVcS4thq2xKndbXtVCT+Jk2aUFZWFjoMySgz+zzUsdW2JU7ratsa6hERKTJK/CIiRUaJX0SkyCjxi4gUGSV+EZEiE1viN7Ndzex5M5tuZu+bWbfKx28ws6/M7K3KrxPiikEkDmrbknZxTuesAC53zr1hZlvgN0t4pvK5Ps6522M8tkic1LYl1WLr8Tvn5jjn3qj8+RtgBn4/TJHCev55uP12WL48krdT25bE6N0bJk+u9p8VZIzfzJoABwCvVT50kZm9Y2bDzGybdfxNFzMrM7Oy8vLyQoQpWXX33T7x16sX+VurbUsw8+fDddfBlCnV/tPYE7+ZNQTGApc455YA9wJ7AvsDc4A71vZ3zrlBzrlS51xpSUmQ1fSSBQsWwJNPwu9+B3WjHdlU25agRo6Eigo488xq/2msid/M6uFPjBHOuUcBnHPznHOrq2ybdkicMUiRGzUKVq2q0cmxPmrbElwuBwcdBHvvXe0/jXNWjwFDgRnOuTurPL5jlZedBLwXVwwi5HKw//6w776RvaXatgT37rvw5ps17tDEOaunNdAZeNfM3qp87E/AqWa2P+CAWcB5McYgxWz6dCgrgz59on5ntW0JK5fz96xOPbVGfx5b4nfOTQVsLU9NjOuYIv8ll/Pj+qedFunbqm1LUBUV8NBD0LYtNG5co7fQyl3JptWr/clx/PGw3XahoxGJzuTJMG8enHFGjd9CiV+yacoU+Ne/anVyiCRSLgfbbut7/DWkxC/ZlMvBNttAu3ahIxGJzqJFMGGCH9uvX7/Gb6PEL9mzZAmMGwennAKbbBI6GpHojBkD331X6+nJSvySPWPGwIoVkc/dFwkul4OWLf38/VpQ4pfsyeVgr73gEK2fkgyZORP+8Q/fobG1TSrbeEr8ki2ffgovvRTJySGSKMOHw49+5MuP1JISv2TL8OE+4XfuHDoSkeisWePb9tFHw861LwSrxC/ZkT85jjoKdtkldDQi0XnhBZg9O7L7Vkr8kh1Tp8Jnn2nuvmRPLgdbbAEdOkTydkr8kh25HDRsCL/5TehIRKKzdCn87W/QqRNstlkkb6nEL9nw7bd+GmfHjrD55qGjEYnOuHGwbFmk05OV+CUbxo+Hb77R3H3JnlwOdt8dfv7zyN5SiV+yIZeDH/8YjjgidCQi0fniC3juOX/fKsLpyUr8kn5ffeWLsp1xhp/nLJIVDz4IzkU+YUFniaTfQw/5qZyazSNZ4py/kj38cNhjj0jfWolf0i1/chx2GDRtGjoakei89hp89FEs962U+CXdyspgxgzd1JXsyeWgQQP4v/+L/K2V+CXdcjlferlTp9CRiERnxQoYNQpOOgm23DLyt1fil/RauRJGjvSrGbfeOnQ0ItF54gn4+uvY7lsp8Ut6PfkkLFyoYR7JnlwOdtrJF2WLgRK/pFcuBzvsAMccEzoSkejMmwdPPQWnnw516sRyCCV+Safyct/jP/10qFs3dDQi0Xn4YVi9OtYrWSV+SaeRI6GiQsM8kj25HJSW+i0WY6LEL+mUy8EBB8A++4SORCQ6b7/tv2Lu0CjxS/q89x688YZ6+5I9uRzUqwennBLrYZT4JX1yOT+uf9ppoSMRic6qVTBiBLRtC40bx3ooJX5Jl4oKX5vnhBOgpCR0NCLRmTwZ5s8vyJWsEr+ky5QpMHeuhnkke3I52HZb36mJmRK/pEsuB40a+cthkaxYtAgmTPDDl/Xrx344JX5Jj8WL/U5bp57q6/OIZMUjj/gSJAW6ko0t8ZvZrmb2vJlNN7P3zaxb5eONzOwZM5tZ+X2buGKQjBk92hevClx3X21bIpfLwd57w4EHFuRwcfb4K4DLnXMtgZ8CF5pZS+Bq4FnnXDPg2crfRTYsl4PmzeHgg0NHorYt0fnwQ3j11ci3V1yf2BK/c26Oc+6Nyp+/AWYAOwPtgVzly3JAh7hikAz5+GN4+WV/KVygk2Nd1LYlUsOH+y1DTz+9YIcsyBi/mTUBDgBeA7Z3zs2pfGousP06/qaLmZWZWVl5eXkhwpQkGz7cJ/wCnhwbQ21bamXNGr+v7jHH+GqcBRJ74jezhsBY4BLn3JKqzznnHODW9nfOuUHOuVLnXGmJ5msXt9WrfeI/+mjYZZfQ0fyH2rbU2nPPwRdfFHx6cqyJ38zq4U+MEc65RysfnmdmO1Y+vyMwP84YJAOeego+/xzOPTd0JP+hti2RGDDAz93v0KGgh41zVo8BQ4EZzrk7qzz1GJD/5+1MYEJcMUhG9OvnL4MLfHKsi9q2RGL2bD93/5xz/N66BRRnj7810BloY2ZvVX6dAPQGjjGzmcDRlb+LrN3MmfD003Deeb54VTKobUvt3XcfOAfnn1/wQ8e2g4VzbiqwrukXR8V1XMmYAQN8wu/SJXQk/6G2LbX23XcweDC0awdNmhT88Fq5K8m1bBncfz+cfLLfYlEkK8aM8bvIXXhhkMMr8UtyjRjhyzRcdFHoSESi1a8f/OQnsW2mviFK/JJMzkH//rDffnDYYaGjEYlOWRm89hp07eoXbgWgXaolmaZOhXfe8eOggVfqikSqf3/YfPOgpcXV45dk6t8ftt5au2xJtvz73zBypF+BvvXWwcJQ4pfkmTMHxo6Fs8+GzTYLHY1IdIYO9TN6At3UzVPil+QZNMhvsXjBBaEjEYnO6tVw771wxBHQqlXQUJT4JVlWrfILW44/Hpo2DR2NSHQmToRZsxIxS003dyVZxo3zQz2DB4eORCRa/fsnpvSIevySLP36we67w3HHhY5EJDoffZSo0iNK/JIc77wDL73k5zfXqRM6GpHo3Hsv1K2bmAqzSvySHP37w6ab+tk8IlmRLz3SsSPsuGPoaAAlfkmKr7+Ghx7y8/YbNQodjUh08qVHAk/hrEqJX5LhgQfg228TdXKI1FrV0iOtW4eO5j80q0fCW7PGl1/+2c/gwANDRyMSnXzpkUGDElV6RD1+Ce+ZZ/yGK+rtS9YktPSIEr+E178/bLedv/klkhX50iNnneWLsiWIEr+E9dln8MQTfprbJpuEjkYkOvnSI127ho7kfyjxS1gDB/qa5OedFzoSkegkvPSIbu5KOMuXw5Ah0L497Lpr6GhEopPw0iPq8Us4jzwCCxcmomiVSKT69YM99khs6RElfgnDOX9ytGwJRx4ZOhqR6ORLj1xwQWJLjyjxSxj//CdMm+ancCZofrNIraWg9IgSv4TRrx9ssQV07hw6EpHopKT0iBK/FN78+TB6tN9seostQkcjEp2UlB5R4pfCGzIEVq5M5PxmkRpLUekRJX4prIoKX5v8qKOgRYvQ0YhEJ196JAWz1JT4pbAefxy+/DLxl8Ii1ZYvPXLyyaEj2SAlfimsfv38Yq127UJHIhKdfOmRLl1SUXpEiV8KZ8YMeO45OP98vw2dSFakrPRIbInfzIaZ2Xwze6/KYzeY2Vdm9lbl1wlxHV8SqH9/qF8fzjkndCS1orYt/yVfeqRDB9hll9DRbJQ4e/wPAGtbr9zHObd/5dfEGI8vSbJkCeRy0KmTHwdNtwdQ25a8fOmRFN23ii3xO+deBBbG9f6SMkOGwNKlqZjxsCFq2/Ifa9bAnXfC3nunqvRIiDH+i8zsncrL5W3W9SIz62JmZWZWVl5eXsj4JGorVsBf/wpt2sChh4aOJk5q28Xm8cfh3XfhmmtSVXqk0In/XmBPYH9gDnDHul7onBvknCt1zpWWlJQUKDyJxbBhMHcuXHtt6EjipLZdbJyDnj1hzz3ht78NHU21FHRqhXNuXv5nMxsMPFHI40sAK1fCbbfBYYel6lK4utS2i9DkyVBW5ocxUzZLraA9fjPbscqvJwHvreu1khEPPQSzZ/vefoouhatLbbvIOAc33+zXpKSw0GBs/0yZ2UjgSKCxmX0JXA8caWb7Aw6YBaRj0qvUTEUF3Hqrr1uS0A0pakJtW3jxRXj5Zb8gsX790NFUW2yJ3zl36loeHhrX8SSBRo+Gjz+GRx/NVG9fbVvo2RN22CHRNffXRyt3JR5r1kCvXn6aW/v2oaMRic6rr8KUKdC9OzRoEDqaGknXHQlJj/HjYfp0ePhhv5RdJCt69YJtt01NeYa10Rkp0ctPc2vWzK/UFcmKN9/0xdguvRQaNgwdTY2pxy/RmzjRnyDDhiV2s2mRGunVC7baKvUr0NXjl2jlp7ntthucfnroaESi8/77MHYsXHyxT/4pph6/ROu55+C11/wWdPXqhY5GJDq33gqbbw7duoWOpNbU45do9ewJO+4IZ50VOhKR6Hz8MYwcCRdcAI0bh46m1tTjl+hMnQp//7uvVrjppqGjEYlO795+odbll4eOJBLq8Ut0evWCkhK//ZxIVsye7feSOPdcv2grA5T4JRplZTBpElx2mR8HFcmKv/zFrzy/4orQkURGiV+i0asXbL01dO0aOhKR6MyZ46tv/v73viBbRijxS+29+65fqdutG2y5ZehoRKJzxx2+2ODVV4eOJFJK/FJ7t9ziVzH+8Y+hIxGJzoIFcO+9cNppsMceoaOJ1AYTv5ldvL5t5KTIffih32z6wguhUaPQ0VTLPffcw6JFi0KHIUl1112wfLnfVjFjNqbHvz3wupmNNrPjzDJUX1dqr3dvP3XzsstCR1Jt8+bN4+CDDwbYQ21b/svXX8M990DHjtCiRehoIrfBxO+cuxZohq83/ntgppndYmZ7xhybJN2sWfDgg3765nbbhY6m2nr27MnMmTMBFqC2LVX16wdLlkCPHqEjicVGjfE75xwwt/KrAtgG+JuZ/SXG2CTpbrvNF2Hr3j10JDVW2clfhdq25C1dCn36QLt2sN9+oaOJxcaM8Xczs2nAX4CXgVbOuQuAg4CTY45Pkuqrr3z1zbPOgl12CR1NjfTt25eDDjoIYBfUtiVv4EBYuDCzvX3YuJINjYDfOOc+r/qgc26NmZ0YT1iSeLffDqtXw1VXhY6kxhYuXMijjz5KkyZNZjrnxuQfV9suYsuX+7Z9zDFw6KGho4nNBhO/c+769Tw3I9pwJBXmz4f77vNll3ffPXQ0NXbjjTeu8zm17SI1dCjMmwfXXhs6klhpHr9UX58+sGJFJqe5SRFbudLftzr8cDjiiNDRxErVOaV6Fi70Mx46dYK99godjUh0hg+HL7/0vf6MU49fqueee/yshz/9KXQkItGpqPAbrRx8sB/fzzj1+GXjLVkCfftC+/aw776hoxGJzqhR8OmnfhizCNbxqccvG2/AAFi0KPM3vqTIrF7tq8vut5+fu18E1OOXjVNe7i+F27aF0tLQ0YhEZ+hQ+OADv5F6EfT2QT1+2VjXXQfffuvnOItkxeLF/gr2iCPgpJNCR1MwSvyyYe+8A4MH+wqczZuHjkYkOjff7Msv33VX0fT2QYlfNsQ5uOQSv7vWn/8cOhqR6MycCXffDWefDQccEDqagtIYv6zfhAnw/PN+7n7K6u2LrFf37r6keK9eoSMpOCV+WbfvvvMnR8uWcN55oaMRic6UKfDYY34/ie23Dx1NwcU21GNmw8xsvpm9V+WxRmb2jJnNrPyunb2S7O674ZNP/Nzmuuoj5Kltp1xFBVx6qd9O8ZJLQkcTRJxj/A8Ax/3gsauBZ51zzYBnK3+XJJo3z9/4atsWjj02dDRJ8wBq2+k1eDC89x789a+wySahowkitsTvnHsRWPiDh9sDucqfc0CHuI4vtXTddb5E7R13hI4kcdS2U+zrr33bPvLIopq++UOFntWzvXNuTuXPc/H7+a6VmXUxszIzKysvLy9MdOK99RYMGQIXX6xCbBtPbTsNbrrJFxossumbPxRsOmfldo5uPc8Pcs6VOudKS0pKChhZkctP32zUyPeMpNrUthPqww99kcFzzsnsloobq9CJf56Z7QhQ+X1+gY8vGzJuHLzwgh/f30b3J6tBbTvpuneHBg2gZ8/QkQRX6MT/GHBm5c9nAhMKfHxZn/z0zX32gXPPDR1N2qhtJ9nkyfDEE/4qdrvtQkcTXGxz9MxsJHAk0NjMvgSuB3oDo83sD8DnQKe4ji81cNdd8Nln/iTR9M11UttOmfz0zT33hD/+MXQ0iRDb2e2cO3UdTx0V1zGlFubO9SsY27Urio0oakNtO2Xuuw+mT/fDmEU6ffOHVKtHvGuv9fvoavqmZMnChb7GVJs2fgMhAZT4BeDNN2HYMH8Z3KxZ6GhEonPTTX7ufpHsrLWxlPiLXX765rbbamctyZYPPoD+/f1EBW0V+l90B6/YjR0LL74IAwf60ssiWXH55bDZZn5qsvwXJf5itmIFXHEFtGoFf/hD6GhEojNpEkyc6HeM0yK5/6HEX8z69IFZs+DZZzV9U7Jj1So/fbNpU192RP6HzvZiNWcO3HKLn+nQpk3oaESiM3CgH9+fMAHq1w8dTSLp5m6x6tHDr9TV5umSJf/+N1x/PRx9tF+TImulxF+Mpk2DBx7ws3maNg0djUh0brwRFi/W9M0NUOIvNvnpm40b+16/SFZMnw4DBvhtQvfZJ3Q0iaYx/mIzZgxMnQqDBsFWW4WORiQazsFll0HDhn7RlqyXEn8xWboUrrzS1yI/++zQ0YhE5/HH4emn4c47/dWsrJcSfzG59FKYPRtGjIA6dUJHIxKN+fP96txWreDCC0NHkwpK/MVi/Hi/neI110Dr1qGjEYmGcz7pf/01TJmi6ZsbSYm/GMyd60+OAw+EG24IHY1IdIYOhcce81VlW7UKHU1qaFZP1jnnyzEsXQoPPaQekWTHxx/7GWpt2vjvstHU48+6++7zNUvuvhtatAgdjUg0Kiqgc2eoV8+vSfmR+rDVocSfZR9+6Ke4HXusbnpJttx6K7z6Kjz8MOy6a+hoUkf/TGbVqlVw+unQoAHcf796RJIdr7/uV+iedhqcuq5dMGV91OPPqptvhrIyv2Brp51CRyMSjWXLfIdmp538JitSI0r8WfTKK37j9DPPhI4dQ0cjEp3u3WHmTF9KXBsH1Ziu/7Nm6VJ/02u33fwNXZGsePJJX3L5ssvgl78MHU2qqcefNZdeCp9+Ci+8AFtuGToakWiUl/tpya1a+atZqRUl/iyZMMGvzr36ajj88NDRiEQjvzp30SJ45hnYZJPQEaWeEn9WzJ0L55wDBxzgZzyIZMWwYb5To9W5kdEYfxZoda5k1SefQLduWp0bMfX4s6Dq6tyWLUNHIxINrc6NjRJ/2n30EVx+uVbnSvbcequfmqzVuZHTP6Fpll+du+mmWp0r2aLVubFSjz/Nbr7ZnyBanStZotW5sQuS+M1sFvANsBqocM6Vhogj1fKrc884Q6tzE0RtOwJXXKHVuTEL2eP/pXNuQcDjp1d+de6uu2p1bjKpbdfUxIlw773+vpVW58ZGQz1pVHV17lZbhY5GJBrl5XD22VqdWwCh7gY6YLKZTTOzLmt7gZl1MbMyMysrLy8vcHgJNmqUX5171VVanZtMats1UVEBv/+9X507YoRW58YsVOL/uXPuQOB44EIzO+KHL3DODXLOlTrnSktKSgofYRI9/7yvuNm6tVbnJpfadnU5Bxdc4Id5+vbV6twCCJL4nXNfVX6fD4wDDgkRR6q8/TZ06ABNm/rNpbU6N5HUtmvghhv8VWyPHnD++aGjKQoFT/xmtrmZbZH/GTgWeK/QcaTKrFlw3HG+2uakSdCoUeiIZC3Utmtg4EC46SY/tn/zzaGjKRohbu5uD4wzs/zxH3bOTQoQRzosWAC/+hWsWAFTp2oFY7KpbVfHuHF+tfmJJ/qyI/6/mxRAwRO/c+5TYL9CHzeVli2Dtm1h9myYMgX23jt0RLIeatvV8NJLfkXuIYfAI49AXU0wLCT9106qVaugUye/b+7Ysf6GrkgWvPce/PrX0KQJPPEEbLZZ6IiKjhJ/EjkHXbr4WQ733edv6opkwezZ/n7VZpvB00/DttuGjqgoKfEnUY8evgztDTf4fwBEsmDhQp/0ly71Qz0//nHoiIqWEn/S3HOPL0fbpQv8+c+hoxGJxvLl0K6d31hl8mTN1Q9MiT9Jxozxuw116AADBmiWg2RDRQWccoovLDh6NPziF6EjKnpK/Enx97/7UrStW/uNJ+rUCR2RSO05B127+kWH/furkmxCaOeOJHj7bWjfHpo18ydIgwahIxKJxo03wuDB/r5V166ho5FKSvyhzZoFxx/vV+U+9RRss03oiESiMXCgT/xalZs4GuoJacECP8th+XKtypVs0arcRFPiD2XZMn9SfP65VuVKtmhVbuLp/0gI+VW5r78Ojz6qVbmSHVVX5T7+uFblJpTG+Att+XK/T25+i7n27UNHJBKNd9/1Q5cNGvhVuY0bh45I1kGJv5A+/9zvmjVqFNx2m1blSnaMGgU//amfvjlpklblJpwSf6E89xyUlsLMmf4S+MorQ0ckUnsVFdC9ux/TP/BAmDYN9t03dFSyAUr8cXMO7rgDjjkGttvOj+ufeGLoqERqr7zc7xVxxx1w0UXw7LOwww6ho5KNoJu7cVq2DM45x18Gd+wIw4bBFluEjkqk9qZNg9/8BubP9wUFzzwzdERSDerxx+WTT+BnP/O1SXr39t+V9CULcrnvZ6JNnaqkn0Lq8cdh0iQ/5mnmV+Mee2zoiERqb+VKuOwyX3OnTRt/JVtSEjoqqQH1+KO0Zg306gUnnOBnNUybpqQv2TB3Lhx1lE/63bv76ZpK+qmlHn9Ulizxl7zjx8PvfgeDBmnximTDK6/AySfD4sUwcqQvsSypph5/FD74AA491E/T7NMHHnxQSV/SzzlfZ+cXv/CLsl55RUk/I9Tjr63x4/1K3E039TV3jjwydEQitbdihZ+iOXSorx47YoQqx2aIevw1tXo1XHcdnHQSNG/ux/OV9CULvvgCjjjCJ/0ePfyVrJJ+pqjHXxMzZvjZDZMm+Vrj/fv7Hr9Imq1eDWPHwsUX+5pS48b5bUAlc9Tjr45p0/xCrL33hhde8EXWhgxR0pd0W7kS7r8fWraE3/7WrzD/5z+V9DNMiX9DnIMXX/RVB0tL/Th+jx6+4Nr552uDCUmvb7+Fe+6Bpk39levmm8OYMfDWW374UjJLQz3r4pxffHXLLfDyy74X1Ls3XHCB3yZRJK0WL4YBA/wMtPJyXzF20CBfd0cdmaKgxP9D+XHOW27xm6Dvthv06+d7RNoEXdJs/nzo29e35yVL/Gyda67xiV+KihJ/3sqVfv79bbf50snNm/viU6edBvXqhY5OpOa++AJuvx0GD/bTNDt29An/gANCRyaBKPEvW+Zv0N5+O3z5JRx0kO/xd+gAP9ItEEmxjz7yHZnhw/3vnTvDVVfBXnuFjUuCK87Ev3Kl79WPHw933QULFvjViUOH+rr5GueUtFq4EN55x884GzPGzzjr2hUuv9wPW4oQKPGb2XFAX6AOMMQ51zuWAy1e7MspzJjhv/I/f/qpH8sHaNvWX/Zqw3OJQEHa9po1/uq0apvO/zx/vn/Nllv6dt2tm5+YIFJFwRO/mdUB+gPHAF8Cr5vZY8656TV6Q+fgX/9a+0kwZ873r6tfH5o1g/328/VGmjf30zN/8pMIPpVIDG07f2Wab9f57x9+6Ico8xo1ghYt4Ne/9u26eXP4+c9hq60i+FSSRSF6/IcAHzvnPgUws1FAe6D6J0ebNlBWBt988/1jW23lT4Jf/cp/b9HCnwi77w51i3NkSwommrb90kt+57ZPPvn+yhT8UE2LFr6cQvPm37fvxo01PCnVEiIT7gx8UeX3L4FDf/giM+sCdAHYbV1jk82b+1W0VRP8DjvoJJBQomnbJSXQqhV06vR9gt9rL7/ASiQCie0CO+cGAYMASktL3VpfNGBAIUMSicQG23bz5vC3vxU6LCkiIeYrfgXsWuX3XSofE0k7tW1JhRCJ/3WgmZntbmb1gVOAxwLEIRI1tW1JhYIP9TjnKszsIuBp/JS3Yc659wsdh0jU1LYlLYKM8TvnJgITQxxbJE5q25IGqkkgIlJklPhFRIqMEr+ISJFR4hcRKTLm3NrXRiWJmZUDn6/j6cbAggKGU0hZ/myQnM/3Y+dcSYgDr6dtJ+W/TVyy/PmS9NnW2rZTkfjXx8zKnHOloeOIQ5Y/G2T/89VG1v/bZPnzpeGzaahHRKTIKPGLiBSZLCT+QaEDiFGWPxtk//PVRtb/22T58yX+s6V+jF9ERKonCz1+ERGpBiV+EZEik9rEb2bHmdmHZvaxmV0dOp4omdmuZva8mU03s/fNrFvomKJmZnXM7E0zeyJ0LEmT1batdp0cqUz8VTa1Ph5oCZxqZi3DRhWpCuBy51xL4KfAhRn7fADdgBmhg0iajLdtteuESGXip8qm1s65lUB+U+tMcM7Ncc69UfnzN/iGtHPYqKJjZrsAbYEhoWNJoMy2bbXr5Ehr4l/bptaZaUBVmVkT4ADgtcChROku4EpgTeA4kqgo2rbadVhpTfxFwcwaAmOBS5xzS0LHEwUzOxGY75ybFjoWCUPtOry0Jv7Mb2ptZvXwJ8cI59yjoeOJUGvg12Y2Cz+M0cbMHgobUqJkum2rXSdDKhdwmVld4CPgKPxJ8TpwWlb2NzUzA3LAQufcJYHDiY2ZHQl0d86dGDiUxMhy21a7To5U9vidcxVAflPrGcDoLJwYVbQGOuN7DW9Vfp0QOiiJX8bbttp1QqSyxy8iIjWXyh6/iIjUnBK/iEiRUeIXESkySvwiIkVGiV9EpMgo8YuIFBklfhGRIqPEnxFmdrCZvWNmm5rZ5pX1zvcJHZdIbaltR08LuDLEzHoCmwINgC+dc7cGDkkkEmrb0VLizxAzq4+v7bICOMw5tzpwSCKRUNuOloZ6smVboCGwBb53JJIVatsRUo8/Q8zsMXxJ2N2BHZ1zFwUOSSQSatvRqhs6AImGmZ0BrHLOPVy5b+s/zKyNc+650LGJ1IbadvTU4xcRKTIa4xcRKTJK/CIiRUaJX0SkyCjxi4gUGSV+EZEio8QvIlJklPhFRIrM/wNWe9o7mptlcQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(nrows=1, ncols=2)\n",
    "\n",
    "for ax in axes:\n",
    "    ax.plot(x, y, 'r')\n",
    "    ax.set_xlabel('x')\n",
    "    ax.set_ylabel('y')\n",
    "    ax.set_title('title')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That was easy, but it isn't so pretty with overlapping figure axes and labels, right?\n",
    "\n",
    "We can deal with that by using the `fig.tight_layout` method, which automatically adjusts the positions of the axes on the figure canvas so that there is no overlapping content:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(nrows=1, ncols=2)\n",
    "\n",
    "for ax in axes:\n",
    "    ax.plot(x, y, 'r')\n",
    "    ax.set_xlabel('x')\n",
    "    ax.set_ylabel('y')\n",
    "    ax.set_title('title')\n",
    "    \n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Figure size, aspect ratio and DPI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib allows the aspect ratio, DPI and figure size to be specified when the `Figure` object is created, using the `figsize` and `dpi` keyword arguments. `figsize` is a tuple of the width and height of the figure in inches, and `dpi` is the dots-per-inch (pixel per inch). To create an 800x400 pixel, 100 dots-per-inch figure, we can do: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x400 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8,4), dpi=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same arguments can also be passed to layout managers, such as the `subplots` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs0AAADgCAYAAAD44ltAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAgKElEQVR4nO3de5id87338fc3k6MkIomISMRInOpQoVPiTEscIqiWOhS7paGbbjZF97YfevA8tVuHavEQlW1XhabKLnGuU5xJRJAoKpEQIUI0SeU8v+eP38wzSUxMUrPmnjXr/bqu+5q17nvNrO9YyOf65Xt/f5FSQpIkSdKatSu6AEmSJKm1MzRLkiRJTTA0S5IkSU0wNEuSJElNMDRLkiRJTTA0S5IkSU0wNEtSmYqIgRGxMCKqPuM1KSK2aMm6JKktMjRLUhmJiLciYn+AlNLMlFK3lNKKumuPRsQpxVYoSW2ToVmSJElqgqFZkspERNwEDATuqmvLOK+u/aJ9RPxvYC/gqrprVzXy/Z0i4tKImBkR70fEtRHRpaV/D0kqR4ZmSSoTKaUTgJnAiJRSN2DsStcuAB4Hzqhr2TijkR9xCbAVMATYAugPXFjquiWpLTA0S1IFiIgARgL/mlL6KKW0APg/wDHFViZJ5aF90QVIklpEH2A9YGLOzwAEsMbJG5KkBoZmSSov6R+8NhdYBGyXUprVvCVJUttne4YklZf3gUHrei2lVAtcD1wRERsBRET/iDiwJFVKUhtjaJak8vIz4D8i4mPgG6tduxL4RkTMi4hfNfK95wN/BZ6JiPnAn4GtS1msJLUVkdJn/W2eJEmSJFeaJUmSpCYYmiVJkqQmGJolSZKkJhiaJUmSpCYYmiVJkqQmlMXmJhtuuGGqrq4uugxJkiS1cRMnTpybUuqz+vmyCM3V1dVMmDCh6DIkSZLUxkXEjMbO254hSZIkNcHQLEmSJDWhZKE5IjaNiEciYmpETImIM+vO/ygiZkXEi3XHIaWqQZIkSWoOpexpXg6ck1J6ISK6AxMj4sG6a1eklC4t4XtLkiRJzaZkK80ppdkppRfqHi8AXgX6l+r9JEmSVOY++QSuuQbOP7/oSj6lRXqaI6Ia2Al4tu7UGRHxUkSMjoiea/iekRExISImfPDBBy1RpiRJkoowdy78+Mew2WZw+unw1FOwfHnRVa2i5KE5IroBfwTOSinNB/4vMBgYAswGLmvs+1JKo1JKNSmlmj59PjUqT5IkSeVu+nT4/vdh4ED40Y9g6FAYPz4f7VvXZOSSVhMRHciB+eaU0u0AKaX3V7p+PTCulDVIkiSplZk4EX7xC/jDH6CqCr71LfjBD2DbbYuubI1KFpojIoAbgFdTSpevdL5fSml23dOvAa+UqgZJkiS1EinBAw/ksPzQQ9C9O5xzDpx5JvRv/be9lXKleQ/gBODliHix7ty/A8dGxBAgAW8Bp5awBkmSJBVp2TIYOzaH5cmTYZNN4Oc/h5EjoUePoqtbayULzSmlJ4Bo5NI9pXpPSZIktRILF8INN8Dll8PMmfCFL8Do0XDccdCpU9HVrbPW1WEtSZKk8vb++/DrX+fRcfPmwV57wdVXwyGHQLvy3Yza0CxJkqTP74034LLL4MYbYelSOOIIOPdc2G23oitrFoZmSZIk/eOefTb3KN9xB3TsCCedlG/w22qroitrVoZmSZIkrZvaWrj33hyWx4+HDTaAf/u3PHN5442Lrq4kDM2SJElaO0uXwpgxcOmlMGUKbLopXHEFnHxyHiHXhhmaJUmS9Nnmz4dRo+CXv4RZs2CHHeCmm+Cb34QOHYqurkUYmiVJktS4d9+FK6+Ea6/NwfkrX8lj5IYNg2hssnDbZWiWJEnSql59Nbdg3HQTrFgB3/hGnoRRU1N0ZYUxNEuSJClvc/3kk/nmvrvugi5d8q59Z58NgwYVXV3hDM2SJEmVrLYW7rwzh+Wnn4beveGii+D006FPn6KrazUMzZIkSZVo8eLcfnHppfD667D55nDVVfDtb8N66xVdXatjaJYkSaok8+blG/uuvDJveb3zznDrrfD1r0N7o+Ga+E9GkiSpEsycmUfGXX89LFwIBx4I550H++1XcZMw/hGGZkmSpLbs5ZfhF7+AW27JN/sdc0yehLHjjkVXVlYMzZIkSW1NSvDoo/nmvvvug65d4Ywz4KyzYLPNiq6uLBmaJUmS2ooVK+D223NYnjABNtoILr4Yvvc96NWr6OrKmqFZkiSp3H3yCdx4I1x2GUybBltuCdddByeeCJ07F11dm2BoliRJKlcffghXXw2//jXMnQu77pr7lw8/HKqqiq6uTTE0S5IklZvp0+Hyy2H06LzKfOiheRLGnns6CaNEDM2SJEnl4oUX8kry2LF5Jfn44+EHP4Dttiu6sjavXal+cERsGhGPRMTUiJgSEWfWne8VEQ9GxBt1X3uWqgZJkqSylxI88AAccAB86Utw991wzjl5tfm//svA3EJKFpqB5cA5KaVtgaHA6RGxLfBD4KGU0pbAQ3XPJUmStLJly2DMGNhpp7wRyZQp8J//CW+/nadj9O9fdIUVpWTtGSml2cDsuscLIuJVoD9wOLBv3cv+G3gUOL9UdUiSJJWVhQvhhhvgiitgxgz4whfy8+OPh06diq6uYrVIT3NEVAM7Ac8CfesCNcB7QN+WqEGSJKlVmzMnT8G4+mqYNy/f1PfrX8Pw4dCulM0BWhslD80R0Q34I3BWSml+rHRHZ0opRURaw/eNBEYCDBw4sNRlSpIkFeOVV+Cqq/Kc5aVL4Ygj8jbXu+1WdGVaSUlDc0R0IAfmm1NKt9edfj8i+qWUZkdEP2BOY9+bUhoFjAKoqalpNFhLkiSVpcWL4Y9/hGuvhSeegI4d4aST8g1+W29ddHVqRCmnZwRwA/BqSunylS7dCZxU9/gk4E+lqkGSJKlVeeONvIo8YAB861vw3nt5hNysWTBqlIG5FSvlSvMewAnAyxHxYt25fwcuAcZGxMnADODoEtYgSZJUrGXL4E9/yqvKDz0E7dvnFozTToP99rNfuUyUcnrGE8CatqT5aqneV5IkqVWYMQOuvz5PvnjvPRg4EC6+GL7zHejXr+jqtI7cEVCSJKm5rFgB996bV5XvuSefGz48ryofdFDexU9lydAsSZL0ec2enVeUR43Km4/06wcXXACnnAKbbVZ0dWoGhmZJkqR/RG1t7lG+9trcs7xiRd7q+pe/hBEjoEOHoitUMzI0S5IkrYsPPsgzla+7Dt58E3r3hrPPhpEjYYstiq5OJWJoliRJakpKeZ7ytdfCbbflTUj22gt+8hM48kjo3LnoClVihmZJkqQ1+fhjuOmmHJanToUePeDUU/Ox3XZFV6cWZGiWJElaWUowYUIOyrfcAosWwS67wOjR8M1vwnrrFV2hCmBoliRJAli4EMaMyb3KL7wAXbvCCSfkVeWddy66OhXM0CxJkirbSy/lVeXf/Q4WLIAddoBrroHjj4f11y+6OrUShmZJklR5Fi2CP/whh+Wnn4ZOnXLrxWmnwdChEGva1FiVytAsSZIqx2uv5faLG2+EefNgq63g8svhpJOgV6+iq1MrZmiWJElt29KlcMcdOSw/8kjedOTII/Oq8j77uKqstWJoliRJbdP06Xlb69GjYc4cqK6Gn/0Mvv1t6Nu36OpUZgzNkiSp7Vi+HO6+O/cq339/XkUeMSKvKg8bBu3aFV2hypShWZIklb9Zs+A3v4Hrr8+PN9kELrwQTjkFBgwoujq1AYZmSZJUnmpr4YEHcq/yXXfl5wceCFdfDcOHQ3tjjpqP/zZJkqTyMmdO7lMeNSr3LffpA+eeC9/9LgwaVHR1aqMMzZIkqfVLCR57LPcq3347LFsG++6bb+z72tegY8eiK1QbZ2iWJEmt10cfwW9/m8Pya6/BBhvA6afnra232abo6lRBDM2SJKl1SQmefTYH5d//HhYvht12yxuSHH00dOlSdIWqQIZmSZLUOixYADffnMPy5MnQrVueqXzqqbDjjkVXpwpXsmGFETE6IuZExCsrnftRRMyKiBfrjkNK9f6SJKlMTJqUg3G/fvC97+XZytddB+++C9dcY2BWq1DKleYbgauA3652/oqU0qUlfF9JktTaffJJbr249lp47rnccnHMMXkTki9/2a2t1eqULDSnlMZHRHWpfr4kSSozy5fDww/DmDF5AsaCBbDttnDllXDCCdCzZ9EVSmtURE/zGRFxIjABOCelNK+xF0XESGAkwMCBA1uwPEmS1Gzqb+obMyavLM+ZAz16wFFHwUknwV57uaqsshAppdL98LzSPC6ltH3d877AXCABPwX6pZS+09TPqampSRMmTChZnZIkqZlNnZqD8i23wLRp0KkTjBgBxx0HBx8MnTsXXaHUqIiYmFKqWf18i640p5TeX6mg64FxLfn+kiSphN5+G269NU/AmDwZ2rWD/feHCy+EI47IK8xSmWrR0BwR/VJKs+uefg145bNeL0mSWrkPP4TbbsuryuPH53O77gq/+lWeqdy3b7H1Sc2kZKE5Im4B9gU2jIh3gIuAfSNiCLk94y3g1FK9vyRJKpG//x3uvDMH5fvuyzf4bbMN/PSncOyxMHhw0RVKza6U0zOObeT0DaV6P0mSVELLlsEDD+Sg/D//k0fGDRgA//qvuU95xx29oU9tmjsCSpKkxtXWwpNP5qD8hz/kVoxevfJ4uOOOgz33zH3LUgUwNEuSpAYpwUsvNUy+ePttWG89OPzwHJSHDYOOHYuuUmpxhmZJkpTHwt1ySw7LU6dCVRUceCBccgkcdhh061Z0hVKhDM2SJFWqOXNg7NgclJ9+Op/bc0+45hr4xjegT59i65NaEUOzJEmVZP78fCPfmDHw5z/DihXwxS/mFeVjjoHNNiu6QqlVMjRLktTWLVkC996bg/Jdd8HixVBdDeefn0fEbb990RVKrZ6hWZKktmjFCnjssRyUb7sN/va33G5xyin5hr6hQx0RJ60DQ7MkSW1FSjBxYg7Kt94Ks2fnG/i+9rUclL/6VejQoegqpbLUZGiOiO8Dv0spzWuBeiRJ0rp6/fWGyRevv56D8SGH5KB86KF5ZJykz2VtVpr7As9HxAvAaOD+lFIqbVmSJOkzvfsu/P73OShPmJBbLfbdF849F77+dejZs+gKpTalydCcUvqPiPhfwDDg28BVETEWuCGl9GapC5QkSXXmzYPbb89B+ZFHcjvGl74El10G3/wm9O9fdIVSm7VWPc0ppRQR7wHvAcuBnsBtEfFgSum8UhYoSVJFW7QIxo3LQfmee2DpUthiC7jwwjz5Yuuti65Qqghr09N8JnAiMBf4DXBuSmlZRLQD3gAMzZIkNafly+Ghh3JQvuMOWLAANt4Y/vmfc59yTY2TL6QWtjYrzb2AI1NKM1Y+mVKqjYhDS1OWJEkVJiV45pkclMeOzbv19egBRx2Vg/K+++atrSUVYm16mi/6jGuvNm85kiRVmKlT4eab8/SL6dOhUycYMSIH5YMPhs6di65QEs5pliSp5c2cmecojxkDkydDu3aw//5w0UVwxBF5hVlSq2JoliSpJbz/fu5PHjMGHn88n9t1V/jVr+Doo6Fv32Lrk/SZDM2SJJVCSnkVedw4uOsueO65fH6bbeCnP82TLwYPLrZGSWvN0CxJUnNZtAgefjiH5HHjYNasfH6XXeAnP4HDDoMvftHJF1IZMjRLkvR5zJqVA/K4cXlM3KJF0LUrDBuWt7A+5JA8Lk5SWTM0S5K0Lmpr87bV9UF50qR8vroaTjklB+V99slTMCS1GSULzRExGjgUmJNS2r7uXC/g90A18BZwdEppXqlqkCSpWSxYAH/+cw7Jd9+db+pr1w523x0uuSQH5W23te1CasNKudJ8I3AV8NuVzv0QeCildElE/LDu+fklrEGSpH/M9OkNq8mPPpq3r+7RAw46KIfkgw+G3r2LrlJSCylZaE4pjY+I6tVOHw7sW/f4v4FHMTRLklqD5cvzjnz1QXnKlHx+q63g+9/PQXmPPaBDh2LrlFSIlu5p7ptSml33+D1gjUMpI2IkMBJg4MCBLVCaJKnifPwx3H9/Dsn33AMffQTt28Pee8PJJ8Pw4Tk0S6p4hd0ImFJKEZE+4/ooYBRATU3NGl8nSdI6ef31hpFwjz8OK1bkNovhw/Nq8oEHuiOfpE9p6dD8fkT0SynNjoh+wJwWfn9JUqVZtiyH4/q2izfeyOe33x7OOy8H5V13haqqYuuU1Kq1dGi+EzgJuKTu659a+P0lSZVg7ly4994cku+7D+bPh44d4StfgTPPzKvK1dVFVympjJRy5Nwt5Jv+NoyId4CLyGF5bEScDMwAji7V+0uSKkhK+ca9+raLp5/O5zbeGI46Kq8m778/dOtWdKWSylQpp2ccu4ZLXy3Ve0qSKsjixXkUXH3bxYwZ+fzOO8OFF+agvPPOeZ6yJH1O7ggoSSofs2fnKRfjxsGDD8Lf/w5dusABB8AFF+Qtq/v3L7pKSW2QoVmS1HqllLepHjcut15MmJDPb7opnHhiXk3eb78cnCWphAzNkqTW5ZNP4KGHcki++2549928PfWuu8LFF8OIEbDDDm5ZLalFGZolScWbOTMH5HHj4OGHc79y9+55ZnL9ltUbbVR0lZIqmKFZktTyVqyA559vuIlv8uR8ftAgOPXUHJT33juPiZOkVsDQLElqGfPn55v37ror38z3wQd5Q5E99oCf/zy3XWy9tW0XklolQ7MkqTRSgmnTGlaTH3ss787Xs2dut6jfsrpXr6IrlaQmGZolSc0jJXj99RyOx4/Px9tv52tf+AKcdVYOyrvvDu3940dSefH/WpKkf0xtLbzySg7H9UF5zpx8rW/f3JN8/vlw0EEweHCxtUrS52RoliStneXL88zk+pD8xBMwb16+tummMGxYDsr77ANbbmlvsqQ2xdAsSWrckiV5M5H6VeQnn4SFC/O1LbeEI4/MIXnvvaG6utBSJanUDM2SpOyTT+CZZxpWkp95Js9LBthuu7wD3957w157wSabFFurJLUwQ7MkVar58/Pqcf1Ne88/n6dbtGsHQ4bAaac1hOQNNyy6WkkqlKFZkirFhx/mPuT6dotJk/LNfO3bQ00NnH12Dsl77AE9ehRdrSS1KoZmSWqr3nuvYRX5scfypAuATp1g6FC44IJ8097QodC1a7G1SlIrZ2iWpLZi5sxVZyS//no+37VrXj0+5pi8krzLLjk4S5LWmqFZkspRSvDXv646I3nGjHytR4/ch/zd7+aQvNNO0KFDsfVKUpkzNEtSOaithalTG1aRx4+H2bPztT59cjg+++zcbrH99lBVVWy9ktTGGJolqTVasQImT25YSX788XwjH0D//rDffg0zkrfZxo1EJKnEDM2S1BosXQoTJzasIj/xRB4JBzBoEIwYkVeR994bNt/ckCxJLayQ0BwRbwELgBXA8pRSTRF1SFJhFi2CZ59tCMlPP503F4G8cnzssQ0ryQMGFFurJKnQleb9UkpzC3x/SWo5CxfCU081tFs891xeXY6AL34RTj45ryTvtRdstFHR1UqSVmN7hiSVwrx5ucWifiV54sTcp1xVBV/6EvzLv+RV5D33hJ49i65WktSEokJzAh6IiARcl1IaVVAdkvT5LV6cNw6ZNCkfTz0FL72Ux8J17JjnIv/whzkk77YbdO9edMWSpHVUVGjeM6U0KyI2Ah6MiL+klMav/IKIGAmMBBg4cGARNUrSp330Ebz4Yg7HL76Yj1dfzavIkAPxl78MP/pRbrfYZRfo0qW4eiVJzaKQ0JxSmlX3dU5E3AHsAoxf7TWjgFEANTU1qcWLlFTZUso77NWH4/qvM2c2vGaTTfLGIYcfnr8OGZInW7RrV1DRkqRSafHQHBFdgXYppQV1j4cBP2npOiTp/1u2DP7yl0+vIM+bl69HwNZbw+67w+mn53A8ZIg37ElSBSlipbkvcEfkGaPtgTEppfsKqENSJVq4MPcb1wfkSZNyP/KSJfl6586www5w1FE5GO+0U37etWuRVUuSCtbioTmlNA3YsaXfV1IFev/9VVePJ02CN97IrRcAvXrlUHzGGQ3tFVtvDe0dLCRJWpV/Mkgqf7W1MG3ap/uPZ89ueE11dQ7Fxx/fsII8YIA760mS1oqhWVJ5WbIEpkxZNRxPngwLFuTrVVWw7bZwwAEN4XjHHZ2FLEn6XAzNklqvjz/OgXjlFeSpU2H58ny9W7cciE88saG9Yrvtcl+yJEnNyNAsqXgpwaxZn26vmD694TUbb5xD8fDhDSvIgwc73k2S1CIMzZJa1ooV8Nprnx7vNnduvh4BW26ZNwj57ncbVpA33ri4miVJFc/QLKl0PvkEXn551RXkl1+GRYvy9Y4d8zi3+s1B6se7uc20JKmVMTRLah5z5366veK11/JkC4ANNsgrxqed1tBesc020KFDYSVLkrS2DM2S1t7f/gZvvpmPadMavv7lL7knud7AgTkYH310w+55m23meDdJUtkyNEtqUFubw+/qobg+KH/00aqv79Mn34y3334N4XjIEOjdu4DiJUkqHUOzVGkWLcpTKVZfMX7zzXx+6dKG11ZV5RXiwYPzqvGgQfnx4MGw+eaw/vrF/R6SJLUgQ7PU1qSU+4sbC8XTpsG77676+u7dcwjefns47LCGUDxoUG6zcEtpSZIMzVJZWrYMZs5sPBRPm9awO169/v1zEB42rCEQ14fj3r3tNZYkqQmGZqm1mj9/zb3FM2fmecf1OnXKQXjQINhnn1VDcXU1dOlS2K8hSVJbYGiWilJbm1slGgvF06Y1bPZRr3fvHIKHDoXjjlu1jWKTTdwZT5KkEjI0S6W0eHHDTXerh+Lp0/P1elVVuYd48GA48shVQ/GgQdCjR3G/hyRJFc7QLH0eKcGHHzYeit98c9XZxQDduuUgvM02MHz4qm0UAwe60YckSa2UoVlqzJIl8MEH+Zg7t+Fx/fM5c/JK8bRpufd4Zf365RC8//6rhuJBg/JcY2+6kySp7Bia1fallKdJrB5+1xSIP/jg09Mn6rVrl3uL+/TJN9jtueeq0yg23xzWW69Ffz1JklR6hmaVn9ravDPd2oTf+mPlDTtW1qlTDsD1xxZbrPq8Tx/YcMOGxz17esOdJEkVyNCs4i1duuaw29i5jz7Kwbkx66/fEHAHDICddmo8/NYfXbvaLiFJkppkaFbzSgkWLly3VojVe4Lr1bdC1IfdbbddcwDecMN8dOrUsr+vJEmqCIWE5og4CLgSqAJ+k1K6pIg6tJqUYPnyfBNcY8f8+WsXhpcsafznd+y4atAdPHjNAbi+FaKqqmX/GUiSJDWixUNzRFQBVwMHAO8Az0fEnSmlqS1dS6GaCqhLluS2hc+6/nlf39j3pLT2v0P37g1Bt39/2HHHz+4H7tbNVghJklSWilhp3gX4a0ppGkBE3AocDrSu0DxtGjz+eOsJqE3p1OnTR8eOqz7v3r2hheGzjtW/b+XvXzkM2wohSZIqRBGhuT/w9krP3wF2Xf1FETESGAkwcODAlqlsZU8+Cf/0T41fW1OobCqgrs33rUuIrT86dHAFV5IkqYRa7Y2AKaVRwCiAmpqaZlySXUuHH553dDOgSpIkVbwiQvMsYNOVng+oO9e6rL9+PiRJklTxitil4Xlgy4jYPCI6AscAdxZQhyRJkrRWWnylOaW0PCLOAO4nj5wbnVKa0tJ1SJIkSWurkJ7mlNI9wD1FvLckSZK0ropoz5AkSZLKiqFZkiRJakKk5txgo0Qi4gNgRgFvvSEwt4D3Vcvyc64Mfs6Vwc+57fMzrgxFfs6bpZT6rH6yLEJzUSJiQkqppug6VFp+zpXBz7ky+Dm3fX7GlaE1fs62Z0iSJElNMDRLkiRJTTA0f7ZRRRegFuHnXBn8nCuDn3Pb52dcGVrd52xPsyRJktQEV5olSZKkJhia1yAiDoqI1yLirxHxw6LrUfOLiNERMSciXim6FpVGRGwaEY9ExNSImBIRZxZdk5pfRHSOiOciYnLd5/zjomtS6UREVURMiohxRdei0oiItyLi5Yh4MSImFF1PPdszGhERVcDrwAHAO8DzwLEppamFFqZmFRF7AwuB36aUti+6HjW/iOgH9EspvRAR3YGJwBH+t9y2REQAXVNKCyOiA/AEcGZK6ZmCS1MJRMTZQA2wfkrp0KLrUfOLiLeAmpRSq5rH7Upz43YB/ppSmpZSWgrcChxecE1qZiml8cBHRdeh0kkpzU4pvVD3eAHwKtC/2KrU3FK2sO5ph7rDFaE2KCIGAMOB3xRdiyqPoblx/YG3V3r+Dv5BK5W1iKgGdgKeLbgUlUDdX9m/CMwBHkwp+Tm3Tb8EzgNqC65DpZWAByJiYkSMLLqYeoZmSW1eRHQD/giclVKaX3Q9an4ppRUppSHAAGCXiLDlqo2JiEOBOSmliUXXopLbM6W0M3AwcHpdO2XhDM2NmwVsutLzAXXnJJWZuh7XPwI3p5RuL7oelVZK6WPgEeCggktR89sDOKyu3/VW4CsR8btiS1IppJRm1X2dA9xBbpstnKG5cc8DW0bE5hHRETgGuLPgmiSto7obxG4AXk0pXV50PSqNiOgTERvUPe5Cvon7L4UWpWaXUvq3lNKAlFI1+c/lh1NK3yq4LDWziOhad+M2EdEVGAa0iilXhuZGpJSWA2cA95NvHBqbUppSbFVqbhFxC/A0sHVEvBMRJxddk5rdHsAJ5BWpF+uOQ4ouSs2uH/BIRLxEXvR4MKXkODKpPPUFnoiIycBzwN0ppfsKrglw5JwkSZLUJFeaJUmSpCYYmiVJkqQmGJolSZKkJhiaJUmSpCYYmiVJkqQmGJolSZKkJhiaJUmSpCYYmiWpDYmIL0fESxHRuW5nrSkRsX3RdUlSuXNzE0lqYyLiYqAz0AV4J6X0s4JLkqSyZ2iWpDYmIjqSt5NeDOyeUlpRcEmSVPZsz5Cktqc30A3oTl5xliR9Tq40S1IbExF3ArcCmwP9UkpnFFySJJW99kUXIElqPhFxIrAspTQmIqqApyLiKymlh4uuTZLKmSvNkiRJUhPsaZYkSZKaYGiWJEmSmmBoliRJkppgaJYkSZKaYGiWJEmSmmBoliRJkppgaJYkSZKaYGiWJEmSmvD/AHtsQpJhmzHOAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(figsize=(12,3))\n",
    "\n",
    "axes.plot(x, y, 'r')\n",
    "axes.set_xlabel('x')\n",
    "axes.set_ylabel('y')\n",
    "axes.set_title('title');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving figures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To save a figure to a file we can use the `savefig` method in the `Figure` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig(\"filename.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we can also optionally specify the DPI and choose between different output formats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig(\"filename.png\", dpi=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What formats are available and which ones should be used for best quality?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib can generate high-quality output in a number formats, including PNG, JPG, EPS, SVG, PGF and PDF. For scientific papers, I recommend using PDF whenever possible. (LaTeX documents compiled with `pdflatex` can include PDFs using the `includegraphics` command). In some cases, PGF can also be good alternative."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Legends, labels and titles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have covered the basics of how to create a figure canvas and add axes instances to the canvas, let's look at how decorate a figure with titles, axis labels, and legends."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Figure titles**\n",
    "\n",
    "A title can be added to each axis instance in a figure. To set the title, use the `set_title` method in the axes instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax.set_title(\"title\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Axis labels**\n",
    "\n",
    "Similarly, with the methods `set_xlabel` and `set_ylabel`, we can set the labels of the X and Y axes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax.set_xlabel(\"x\")\n",
    "ax.set_ylabel(\"y\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Legends**\n",
    "\n",
    "Legends for curves in a figure can be added in two ways. One method is to use the `legend` method of the axis object and pass a list/tuple of legend texts for the previously defined curves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax.legend([\"curve1\", \"curve2\", \"curve3\"]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method described above follows the MATLAB API. It is somewhat prone to errors and unflexible if curves are added to or removed from the figure (resulting in a wrongly labelled curve).\n",
    "\n",
    "A better method is to use the `label=\"label text\"` keyword argument when plots or other objects are added to the figure, and then using the `legend` method without arguments to add the legend to the figure: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax.plot(x, x**2, label=\"curve1\")\n",
    "ax.plot(x, x**3, label=\"curve2\")\n",
    "ax.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The advantage with this method is that if curves are added or removed from the figure, the legend is automatically updated accordingly.\n",
    "\n",
    "The `legend` function takes an optional keyword argument `loc` that can be used to specify where in the figure the legend is to be drawn. The allowed values of `loc` are numerical codes for the various places the legend can be drawn. See http://matplotlib.org/users/legend_guide.html#legend-location for details. Some of the most common `loc` values are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x25f3e8737f0>"
      ]
     },
     "execution_count": 335,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ax.legend(loc=0) # let matplotlib decide the optimal location\n",
    "ax.legend(loc=1) # upper right corner\n",
    "ax.legend(loc=2) # upper left corner\n",
    "ax.legend(loc=3) # lower left corner\n",
    "ax.legend(loc=4) # lower right corner\n",
    "# .. many more options are available"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following figure shows how to use the figure title, axis labels and legends described above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.plot(x, x**2, label=\"y = x**2\")\n",
    "ax.plot(x, x**3, label=\"y = x**3\")\n",
    "ax.legend(loc=2); # upper left corner\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('title');"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}