{ "cells": [ { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# Basic Introduction to Python\n", "\n", "This is a very basic introduction to Python. It is not exhaustive, but is meant to give you a starting point.\n", "\n", "This notebook was written for PHY 403 by Segev BenZvi, University of Rochester, (Spring 2016), and updated by Aran Garcia-Bellido (Spring 2017).\n", "\n", "It is based on a similar (longer) Python guide written by Kyle Jero (UW-Madison) for the IceCube Programming Bootcamp in June 2015, and includes elements from older guides by Jakob van Santen and Nathan Whitehorn.\n", "\n", "\n", "## What is Python?\n", "\n", "Python is an **imperative**, **interpreted** programming language with **strong** **dynamic** typing.\n", "\n", "- **Imperative**: programs are built around one or more subroutines known as \"functions\" and \"classes\"\n", "- **Interpreted**: program instructions are executed on the fly rather than being pre-compiled into machine code\n", "- **Dynamic Typing**: data types of *variables* (`int`, `float`, `string`, etc.) are determined on the fly as the program runs\n", "- **Strong Typing**: converting a variable from one type to another (e.g., `int` to `string`) is not always done automatically\n", "\n", "Python offers fast and flexible development and can be used to glue together many different analysis packages which have \"Python bindings.\"\n", "\n", "As a rule, Python programs are slower than compiled programs written in Fortran, C, and C++. But it's a much more forgiving programming language.\n", "\n", "## Why Use Python?\n", "\n", "Python is one of the most popular scripting languages in the world, with a huge community of users and support on all major platforms (Windows, OS X, Linux).\n", "\n", "\n", "\n", "\n", "\n", "Pretty much every time I've run into a problem programming in Python, I've found a solution after a couple of minutes of searching on google or stackoverflow.com!\n", "\n", "## Key Third-Party Packages\n", "\n", "### Must-Haves\n", "\n", "- NumPy: random number generation, transcendental functions, vectorized math, linear algebra.\n", "- SciPy: statistical tests, special functions, numerical integration, curve fitting and minimization.\n", "- Matplotlib: plotting: xy plots, error bars, contour plots, histograms, etc.\n", "- IPython: an interactive python shell, which can be used to run Mathematica-style analysis notebooks.\n", "\n", "### Worth Using\n", "\n", "- SciKits: data analysis add-ons to SciPy, including machine learning algorithms.\n", "- Pandas: functions and classes for specialized data analysis.\n", "- AstroPy: statistical methods useful for time series analysis and data reduction in astronomy.\n", "- Emcee: great implementation of Markov Chain Monte Carlo; nice to combine with the package Corner.\n", "\n", "### Specialized Bindings\n", "\n", "Many C and C++ packages used in high energy physics come with bindings to Python. For example, the ROOT package distributed by CERN can be run completely from Python. If you are building ROOT in your computer from scratch, make sure you enable the python binding when you build ROOT. \n", "\n", "### Online Tools\n", "\n", "If you don't want to install all these packages on your own computer, you can create a free account at cloud.sagemath.com. \n", "Sagemath gives you access to ipython notebooks running on remote servers. Recent versions of SciPy, NumPy, and Matplotlib are provided.\n", "\n", "Similarly, try.jupyter.org allows to check simple code without opening an account (but does not allow to save files, for that you need to download Anaconda/Jupyter into your computer). Jupyter can also be run from github.com which is very useful as a code repository.\n", "\n", "## Programming Basics\n", "\n", "We will go through the following topics, and then do some simple exercises.\n", "\n", "- Arithmetic Operators\n", "- Variables and Lists\n", "- Conditional Statements\n", "- Loops (`for` and `while`)\n", "- Functions\n", "- Importing Modules" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "### Arithmetic Operators" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "#### Addition" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "24" ] }, "execution_count": 1, "metadata": { }, "output_type": "execute_result" } ], "source": [ "1+23" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "#### Subtraction" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "12250" ] }, "execution_count": 3, "metadata": { }, "output_type": "execute_result" } ], "source": [ "19993 - 7743" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "#### Multiplication" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "24" ] }, "execution_count": 4, "metadata": { }, "output_type": "execute_result" } ], "source": [ "3*8" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "#### Division" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "25" ] }, "execution_count": 5, "metadata": { }, "output_type": "execute_result" } ], "source": [ "50 / 2" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 6, "metadata": { }, "output_type": "execute_result" } ], "source": [ "1 / 3" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "Note: in Python 2, division of two integers is always **floor division**. In Python 3, 1/2 automatically evaluates to the *floating point number* 0.5. To use floor division in Python 3, you'll have to run `1 // 2`." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "0.5" ] }, "execution_count": 7, "metadata": { }, "output_type": "execute_result" } ], "source": [ "1.0000000 / 2" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "0.5" ] }, "execution_count": 8, "metadata": { }, "output_type": "execute_result" } ], "source": [ "float(1) / 2" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "#### Modulo/Remainder" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 9, "metadata": { }, "output_type": "execute_result" } ], "source": [ "30 % 4" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "0.14159265359000006" ] }, "execution_count": 10, "metadata": { }, "output_type": "execute_result" } ], "source": [ "3.14159265359 % 1." ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "#### Exponentiation" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "16" ] }, "execution_count": 11, "metadata": { }, "output_type": "execute_result" } ], "source": [ "4**2" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "16" ] }, "execution_count": 12, "metadata": { }, "output_type": "execute_result" } ], "source": [ "pow(4,2)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### Variables\n", "\n", "Variables are extremely useful for storing values and using them later. One can declare a variable to contain the output of any variable, function call, etc. However, variable names must follow certain rules:\n", "\n", "1. Variable names must start with a letter (upper or lower case) or underscore\n", "2. Variable names may contain only letters, numbers, and underscores _\n", "3. The following names are **reserved keywords** in Python and cannot be used as variable names:\n", "\n", " ` and del from not while`\n", "\n", " ` as elif global or with`\n", " \n", " ` assert else if pass yield`\n", " \n", " ` break except import print`\n", " \n", " ` class exec in raise`\n", " \n", " ` continue finally is return`\n", " \n", " ` def for lambda try`" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "x = 5 + 6" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This time nothing printed out because the output of the expression was stored in the variable `x`. To see the value we have to call the `print` function:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "11\n" ] } ], "source": [ "print(x)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "Alternatively, just call `x` and the notebook will evaluate it and dump the value to the output:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "11" ] }, "execution_count": 15, "metadata": { }, "output_type": "execute_result" } ], "source": [ "x" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "Recall that we don't have to explicitly declare what type something is in python, something that is not true in many other languages, we simply have to name our variable and specify what we want it to store. However, it is still nice to know the types of things sometimes and learn what types python has available for our use." ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "print(type(x))" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "y = 2\n", "print(type(x/y))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "z = 1.\n", "print(type(z/y))" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "h = \"Hello\"\n", "print(type(h))" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello World!\n" ] } ], "source": [ "s = \" \"\n", "w = \"World!\"\n", "\n", "print(h + s + w)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "They're \"hypothetically\" good for you to know.\n" ] } ], "source": [ "apostrophes=\"They're \"\n", "quotes='\"hypothetically\" '\n", "saying=apostrophes + quotes + \"good for you to know.\"\n", "\n", "print(saying)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "C-style formatted printing is also allowed:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pi = 3.142\n" ] } ], "source": [ "p = \"Pi\"\n", "print(\"%s = %.3f\" % (p, 3.14159265359))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### Lists\n", "\n", "Imagine that we are storing the heights of people or the results of a random process. We could imagine taking and making a new variable for each piece of information but this becomes convoluted very quickly. In instances like this it is best to store the collection of information together in one place. In python this collection is called a list and can be defined by enclosing data separated by commas in square brackets. A empty list can also be specified by square brackets with nothing between them and filled later in the program." ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 23, "metadata": { }, "output_type": "execute_result" } ], "source": [ "blanklist=[]\n", "blanklist" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3]\n", "\n", "[1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5]\n" ] } ], "source": [ "alist=[1, 2, 3]\n", "print(alist)\n", "print(type(alist))\n", "blist=10*[1.5]\n", "print(blist)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "Notice that the type of our list is list and no mention of the data type it contains is made. This is because python does not fuss about what type of thing is in a list or even mixing of types in lists. If you have worked with nearly any other language this is different then you are used to since the type of your list must be homogeneous." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 'two', 3.0]" ] }, "execution_count": 25, "metadata": { }, "output_type": "execute_result" } ], "source": [ "blist=[1, \"two\", 3.0]\n", "blist" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "print(type(blist))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "You can check the current length of a list by calling the `len` function with the list as the argument:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 27, "metadata": { }, "output_type": "execute_result" } ], "source": [ "len(blist)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "In addition, you can add objects to the list or remove them from the list in several ways:" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 'two', 3.0, '4']" ] }, "execution_count": 28, "metadata": { }, "output_type": "execute_result" } ], "source": [ "blist.append(\"4\")\n", "blist" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "['0', 1, 'two', 3.0, '4']" ] }, "execution_count": 29, "metadata": { }, "output_type": "execute_result" } ], "source": [ "blist.insert(0, \"0\")\n", "blist" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['0', 1, 'two', 3.0, '4', 5, 6]\n", "7\n" ] } ], "source": [ "blist.extend([5,6])\n", "print(blist)\n", "print(len(blist))" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "['0', 1, 'two', 3.0, '4', 5, 6, 7]" ] }, "execution_count": 31, "metadata": { }, "output_type": "execute_result" } ], "source": [ "blist.append(7)\n", "blist" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "['0', 1, 'two', 3.0, '4', 5, 6, 7, '0', 1, 'two', 3.0, '4', 5, 6, 7]" ] }, "execution_count": 32, "metadata": { }, "output_type": "execute_result" } ], "source": [ "blist = blist*2\n", "blist" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "['0', 1, 'two', 3.0, 5, 6, 7, '0', 1, 'two', 3.0, '4', 5, 6, 7]" ] }, "execution_count": 33, "metadata": { }, "output_type": "execute_result" } ], "source": [ "blist.remove(\"4\")\n", "blist" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "['0', 1, 'two', 5, 6, 7, '0', 1, 'two', 3.0, 5, 6, 7]" ] }, "execution_count": 34, "metadata": { }, "output_type": "execute_result" } ], "source": [ "blist.remove('4')\n", "blist.remove(3.0)\n", "blist" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "##### List Element Access\n", "\n", "Individual elements (or ranges of elements) in the list can be accessed using the square bracket operators [ ]. For example:" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "6\n" ] } ], "source": [ "print(blist[0])\n", "print(blist[4])" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7\n", "6\n", "5\n" ] } ], "source": [ "print(blist[-1])\n", "print(blist[-2])\n", "print(blist[-3])" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "['0', 1, 'two', 5]" ] }, "execution_count": 37, "metadata": { }, "output_type": "execute_result" } ], "source": [ "blist[0:4]" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['0', 1, 'two', 5, 6, 7, '0', 1, 'two', 3.0, 5, 6, 7]\n" ] }, { "data": { "text/plain": [ "['0', 'two', 6]" ] }, "execution_count": 38, "metadata": { }, "output_type": "execute_result" } ], "source": [ "print(blist) # list slicing example:\n", "blist[0:6:2] # sytax: start, stop, stride" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This is an example of a slice, where we grab a subset of the list and also decide to step through the list by skipping every other element. The syntax is\n", "\n", "`listname[start:stop:stride]`\n", "\n", "Note that if start and stop are left blank, the full list is used in the slice by default." ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "['0', 'two', 6, '0', 'two', 5, 7]" ] }, "execution_count": 39, "metadata": { }, "output_type": "execute_result" } ], "source": [ "blist[::2]" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[7, 6, 5, 3.0, 'two', 1, '0', 7, 6, 5, 'two', 1, '0']\n", "['0', 1, 'two', 5, 6, 7, '0', 1, 'two', 3.0, 5, 6, 7]\n" ] } ], "source": [ "print(blist[::-1]) # An easy way to reverse the order of elements\n", "print(blist)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "A simple built-in function that is used a lot is the range function. It is not a list but returns one so we will discuss it here briefly. The syntax of the function is range(starting number, ending number, step size ). All three function arguments are required to be integers with the ending number not being included in the list. Additionally the step size does not have to be specified, and if it is not the value is assumed to be 1." ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" ] }, "execution_count": 41, "metadata": { }, "output_type": "execute_result" } ], "source": [ "range(0,10)" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[0, 2, 4, 6, 8]" ] }, "execution_count": 42, "metadata": { }, "output_type": "execute_result" } ], "source": [ "range(0,10,2)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### Conditional Statements\n", "\n", "Conditionals are useful for **altering the flow of control** in your programs. For example, you can execute blocks of code (or skip them entirely) if certain conditions are met.\n", "\n", "Conditions are created using `if/elif/else` blocks.\n", "\n", "For those of you familiar with C, C++, Java, and similar languages, you are probably used to code blocks being marked off with curly braces: { }\n", "\n", "In Python braces are not used. Code blocks are *indented*, and the Python interpreter decides what's in a block depending on the indentation. Good practice (for readability) is to use 4 spaces per indentation. The IPython notebook will automatically handle the indentation for you." ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x > 10\n" ] } ], "source": [ "x = 55\n", "\n", "if x > 10:\n", " print(\"x > 10\")\n", "elif x > 5:\n", " print(\"x > 5\")\n", "else:\n", " print(\"x <= 5\")" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x is odd\n" ] } ], "source": [ "isEven = (x % 2 == 0) # Store a boolean value\n", "\n", "if not isEven:\n", " print(\"x is odd\")\n", "else:\n", " print(\"x is even\")" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "#### Comparison Operators\n", "\n", "There are several predefined operators used to make boolean comparisons in Python. They are similar to operators used in C, C++, and Java:\n", "\n", "`==` ... test for equality\n", "\n", "`!=` ... test for not equal\n", "\n", "`>` ... greater than\n", "\n", "`>=` ... greater than or equal to\n", "\n", "`<` ... less than\n", "\n", "`<=` ... less than or equal to\n", "\n", "#### Combining Boolean Values\n", "\n", "Following the usual rules of boolean algebra, boolean values can be negated or combined in several ways:\n", "\n", "##### Logical AND\n", "\n", "You can combine two boolean variables using the operator `&&` or the keyword `and`:" ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x y | x && y\n", "---------------\n", "1 1 | 1\n", "1 0 | 0\n", "0 1 | 0\n", "0 0 | 0\n" ] } ], "source": [ "print(\"x y | x && y\")\n", "print(\"---------------\")\n", "\n", "for x in [True, False]:\n", " for y in [True, False]:\n", " print(\"%d %d | %d\" % (x, y, x and y))" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n" ] } ], "source": [ "x = 10\n", "if x > 2 and x < 20:\n", " print(x)" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "if x < 2 and x > 20:\n", " print(x)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "##### Logical OR\n", "\n", "You can also combine two boolean variables using the operator `||` or the keyword `or`:" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x y | x || y\n", "---------------\n", "1 1 | 1\n", "1 0 | 1\n", "0 1 | 1\n", "0 0 | 0\n" ] } ], "source": [ "print(\"x y | x || y\")\n", "print(\"---------------\")\n", "\n", "for x in [True, False]:\n", " for y in [True, False]:\n", " print(\"%d %d | %d\" % (x, y, x or y))" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n" ] } ], "source": [ "x = 10\n", "if x > 2 or x < 0:\n", " print(x)" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "if x < 2 or x > 20:\n", " print(x)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "##### Logical NOT\n", "\n", "It's possible to negate a boolean expression using the keyword `not`:" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x | not x\n", "----------\n", "1 | 0\n", "0 | 1\n" ] } ], "source": [ "print(\"x | not x\")\n", "print(\"----------\")\n", "for x in [True, False]:\n", " print(\"%d | %d\" % (x, not x))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "A more complex truth table demonstrating the duality\n", "\n", "$\\overline{AB} = \\overline{A}+\\overline{B}$:" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A B | A and B | !(A and B) | !A or !B\n", "-------------------------------------------\n", "1 1 | 1 | 0 | 0\n", "1 0 | 0 | 1 | 1\n", "0 1 | 0 | 1 | 1\n", "0 0 | 0 | 1 | 1\n" ] } ], "source": [ "print(\"A B | A and B | !(A and B) | !A or !B\")\n", "print(\"-------------------------------------------\")\n", "for A in [True, False]:\n", " for B in [True, False]:\n", " print(\"%d %d | %-7d | %-12d| %d\" % \n", " (A, B, A and B, not (A and B), not A or not B))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### Loops\n", "\n", "Loops are useful for executing blocks of code as long as a logical condition is satisfied.\n", "\n", "Once the loop condition is no longer satisfied, the flow of control is returned to the main body of the program. Note that **infinite loops**, a serious runtime bug where the loop condition never evaluates to `False`, are allowed, so you have to be careful.\n", "\n", "#### While Loop\n", "\n", "The `while` loop evaluates until a condition is false. Note that loops can be nested inside each other, and can also contain nested conditional statements." ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "4\n", "6\n", "8\n", "10\n" ] } ], "source": [ "i = 0\n", "while i < 10: # Loop condition: i < 10\n", " i += 1 # Increment the value of i\n", " if i % 2 == 0: # Print i if it's even\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "#### For Loop\n", "\n", "The `for` loop provides the same basic functionality as the `while` loop, but allows for a simpler syntax in certain cases.\n", "\n", "For example, if we wanted to access all the elements inside a list one by one, we could write a while loop with a variable index `i` and access the list elements as `listname[i]`, incrementing `i` until it's the same size as the length of the list.\n", "\n", "However, the `for` loop lets us avoid the need to declare an index variable. For example:" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "4\n", "6\n", "8\n", "10\n" ] } ], "source": [ "for x in range(1,11): # Loop through a list of values [1..10]\n", " if x % 2 == 0: # Print the list value if it's even\n", " print(x)" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 a\n", "2 b\n", "3 c\n", "4 d\n", "5 e\n" ] } ], "source": [ "for i, x in enumerate(['a', 'b', 'c', 'd', 'e']):\n", " print(\"%d %s\" % (i+1, x))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "If we are interested in building lists we can start from a blank list and append things to it in a for loop or use a **list comprehension** which combines for loops and list creation into line. The syntax is a set of square brackets that contains formula and a for loop." ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n" ] } ], "source": [ "squaredrange = [e**2 for e in range(1,11)]\n", "\n", "print(squaredrange)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "You can also loop through **two lists simultaneously** using the `zip` function:" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 1 1\n", " 2 4\n", " 3 9\n", " 4 16\n", " 5 25\n", " 6 36\n", " 7 49\n", " 8 64\n", " 9 81\n", "10 100\n" ] } ], "source": [ "mylist = range(1,11)\n", "mylist2 = [e**2 for e in mylist]\n", "\n", "for x, y in zip(mylist, mylist2):\n", " print(\"%2d %4d\" % (x, y))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "To illustrate the zip function, this is what it does:" ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[(1, 4), (2, 5), (3, 6)]\n" ] } ], "source": [ "mylistA=[1,2,3]\n", "mylistB=[4,5,6]\n", "print(zip(mylistA,mylistB))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### Functions\n", "\n", "Functions are subroutines that accept some input and produce zero or more outputs. They are typically used to define common tasks in a program.\n", "\n", "Rule of thumb: if you find that you are copying a piece of code over and over inside your script, it should probably go into a function.\n", "\n", "#### Example: Rounding\n", "\n", "The following function will round integers to the nearest 10:" ] }, { "cell_type": "code", "execution_count": 59, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 2 0\n", " 7 10\n", " 12 10\n", " 17 20\n", " 22 20\n", " 27 30\n", " 32 30\n", " 37 40\n", " 42 40\n", " 47 50\n" ] } ], "source": [ "def round_int(x):\n", " return 10 * ((x + 5)/10)\n", "\n", "for x in range(2, 50, 5):\n", " print(\"%5d %5d\" % (x, round_int(x)))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "# In-Class Exercise\n", "\n", "With the small amount we've gone through, you can already write reasonably sophisticated programs. For example, we can write a loop that generates the Fibonacci sequence.\n", "\n", "Just to remind you, the Fibonacci sequence is the list of numbers\n", "\n", "1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...\n", "\n", "It is defined by the linear homogeneous recurrence relation\n", "\n", "$F_{n} = F_{n-1} + F_{n-2}$, where $F_0=F_1=1$.\n", "\n", "The exercise is:\n", "1. Write a Python function that generate $F_n$ given $n$.\n", "2. Use your function to generate the first 100 numbers in the Fibonacci sequence." ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "# Easy implementation: recursive function\n", "\n", "def fib(n):\n", " \"\"\"Generate term n of the Fibonacci sequence\"\"\"\n", " if n <= 1:\n", " # if n==0 or n==1: return 1\n", " return 1\n", " else:\n", " return fib(n-1) + fib(n-2)" ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 0 1\n", " 1 1\n", " 2 2\n", " 3 3\n", " 4 5\n", " 5 8\n", " 6 13\n", " 7 21\n", " 8 34\n", " 9 55\n", " 10 89\n", " 11 144\n", " 12 233\n", " 13 377\n", " 14 610\n", " 15 987\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 16 1597\n", " 17 2584\n", " 18 4181\n", " 19 6765\n", " 20 10946\n", " 21 17711\n", " 22 28657\n", " 23 46368\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 24 75025\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 25 121393\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 26 196418\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 27 317811\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 28 514229\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 29 832040\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 30 1346269\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 31 2178309\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 32 3524578\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 33 5702887\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 34 9227465\n" ] } ], "source": [ "for n in range(0, 35):\n", " Fn = fib(n)\n", " print(\"%3d%25d\" % (n, Fn))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This function will work just fine for small n. Unfortunately, the recursive calls to `fib` cause the **function call stack** to grow rapidly with n. When n gets sufficiently large, you may hit the Python call stack limit. At that point your program will crash.\n", "\n", "Here is a more efficient approach that does not require recursion:" ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "def fibBetter(n):\n", " \"\"\"Generate the Fibonacci series at position n\"\"\"\n", " a, b = 0, 1\n", " while n > 0: # build up the series starting from the end (high n to n=0)\n", " a, b, n = b, a+b, n-1 # store results in loop variables\n", " return b" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 0 1\n", " 1 1\n", " 2 2\n", " 3 3\n", " 4 5\n", " 5 8\n", " 6 13\n", " 7 21\n", " 8 34\n", " 9 55\n", " 10 89\n", " 11 144\n", " 12 233\n", " 13 377\n", " 14 610\n", " 15 987\n", " 16 1597\n", " 17 2584\n", " 18 4181\n", " 19 6765\n", " 20 10946\n", " 21 17711\n", " 22 28657\n", " 23 46368\n", " 24 75025\n", " 25 121393\n", " 26 196418\n", " 27 317811\n", " 28 514229\n", " 29 832040\n", " 30 1346269\n", " 31 2178309\n", " 32 3524578\n", " 33 5702887\n", " 34 9227465\n", " 35 14930352\n", " 36 24157817\n", " 37 39088169\n", " 38 63245986\n", " 39 102334155\n", " 40 165580141\n", " 41 267914296\n", " 42 433494437\n", " 43 701408733\n", " 44 1134903170\n", " 45 1836311903\n", " 46 2971215073\n", " 47 4807526976\n", " 48 7778742049\n", " 49 12586269025\n", " 50 20365011074\n", " 51 32951280099\n", " 52 53316291173\n", " 53 86267571272\n", " 54 139583862445\n", " 55 225851433717\n", " 56 365435296162\n", " 57 591286729879\n", " 58 956722026041\n", " 59 1548008755920\n", " 60 2504730781961\n", " 61 4052739537881\n", " 62 6557470319842\n", " 63 10610209857723\n", " 64 17167680177565\n", " 65 27777890035288\n", " 66 44945570212853\n", " 67 72723460248141\n", " 68 117669030460994\n", " 69 190392490709135\n", " 70 308061521170129\n", " 71 498454011879264\n", " 72 806515533049393\n", " 73 1304969544928657\n", " 74 2111485077978050\n", " 75 3416454622906707\n", " 76 5527939700884757\n", " 77 8944394323791464\n", " 78 14472334024676221\n", " 79 23416728348467685\n", " 80 37889062373143906\n", " 81 61305790721611591\n", " 82 99194853094755497\n", " 83 160500643816367088\n", " 84 259695496911122585\n", " 85 420196140727489673\n", " 86 679891637638612258\n", " 87 1100087778366101931\n", " 88 1779979416004714189\n", " 89 2880067194370816120\n", " 90 4660046610375530309\n", " 91 7540113804746346429\n", " 92 12200160415121876738\n", " 93 19740274219868223167\n", " 94 31940434634990099905\n", " 95 51680708854858323072\n", " 96 83621143489848422977\n", " 97 135301852344706746049\n", " 98 218922995834555169026\n", " 99 354224848179261915075\n" ] } ], "source": [ "for n in range(0, 100):\n", " Fn = fibBetter(n)\n", " print(\"%3d%25d\" % (n, Fn))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "## Accessing Functions Beyond the Built-In Functions\n", "\n", "If we want to use libraries and modules not defined within the built-in functionality of python we have to import them. There are a number of ways to do this." ] }, { "cell_type": "code", "execution_count": 64, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "import numpy, scipy" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This imports the module `numpy` and the module `scipy`, and creates a reference to that modules in the current namespace. After you’ve run this statement, you can use `numpy.name` and `scipy.name` to refer to constants, functions, and classes defined in module numpy and scipy." ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3.141592653589793" ] }, "execution_count": 65, "metadata": { }, "output_type": "execute_result" } ], "source": [ "numpy.pi" ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "from numpy import *" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This imports the module numpy, and creates references in the current namespace to all public objects defined by that module (that is, everything that doesn’t have a name starting with “_”).\n", "\n", "Or in other words, after you’ve run this statement, you can simply use a plain name to refer to things defined in module numpy. Here, numpy itself is not defined, so numpy.name doesn’t work. If name was already defined, it is replaced by the new version. Also, if name in numpy is changed to point to some other object, your module won’t notice." ] }, { "cell_type": "code", "execution_count": 67, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3.141592653589793" ] }, "execution_count": 67, "metadata": { }, "output_type": "execute_result" } ], "source": [ "pi" ] }, { "cell_type": "code", "execution_count": 68, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(0.0, 0.84270079294971478, 0.99532226501895271)\n" ] } ], "source": [ "from scipy import special\n", "\n", "print(special.erf(0),\n", " special.erf(1),\n", " special.erf(2))" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This imports the module `scipy`, and creates references in the current namespace functions in the *submodule* `special`. We then make 3 function calls to the Error Function `erf`." ] }, { "cell_type": "code", "execution_count": 69, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "import numpy as np" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This imports `numpy` but assigns the name of the module to `np` so that you can type `np` rather than `numpy` when you want to access variables and functions defined inside the module." ] }, { "cell_type": "code", "execution_count": 70, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3.141592653589793" ] }, "execution_count": 70, "metadata": { }, "output_type": "execute_result" } ], "source": [ "np.pi" ] }, { "cell_type": "code", "execution_count": 71, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7])" ] }, "execution_count": 71, "metadata": { }, "output_type": "execute_result" } ], "source": [ "np.arange(0,8) # acts like the range function, but return a numpy array" ] }, { "cell_type": "code", "execution_count": 72, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ,\n", " 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. , 2.1,\n", " 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3. , 3.1, 3.2,\n", " 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4. , 4.1, 4.2, 4.3,\n", " 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5. , 5.1, 5.2, 5.3, 5.4,\n", " 5.5, 5.6, 5.7, 5.8, 5.9, 6. , 6.1, 6.2, 6.3, 6.4, 6.5,\n", " 6.6, 6.7, 6.8, 6.9, 7. , 7.1, 7.2, 7.3, 7.4, 7.5, 7.6,\n", " 7.7, 7.8, 7.9])" ] }, "execution_count": 72, "metadata": { }, "output_type": "execute_result" } ], "source": [ "np.arange(0,8, 0.1) # unlike builtin range, you can use non-integer stride" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "## NumPy Tips and Tricks\n", "\n", "NumPy is optimized for numerical work. The `array` type inside of the module behaves a lot like a list, but it is *vectorized* so that you can apply arithmetic operations and other functions to the array without having to loop through it.\n", "\n", "For example, when we wanted to square every element inside a python list we used a list comprehension:" ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" ] }, "execution_count": 73, "metadata": { }, "output_type": "execute_result" } ], "source": [ "mylist = range(1,11)\n", "[x**2 for x in mylist]" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This isn't that hard, but the syntax is a little ugly and we do have to explicitly loop through the list. In contrast, to square all the elements in the NumPy array you just apply the operator to the array variable itself:" ] }, { "cell_type": "code", "execution_count": 74, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1 4 9 16 25 36 49 64 81 100]\n" ] }, { "data": { "text/plain": [ "array([ 2, 8, 18, 32, 50, 72, 98, 128, 162, 200])" ] }, "execution_count": 74, "metadata": { }, "output_type": "execute_result" } ], "source": [ "myarray = np.arange(1,11)\n", "myarray=myarray**2\n", "print(myarray)\n", "myarray*2\n", "# print(myarray)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### Evenly Spaced Numbers\n", "\n", "NumPy provides two functions to give evenly spaced numbers on linear or logarithmic scales." ] }, { "cell_type": "code", "execution_count": 75, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 1. , 1.45, 1.9 , 2.35, 2.8 , 3.25, 3.7 , 4.15,\n", " 4.6 , 5.05, 5.5 , 5.95, 6.4 , 6.85, 7.3 , 7.75,\n", " 8.2 , 8.65, 9.1 , 9.55, 10. ])" ] }, "execution_count": 75, "metadata": { }, "output_type": "execute_result" } ], "source": [ "np.linspace(1, 10, 21) # gives 21 evenly spaced numbers in [1..10]" ] }, { "cell_type": "code", "execution_count": 76, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 1.00000000e+01, 1.00000000e+02, 1.00000000e+03,\n", " 1.00000000e+04, 1.00000000e+05, 1.00000000e+06])" ] }, "execution_count": 76, "metadata": { }, "output_type": "execute_result" } ], "source": [ "np.logspace(1, 6, 6) # gives 6 logarithmically spaced numbers\n", " # between 1e1=10 and 1e6=1000000" ] }, { "cell_type": "code", "execution_count": 77, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 2., 4., 8., 16., 32., 64.])" ] }, "execution_count": 77, "metadata": { }, "output_type": "execute_result" } ], "source": [ "np.logspace(1, 6, 6, base=2) # same as above, but base-2 logarithm" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### Slicing Arrays with Boolean Masks\n", "\n", "An extremely useful feature in NumPy is the ability to create a \"mask\" array which can select values satisfying a logical condition:" ] }, { "cell_type": "code", "execution_count": 78, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ True True True False False False False False]\n" ] } ], "source": [ "x = np.arange(0, 8) # [0, 1, 2, 3, 4, 5, 6, 7]\n", "y = 3*x # [0, 3, 6, 9, 12, 15, 18, 21]\n", "\n", "c = x < 3\n", "print(c)" ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 1 2]\n" ] } ], "source": [ "print(x[c])" ] }, { "cell_type": "code", "execution_count": 80, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 3 6]\n", "[ 9 12 15 18 21]\n" ] } ], "source": [ "print(y[c])\n", "print(y[x >= 3])" ] }, { "cell_type": "code", "execution_count": 81, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 0 3 6 18 21]\n" ] } ], "source": [ "c = (x<3) | (x>5) # Combine cuts with bitwise OR or AND\n", "print(y[c])" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This is the type of selection used *all the time* in data analysis." ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### File Input/Output\n", "\n", "Standard Python has functions to read basic text and binary files from disk.\n", "\n", "However, for numerical analysis your files will usually be nicely formatted into numerical columns separated by spaces, commas, etc. For reading such files, NumPy has a nice function called `genfromtxt`:" ] }, { "cell_type": "code", "execution_count": 82, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]\n", "[ 1. 4. 9. 16. 25. 36. 49. 64. 81. 100.]\n" ] } ], "source": [ "# Load data from file into a multidimensional array\n", "data = np.genfromtxt(\"data.txt\")\n", "\n", "x = data[:,0] # x is the first column (numbering starts @ 0)\n", "y = data[:,1] # y is the second column\n", "\n", "print(x)\n", "print(y)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "## Plotting with Matplotlib\n", "\n", "Matplotlib is used to plot data and can be used to produce the usual xy scatter plots, contour plots, histograms, etc. that you're used to making for all basic data analyses.\n", "\n", "I strongly recommend that you go to the Matplotlib website and check out the huge plot gallery. This is the easiest way to learn how to make a particular kind of plot.\n", "\n", "**Note**: when you want to plot something in an IPython notebook, put the magic line\n", "\n", "`%matplotlib inline`\n", "\n", "before you import the `matplotlib` module. This will ensure that your plots appear inside the notebook. Otherwise the plots will pop open in another window, which can be annoying." ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ "%matplotlib inline\n", "\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 84, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "Text(0.5,1,'Some XY data')" ] }, "execution_count": 84, "metadata": { }, "output_type": "execute_result" }, { "data": { "image/png": "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" }, "execution_count": 84, "metadata": { "image/png": { "height": 277, "width": 390 } }, "output_type": "execute_result" } ], "source": [ "plt.plot(x, y, \"k.\")\n", "plt.xlabel(\"x [arb. units]\")\n", "plt.ylabel(\"y [arb. units]\")\n", "plt.title(\"Some XY data\")" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "Here is an example of how to change the default formatting of the text in your plot. Also note how LaTeX is supported!" ] }, { "cell_type": "code", "execution_count": 85, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "Text(0.5,1,'Some XY data')" ] }, "execution_count": 85, "metadata": { }, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzMAAAJNCAYAAAAF9CuzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xl8ZFWZ+P/Pwx4QBBTDvjQo4iCy2KJsrgOItppR2RSFr7jvzqijow4uP3XGfR1FRUERGJeorSIgCLKNAiKIoiLdzU5AadZu1n5+f9wbcru6KlVJ1U1Syef9et0Xdznn3KeS9Iv71LnnnMhMJEmSJKnfrDbdAUiSJEnSZJjMSJIkSepLJjOSJEmS+pLJjCRJkqS+ZDIjSZIkqS+ZzEiSJEnqSyYzkiRJkvqSyYwkSZKkvmQyI0mSJKkvmcxIkiRJ6ksmM5IkSZL6ksmMJEmSpL60xnQHIEmzSURsA+wObAY8ElgB3AXcBFwNXJWZy6cvQkmSZo/IzOmOQZL6WkSsB7wZeBWwQ5viDwJ/Ai4CfgWcmZk31xuhOhER2wKLOy2fmdGkjbOBp7epehSwLfCfHdzmmszcttXFiDimTTvHZ+aRHdxn0tr83Gq/v6S5zZ4ZSepCROwJnEzxcApwL3AGcCnwD4rXeTcGdgaeDWwA7FJuryrbGMzMW6Y0cDXzEDBS7q8GbNJw/T7g9jZt3FZpYw3gUeX+PygSWYDlwN2Vco8GVq+0sRy4s9y/tc39qu0MUPx9JTD693RHm/q9UP25QfFz8zV2SVPCnhlJmqSI2J2id2WD8tR3gLdm5m0tyq8LvIPim/Tql0mb2Tsz80TEWcAzK6duB3bq9HcVEZ8B3gb8AdgjMx9oUe6/gXdWTt0I7JiZd08w3tOBfwaOy8xXTaRuL0XEEmCb8nBae2YiovqQ88HMPGa6YpFUD785kaRJiIjVgG8wlsgMA69olcgAZOayzPwI8NopCFHdew1FT9uoDYHPdVIxIp4GvIWiN+aoVolM6cMUY6pGbQ78x0QCjYghikTmduDfJ1JXkvqZyYwkTc5zgF0rxx/IDru6M/M44NxaolLPZObfgA82nD44Ip43Xr2IWJsi0V0N+ERmXtLmPncB72o4/Y6IeGwncUbEAPDp8vADmdnu1TRJmjVMZiRpcp5b2b8zM6+YYP1v9TAW1eeTwGUN575cTvrQygeAnYArWTUZaiozvwOcVzm1FvDZDmN8N8WYrcuBL3dYR5JmBZMZSZqcbSr7ExrbULqwV4GoPpn5IHA0xSD3UVsDH2lWPiJ2o+hlWUHxetl9E7jdm8t6ow7qoBdoW8Z6dd6UmQ+1Li1Js4/JjCRNzvqV/UeXrxZNxF8pxjj8M8UMWJqhMvNi4PMNp98cEXtUT0TEGsBxFJM7fCYzfzPB+/we+GrD6c+2+dv6DMUsZidmpq8uSppznJpZkianOkXvWsDzgR90Wrn8Bv2Xk7lxRKwF7A1sTzGt73KKqXEvzMxrJtPmOPfaDdiHInm7GTg3M68ap/xTgfnAIyimFb4gM//UZQy7UkxlPUgx7fDfKdbquTgzV4xXt4feDwwxNgX36sDXImJ+pTfk3RTjqK4qy0/G+4CDGZvSeQeKGfA+1lgwIvYHXkSxKOs7G6/XISKeQPH73ay87w3A2ZnZbsrqTtpek2IK8ycCj6H4d7UUuBb4v8z8R7f36CK2bYAnUfz+1wfuofj7vgT4S6fj5STVIDPd3Nzc3Ca4UYyFyMp2LbBtzffcHDiW4iEyW2yXAS9u086Lxql/TFlmS4pkq1mZnwCbNrS5K/C7FuXPAraZ4GddE3grcN04sd4GfBTYcIp+5wc0ieHfyms7Ucx8tgLYp8v7vK7hHncDWzT5+VxZjaHmz743xYN7s9/DvcDxwEZl2SWVa99q0+5awEspZgO8c5zf9QrgVOCpHcTaqo2WW4t2dqUYt3R1m/qLKF4RXH0q/g7d3NxW3lxnRpImoZx694KG07dRJDlfy8zlPb7fAuAkYHTg+bUUD4BLKHpBnkrxsD3a474QODQzlzVp60Vl3WY+CHyNYkzPVuOEdDUwPzOXlr0xv6zE1sy1wG45ztTVlfg2A37O2Gxxd5bx/gEIisThRRSLkULRO3BQZl7eru1uRcS3gZdXTi2j6DX6NvA04AuZ+ZYu77EacDGwW+X0SZl5eKXMO4H/Bv4M7JLjT/3clYh4E8VrdlGeGgG+T/E3sC7F5z6A4vewL8VMfR2tMxMRn6OYwnrUzcCPgGsoehy3opg58Enl9YeAd2bmZ8Zps7oO0GBl/x5ajG/LzE0b2tiNIjkf9SDFv6k/UixIuiHwZOBAioQM4GzgBVnMTidpqkx3NuXm5ubWrxvFQ1uzb2r/QfGN7lMpFyfu8j4voXiYGm3/08CaTcrtwco9GecDazUptwVwaGVbqWeGYiHQh4D/Bd4AvBL4OMXrXdWyxwKPBK5vKH8kxYP2PxrKf6GDz7oJsLhS5zwaeoHKchtR9BCNlrsdmDcFv/NHU7xeVP1cNzP2Df16PbrPXhS9EdX77Fde24yxXozn1Px5D2uI4fvAI1r87d1IkeBfXyn/rTbtf7FS9lPA2i3KDVEkI6NlX9Jh/Cv9bU/gcz+5Uu+PtOhZpJgM4sJK2YV1/w26ubmtvE17AG5ubm79ulGMWRlpeGBq3K6nmC73gGaJRYf3uKPS3kltyu8KPFAp/7kO7lGN91KKb8Sf3aTclpUH99HXi744TvltKL7FriYc64wTR1D0yIyWvw545Djl1yofNB9O3qbo9/7yJr/nFcCzenyfExrucRnFWJ3vjCYWNX/OQVZOSC9tlWyU5Z9MkdRWY/5Wm3uMJjOnTfDnfk0n/556kMw8AGzdpuxGrJzgHjgVf4dubm7F5mxmkjRJmXk1xeD48RZF3AJ4PfALYCQijo2I+RO4zceADcr9BygGmY8X0+8pxi+MenNEPH4C99uVYuHFM5u0fT3F7Fmj1gbeOE75a1h5FrBHsvKrU42ex8rr93wwM+9oVTgz7wc+XDm1V0Q8a5z2eyKLNWFOazh9O+P/HUzGuyjGR43ahWIxzpdRvN72jh7fr9G/MvYqHxS/55ZTTWcx69spE7zHzcBf6Gx9nO8yNvPf1hRfENRlOUVcJ2bmteMVzMylwImVU6+uMS5JDUxmJKkLWczstSfwWorXo8azIcWDzm8j4rR2K7yXa4j8S+XUr9s9WJVOqDZD8VDaqXuBr4xz/YwJlm986N9pnLJvr+zfTzFGqJ2FrLw2y1Q9SL6+4b4bUbxa1zOZeTOrLrr5yvK/H+3wb2FSypnFjqycuoNiAH47nfzOHpaZH8nMx2fmjzsou4JiSvNRT5/IvSYY1x/LuI7ssMqVlf3a4pK0KpMZSepSZj6UmcdSTKO7P/At2q8dsz9wWTkYv5WDKF4rGnVWhyGdT5FkjHp+h/WgmAJ3vAHMiyZY/uqG442bFYqI9Vn5IfCizLxnnHYBKMtUY9q3XZ0eeS6r/j/01RGxX4/v83mKQf5VVwOf7PF9Gu1KMX5p1PlZLCDazm9rimdUtWdom5rvNRHVuB4VEeNNhiGph1xnRpJ6pPzm+AzgjIhYneLB+oUUg5ebPXgNAN+LiH2y+QKL+zQcX9mkTLM4HoqIqyjW6wDYNCJ2yMy/dVC98cG5UWPi0q78nQ3HrR7ynsbKiVu7dquqieMWEbFp2atRi4jYmmJCBCgmZhj9f2kAx0bEk8Z7HWsiMvOBiPgAxeQKo07sVfvjeErD8V+blmqQmSMRcTfFDHsdi4h1KGaoeybF3+2jKNZzaUwYq8nwRhO5x2RFxJMpekh3pxg39kiKqbGrBhqON6KYsEBSzUxmJKkGWSykeDZwdkS8g+Jh/fXAIaz8ILQGxbfvezZppjEBunECIdzEWDIz2lYnycy4ix+WidJEyj/YUD5aFG38rIdGRKc9So29PYMUYzHq8jWKB+3fAJ+jGMsxakeKBTPf18P73dpwnD1su5UtG44n8vO8iwkkMxFxFPAJxhYK7VStzzDlAqFfZdUvFTrh85U0RXzNTJJqloULMvMIikHcv2so8pQWg/QbH9In8k1v43oanT4oTvQb/171EDR+1vUokpJOtsZvyTfsUUyriIj/R/GK4L3AUZl5EsW6KFXviognrlK5vzT2ekzkb+/+TgtGxH8BxzH29/k7iumgt6KYrSyqG3DOBOKYtIjYk2LK5dFE5i6KJHUXiqmpG+M6airikrQqvzmQpCmUmX+OiOcAVwCbVy49lfavVrXq1eik7FR8m99Ln8rMf5vuIKoiYnOKtVCgmNlr9LW/NwDPYCyJWhP4ekQ8rXz1cDaYyN9eZw1GHEgxY9uo04HnZ40LgHYiIgaAkxmbRfAu4GmZ+cfpi0pSK/bMSNIUK6dyPbbh9GCTov9oOJ7IoOLGso1tzTSN8U1ozMUU+R+KhOX/KBYuBSAzb2LVaZKfwsor2/ebpQ3H606g7lodlntnw/FbpjuRKb0E2LZy/CUTGWnmMpmRpEmIiH+PiNsjonGq4k41vmr2UJMy1zQcb96kTCuNZRvbmmka49t0WqJoISIOA17A2OtlK/2+MvObrDpt9UciYibNuDUR1zUcbzaBuuu3KxARawDVmd+WZOZfJnCPOjWuVfSLaYlCUkdMZiRpctahmNVou0nWbxxX0DjIG+DchuPx1mh5WPmguEPl1E3lAp8z2YUUM4ON+qeJVI6IfSLi+eWrSz0VEZswtvjn+zOz1euAr2blsUrrMf4aPDNZ4xTLO3ZSKSIeQ2e9ao9m5VfdO53cYiqeWxoTt05i83lKmib+45Ok7syLiEdPol7jN/aXNinzc1busXl2h23vTZFsjfrpBOKaFpl5N/CryqkdIqKjRLEc43AaxQKa72pTfDK+SPHwvdLrZY0y8xrgPQ2nD4yIl9UQU91+D9xSOd6rTJLbaZzSuZXGiSPWaVpqVc1ex+y1ycQ2FXFJasJkRpK6E4ytyj4R1cUyr83MyxsLlCu8f69yat+I2LaDtl9RbYZxHsBnmE81HL+qw3pHMDam4zu9CwfKRU0Ppni97MgOBvR/CTiv4dxnImKi0w5Pq3KBzG9WTm1AsYhrO4d22P5SVh4n9YQyKW2pnIDhsZ20X7Gsst846x0R8ZGI+H1EXBRjc4g3TmG+Rwf3eXr7IpLqYDIjSd17X0R09BoOQET8C8UK8qM+NE7x9wJ3lPtrUKzHMV7bu7JyMvOFcV6LmlEy8zTgJ5VTb2/3c42IzYCPlIeLgW/3Kp6I2Ihi0D/A+zoZ05GZSZGE3Vs5vQnwmV7FNYU+xcoJxwcjouXg/ojYnQ6TmVK1x3Ad4LVtyr+fic+qdkNlf5Mm158KPAl4ZPm7g6KHr+pN5SK4TUXEUymm65Y0DUxmJKl7GwLnRsQhbR56BiLi34GTKqd/yMrfgK8kMxcDRzI2nuQlEfHZiGj2LfPuFMnA6OtAF7DqjFEz3VHAVeX+usDp5cPiKiJiZ+AsiofUB4Ejejwb1mcpJiK4kAkkI5n5V+CYhtNHRERfPfBm5q0U006PPuTvCpwYEauMiYmI3Sj+9k4Hru3wFh9l5aTv4xEx1KTtiIh3A69j4lOMX1jZ3ysiHn7uKXs5RychOH30fGaeTfF3NWoP4LiIWOV1s/Lf3A8nGJOkHoqxLyIkSZ2KiKMpxlKs3XDpBoqF/a6k6FFZjWJBwCdSjHkZnekpKaZnfktmtl1kMCIOolj7YrT+tRQPUUsoBlw/FTiQsURmIXBoZi6jQURsBVxUOVV93/8exgaxvzUzTynr3NxB+U9m5ifL8hdRLHw4XvlTMvOtTeLbBPgx8LTy1AqKn+m5wN8pJl7YCziA4ud7T/lZuxobFBF7sfKD6Wjcd1F5XSkzm860FhH/BoyujbMaq/YE3MtYL1vTz15pq/rzW4uVF7Gs/gwB5mdm4+xjPRMRb6D4Wx/tFRmheP3xaoqE86kUPY1/o3jd6reMjQmrfubrMnN+Q9svBU5k5VfAzqeYGe42imTyBcDOwNcpJiLYtyz3QFkG4ILM/Jcmse9JkdSPJjHnAD+j+HkeVbZ/D7BLZi6q1HsMxd/b4yrN3Qh8v/zc61D8fS6gmInvO8AHKmX/zth4t1p/P9Kcl5lubm5ubpPYKBKLw4BvUTzIZQfbPRQPPk+dxP02o5gd665x2r8MeEmbdrbtMNYjK3U6KX9MpfySDsp/a5wYVweOpuilaVV/OcVrZdv06Pf5jE4+5zj1j+nw5zTuZ5/Az29023YK/tb3Ai4Z5/fwDWD9NrEvadH2UygSh1af7xqKXjeAs1uUOXuc2F8J3N6i3rXAM8b59/3F8vM1q3tveX1jit7Tafv9uLnN5c2eGUnqkXKQ92OBeRS9MY+g+Db7LoqxB1cAf8picHU391kL2AfYnmKWreXAzcCFWcyoNatExOMpXvUZpPhG/HbgL8BvM/Ou6YxtromIJwB7Uvwu7gKup0gk7hi3Ymdtb0/R27EZRU/KrRSzql2aXT6sRMR6FMnq4yimzL6T4t/jr9v9e4yIDSj+ve1AkeAspUjYzsnMe7qJS1L3TGYkSZIk9SUnAJAkSZLUl0xmJEmSJPUlkxlJkiRJfclkRpIkSVJfMpmRJEmS1JdMZiRJkiT1JZMZSZIkSX3JZEaSJElSXzKZkSRJktSX1pjuADRzRMRiYANgyTSHIkmSpNltW+DOzNyum0ZMZlS1wcDAwMY77bTTxtMdiCRJkmavK6+8kuXLl3fdjsmMqpbstNNOG19yySXTHYckSZJmsT322IPf/e53S7ptxzEzkiRJkvqSyYwkSZKkvmQyI0mSJKkvmcxIkiRJ6ksmM5IkSZL6ksmMJEmSpL5kMlOKiP0jYklEZEScPd3xSJIkSRrfnE9mImLDiDgOOA3Ypsu21o6I10TEmRFxY0TcGxHXRsTPIuLwiJjwzzsi9o2Ib0bEVRGxLCL+HhEXR8T7I2KzbuKVJEmS+tmcTmYi4oXAn4CjgLu6bOufgEuArwL7ARcD3wD+AjwXOBH4dURs2WF7a0XEscCvgSOBe4ATKJKuecCHgD9GxIu7iVuSJEnqV2tMdwDTISIGgG8ChwD3Au8BbgW+Psn2tgV+CWwKXAfsn5l/rlzfG/gpsDdwekTsnZlLx2kvgG8BhwEJvCUzv1i5vgHwQ+DZwCkR8cLM/NlkYpckSZL61VztmRmkSGTOA56UmR8HHuqivRMoEpkEDqsmMgCZeT7wpvJwJ+Bzbdr7fxSJDMDXq4lM2d6dwEuBW4DVge9ExKO6iF+SJEnqO3M1mbkPeDOwX2b+tZuGylfV9i0PzywTl1Vk5onA38rDl0fEbi3aGwA+XB6uqOw3trcU+EJ5uCHwvolHL0mSJPWvOZnMZOZNmfnFzMweNPfqyv7JbcqeUv43KHpfmnkeMDqw/4LMvG6c9qr3e2VErNnm/pIkSdKsMSfHzPRKOXblnyunLmhTpXr9JRS9Q41e0ml7mfm3iLgFeAywEfAsigkCJEmSpHEtW7aM4eFhFi9ezLx58xgaGmJgYGC6w5oQk5nu7AqsVe4/QDFz2Xj+UNnfNCK2atLz8pQW5Vu5giKJGa1rMiNJkqRxXXTRRSxYsICRkZGHzw0ODrJw4ULmz58/jZFNzJx8zayHnljZvzEzV7QpfxPFOJhm9YmIRwDbVk5d30EMN7RqT5IkSWq0fPnyVRIZgJGRERYsWMDy5cunKbKJM5npzhaV/VvbFc7MB4HqlMxbNBTZnGI8TcdtUsxo1qq9piLikmYb8PhO6kuSJKl/DQ8Pr5LIjBoZGWF4eHiKI5o8k5nurF/Zv7fDOve1qN/suJM2x2tPkiRJWsmiRYu6uj6TOGamO+tW9u/vsE41+Vi34VrjcSdtjtdeU5m5R7PzZe/M7p20IUmSpP40b968rq7PJPbMdGdZZX+tlqVWVi23rOFa43EnbY7XniRJkrSSoaEhBgcHm14bHBxkaGhoiiOaPJOZ7txV2V+nwzrVcnc1XGs87qTN8dqTJEmSVjIwMMDChQtXSWhGZzPrp+mZfc2sO9XZxjZpVzgiVqdYD2bUDQ1FbgSSsUkA2rbZUKaxPUmSJGkV8+fPZ/HixQwPD7No0SLXmZmjrqjsbx4Rq7WZnnkzVu4NW2kdmcy8OyKWANuVp7bsIIbqDGadrEsjSZIkMTAwwOGHHz7dYXTF18y683vGBumvCTyuTfnqOjA3NVkwE+A3lf2dO4ih2uZvOygvSZIkzQomM13IzDuBMyqn9mpTpXr9By3KVM+P215EbA88pjy8DTirzf0lSZKkWcNkpntfq+wf2qbsIeV/EziuRZmfATeV+3tHxHivmh1S2T8hMx9oc39JkiRp1jCZ6VJm/hg4tzx8TkQ8rVm5iDgMeGx5+J3MvLRFe8uB95eHqwHva9HeI4G3lIe3Ax+ZePSSJElS/zKZ6Y1XACMUs5CdHBE7Vi9GxF7Al8rDK4G3tmnvOODkcv81EfGGhvY2AL4HDAIPAS/PzH909QkkSZKkPjNnZzOLiP2B/Sun/qmyv31EfLJyfHVm/k+rtjJzSUQ8BzgFeALwh4g4FbiOYlKA51AkOhcAh2bm0vFiy8yMiFcCdwNHA1+KiFcD/wesDxxEMcXzUuA1mfmzTj6zJEmSNJvM2WSGYnD9v7a4tmXDtXOAlskMQGZeERG7A0dSjJ15CnAgcCvwC+BE4KQ2UzdX27sfeHVEnECR0OxTtr0cWAJ8Djg2M29q1YYkSZI0m83ZZCYzjwGO6XGb9wFfLbdetXkuY2NyJEmSJJUcMyNJkiSpL5nMSJIkSepLJjOSJEmS+pLJjCRJkqS+ZDIjSZIkqS+ZzEiSJEnqSyYzkiRJkvqSyYwkSZKkvmQyI0mSJKkvmcxIkiRJ6ksmM5IkSZL6ksmMJEmSpL5kMiNJkiSpL5nMSJIkSepLJjOSJEmS+pLJjCRJkqS+ZDIjSZIkqS+ZzEiSJEnqSyYzkiRJkvqSyYwkSZKkvmQyI0mSJKkvmcxIkiRJ6ksmM5IkSZL6ksmMJEmSpL5kMiNJkiSpL5nMSJIkSepLJjOSJEmS+pLJjCRJkqS+ZDIjSZIkqS+ZzEiSJEnqSyYzkiRJkvqSyYwkSZKkvmQyI0mSJKkvmcxIkiRJ6ksmM5IkSZL6ksmMJEmSpL5kMiNJkiSpL5nMSJIkSepLJjOSJEmS+pLJjCRJkqS+ZDIjSZIkqS+ZzEiSJEnqSyYzkiRJkvqSyYwkSZKkvmQyI0mSJKkvmcxIkiRJ6ksmM5IkSZL6ksmMJEmSpL5kMiNJkiSpL5nMSJIkSepLJjOSJEmS+pLJjCRJkqS+ZDIjSZIkqS+ZzEiSJEnqSyYzkiRJkvqSyYwkSZKkvmQy00MR8YiIeG1E/DQiro2IZRFxX0TcHBFnRcS/R8TgBNpbLSIOq7R3b0TcGBFnRsRrImKdOj+PJEmSNJOtMd0BzBYR8Szg28Dm5anfAT8HHgAeBzwLeCbwnoh4Y2Z+p017WwInAfsACZwJLAS2Ap5btvfWiDgkM6/o/SeSJEmSZjaTmR6IiD0oEpe1geXAwZn504YyOwI/BXYAToiI+zLzey3a2wg4HdgJuB14fmaeX7m+E3Aa8ATgjIh4WmYu6fkHkyRJmkWWLVvG8PAwixcvZt68eQwNDTEwMDDdYakLJjO98d8UiQzABxoTGYDM/EtEHAZcBATwuYj4YWY+1KS9z1MkMgBvrCYyZVtXRsThwK+BTYETgP1681EkSZJmn4suuogFCxYwMjLy8LnBwUEWLlzI/PnzpzEydcMxM10qx608o3Lq5FZlM/NiYFF5uBmwZ5P2dgNeVh5elZnfbdHWecBZ5eG+EfHCiUUuSZI0NyxfvnyVRAZgZGSEBQsWsHz58mmKTN3qqmcmIs5qX6pnMjOfPYX369TGrJwU3tym/M3AvHJ/a+CChuuvoui5ATilTVsnA6M/k6OBH7cpL0mSNOcMDw+vksiMGhkZYXh4mMMPP3yKo1IvdPua2TMoBqfXLaboPpPxD+A+xl4z2xS4fpzym1b272ly/cWV/cZEp1H1+v4RsUFm3tmmjiRJ0pyyaNGirq5r5urFa2YxBduMlZn3AT+snDq4VdlyooDRXpn7gQsbrm/NysnOH9rc/s/Ag+X+WsCTOghZkiRpTpk3b15X1zVz9WICgFOAr/SgnfG8HnhpzffoxtuAPSimYP5wRFyZmadWC0TEY4Hq+JfPZubfG9p5YmX/IeCm8W6amSsi4iaK6ZpH6587ifglSZJmraGhIQYHB5u+ajY4OMjQ0NA0RKVe6EUyc11mntODdlqKiOfX2X63MvOWiHgK8F7g/wE/j4iLgYsZW2fm2RQ/7xUUs5W9t0lTW1T2l7aY6azRLYwlM1uMV3BURFzS4tLjO6kvSZLUTwYGBli4cGHL2cycnrl/OTVzj2TmHRHxTYrXvl4JPLncRt0FfAv4n8y8skUz61f27+3w1ve1qC9JkqTS/PnzWbx4McPDwyxatMh1ZmYJk5keiIg1gc9QvA63GnAmcCTwW4pkY3vgCIrX0XaKiI9lZrOZ4Nat7N/f4e2rycy6LUtVZOYezc6XPTa7d3hfSZKkvjIwMOCsZbNMt8nMB4Hz25bq3unA3VNwn8k6Hjis3P8ucERmrqhc/xPwnoi4EPgR8JyI+Ghm/kdDO8sq+2t1eO9quWUtS0mSJEmzTFfJTGZ+sFeBtLnPGcAZU3GviYqIAxhLZO4G3tiQyDwsM38SEd+jmPHsvRHx18w8vlLkrsr+Oh2GUC13V8tSkiRJ0izTi6mZ57pXVPbPyMzb25T/38p+YzJYXZ9mo4hYvYP7b1LZv6GD8pIkSdKsYDLTvep0yn/poHy1zDYRUZ3Y/IrK/urAZuM1FBGrNZRpty6NJEmSNGuYzHRv7cp+J4P272s4fvToTmZeC9xcubZzm7Z2BNas3Pv3HdxfkiRJmhWmNZmJiLUi4s0RMRwRP4mID0fE5tMZ0yTcUtl/TAflN204vq3h+AeV/b3atFW9fnpmOmZGkiRJc0atyUxE/CwiFpXb6Q3X1qGYwvizwAuA51EsJHlFRDy1zrh6rDqb29M7KL9fZf82YHHD9W8AWe4f0qat6vWvd3Cx3tjVAAAgAElEQVRvSZIkadaoLZmJiCcAzwW2LbfGFYneB+w9WryybQh8PyLWqyu2HjuOYqFMKNaQeUGrghHxSIq1aEadkJkPVctk5qXAieXh4yLi0BZt7QU8pzw8NzN/PJngJUmSpH5VZ8/M6EP9JcBOmbnv6IUyUXkTYz0QJ5blXwUsoRjUfmSNsfVMZv4V+EDl1PERcWBjufL1uZ8AW5Sn/sKqs5mNegtwZbn/5TJxqba1I3ASRfJ3MyvPqCZJkiTNCd0umjme/YAHgEMz8+qGay8ANqBIZn6YmUeMXigXlvwjsAD4Uo3x9Uxmfiwi7gY+TtGzdGpE/B74LcWA/+2BZzG2JszpwJGtpnHOzKXl+jUnUfRenRcRvwT+CmxF0eO1JsVinIdk5pK6PpskSZI0U9WZzOwMnN0kkQF4YWX/Q9ULmfnniDiXlac8nvEy8wsRcQpFL8mzKT7/ERQ/47soErTfAidl5rkdtHddROwHHAq8HNiFYkzObRTjdE4Gjs/Me2v4OJIkSdKMV2cyswnw08aTEbEGcCBFr8zlmdlsbZS/AXvWGFstMvMW4JPl1ov2VgDfLTdJkiRJFXWOmUnG1kCpeibFK2YA32tR1ymGJUmSJI2rzmTmFuBxTc6/srLfKpnZDLij5xFJkiRJmjXqTGYuBfaOiN1HT0TErsDBFL02l2XmVY2VImJNit6bVa5JkiRJ0qg6k5mTyvbPjIivRsSXgXMYG6fzjRb1PgE8Gri4xtgkSZIk9bnaJgDIzP+NiDcB+wBHN1y+Cvja6EG5mOT7KRaBHJ3F7NS6YpMkSZLU/+rsmYFirZjvU7xWFuV2AXBQZt5fKbch8A6K6YdHF4L8Zc2xSZIkSepjdU7NTGbeARwcEZsA84AbM/O6JkVvphgnM+rWclpiSZIkSWqq1mRmVGbeCtw6zvX7KMbTSJIkSVJH6n7NrGMR8cSIeFNEPGW6Y5EkSZI089WWzETEWRHx2glU2R34PHBhRPwsItauKTRJkiRJs0CdPTPPALafQPmrgdOAZcCBwLtriEmSJEnSLDFjXjPLzPMy87kUCdANFItrSpIkSVJTMyaZGZWZt1CsMTNvumORJEmSNHPNuGSmtDHFejOSJEmS1FRPpmaOiP1aXNpqnGuNVgM2AJ4CDAGLexGbJEmSpNmpV+vMnA1kk/MHM/mxL6dOOhpJkiRJs14vF81s9lrYZF8V+yPwwS5ikSRJkjTL9SqZOb7JuVcCVwCXdNjGA8Dfgd8AP8/MB3oUmyRJkqRZqCfJTGYe1XguIl4J/CIz39WLe0iSJElS1UydzUySJEmSxtXLMTONtgPuqLF9SZIkSXNYbT0zmXlNZt4+mboR8c8R8YFexyRJkiRp9pipr5ntD/zndAchSZIkaeaaqcmMJEmSJI2r6zEzETEIvKU8/EJm3lyeP6uLZnfoNi5JkiRJs1svJgD4GbBbuX8A8ORy/xlATrLN6KKuJEmSpDmgF8nM5hTJB8CmDdcCSZIkSapBL5KZQ4GPUyQu72m4dizwsUm0+V7g6C7jkiRJkjSLdZ3MZOavgb1aXL4zM6+ZaJsRcWd3UUmSJEma7eqczewa4LZJ1l0KXNvDWCRJkiTNMr14zaypzNyui7ofBT7aw3AkSZIkzTKuMyNJkiSpL83IZCYiDo6I46Y7DkmSJEkz14xMZoD5wCunOwhJkiRJM1dtY2aaiYgNgUfQPonaYArCkSRJktTHak9mIuLlwFEUvS3r1X0/SZIkSXNDbclMRKwO/ABYMHpqgk1kbyOSJEmSNJvU2TPzWuAFlePbKdaOuRt4oE3d7YEtaopLkiRJ0ixQZzJzRPnfnwPvycw/dFoxIj4BvKOWqCRJkiTNCnUmMzsBS4AXZeaDNd5HkiRJ0hxUZzKzJvDLSSYyJwNX9DgeSZIkSbNIncnMtcD9k6mYmZcAl/Q2HEmSJEmzSZ2LZi4E9phMxYjYLiL263E8kiRJkmaROpOZzwLbRcRhk6j7BuBXPY5HkiRJ0ixSWzKTmTdSrDHzsYj4dETsUNe9JEmSJM09dS6aeVa5ezvwVuCtEfF34BrgHsZfFNPER5IkSdK46pwA4BmsnLAE8OhyaycYP9mRJElSG8uWLWN4eJjFixczb948hoaGGBgYmO6wpJ6pM5mBIikZ71iSJEk1uOiii1iwYAEjIyMPnxscHGThwoXMnz9/GiOTeqfuZOZY4GOTqPde4OgexyJJkjQnLF++fJVEBmBkZIQFCxawePFie2g0K9SdzNyZmddMtFJE3FlHMJIkSXPB8PDwKonMqJGREYaHhzn88MOnOCqp9+qcmvka4LZJ1r0a+HUPY5EkSZozFi1a1NV1qV/U1jOTmdt1UfcrwFd6GI4kSdKcMW/evK6uS/2izp6ZSYuI3SPiFdMdhyRJUj8aGhpicHCw6bXBwUGGhoamOCKpHjMymQEOA7453UFIkiT1o4GBARYuXLhKQjM6m5mD/zVb1D0BgCRJkqbB/PnzWbx4McPDwyxatMh1ZjQr1ZbMRMRxXVR38nNJkqQuDQwMOGuZZrU6e2aOBHKSdaOLutMuIrYGDgWeB2wHPAa4BxgBrgMuBk4Hzs3MFeO0sxpwCPAyYJeynduAK4FTgBMy8976PokkSZI0c9X9mllMsHxOos6MERFrAO+hWPRzHeBy4CzgLmBz4FnATsD+ZZntgCUt2toSOAnYh+LnciawENgKeG7Z1lsj4pDMvKK2DyVJkiTNUHUnM6cw/hTLATwC2Jbiof0FFA/tn6LPemYiYnXgROBg4E/AkZl5UUOZ9YBjgXH7eyNiI4qem52A24HnZ+b5les7AacBTwDOiIinZeaS3n0aSZIkaearO5m5LjPP6bDsFyNiC4oE6LDMfG2NcdXhvygSmWuBZ2bmLY0FMvOeiDgSOAB41DhtfZ4ikQF4YzWRKdu5MiIOp1hYdFPgBGC/rj+BJEmS1EfqnJr5HODqiVTIzBuAFwIvjYgX1hJVDSJiN+Bt5eG7miUyozLzAYpXxJ4J3NyirZeVh1dl5ndbtHMexStsAPv2089LkiRJ6oXakpnMfGZmfnUS9f4BnAq8vvdR1ea9wOrAUuCH7Qpn5uWZeXaLwfuvYmzc0Cltmjq5sn90J4FKkiRJs8VMXTTzVmDX6Q6iExGxMcVYH4Bzyp6Xbry4sn9Bm7LV6/tHxAZd3luSJEnqGzN10cx5wCOnO4gOPQdYq9z/0+jJiHgSsC8wCNwP3ECR7LR89a6c0nnTyqk/tLn3n4EHKX6PawFPAs6dYPySJElSX5pxyUxE7AkcCNw43bF0aI/K/khEPA34IrB7s8IRcSbw9sxslqg8sbL/EHDTeDfOzBURcRPFdM2j9U1mJEmSNCfUlsxERKeza60OrAdsDewN/Et57lc1hdZrO1f2/xn4BHA38CbgRxSvzG0FHEGxBs2zgQsjYigzz2hoa4vK/tLMfKiD+9/CWDKzxXgFR0XEJS0uPb6T+pIkSdJMUGfPzNlMbq2YAO4BPt7TaOqzcWX/+cBy4BkNPS9XA8dExGUUEwSsB/xvRDwpM6+tlFu/st9scoBm7mtRX5IkSZrV6n7NLNoXWcUi4KjM/Euvg6lJ49iez7Z4hYzMHI6IhcACYEPg/cCrK0XWrezf3+H9q8nMui1LrRzHHs3Olz02TV+PkyRJkmaaupOZK4BWrzSNWkHRE3M98Bvg15k5mR6d6bJmw/FJbcp/myKZATgsIl6fmQ+Wx8sq5daiM9Vyy1qWkiRJkmaZupOZX2Tmu2q+x3S7q7J/H5UZzVq4uLK/HsUU1KPnqm2t0+H9q+XuallKkiRJmmVm6joz/eT2yv5tHQzaH2k43qyyf31lf6OIWL2D+29S2b+hg/KSJEnSrFBnMrMb8Jka258p/lzZ7+T1uMaxMGtX9q+o7K/OyonOKiJitYYy7dalkSRJkmaN2pKZzLwsM8ddJ2WWuLSyv2EH5RsnDPj76E45s9nNlWs7M74dGRuzcz/w+w7uL0mSJM0KvmbWvZ9RTGIAsG5EbNum/I6V/RXAZQ3Xf1DZ36tNW9Xrp2emY2YkSZI0Z5jMdCkzbwSqi18e1KbKAZX9czJzacP1bzD2utohbdqqXv96m7KSJEnSrGIy0xvvBkYH/v9rRDSdiSwiNgReXx4m8J+NZTLzUuDE8vBxEXFoi7b2Ap5THp6bmT+eZOySJElSXzKZ6YHMvAz49/JwHvC9MnF5WEQMAj9mbPax92XmuS2afAtwZbn/5TJxqba1I8V6NkExxuYVXX8ISZIkqc/Uvc7MnJGZn4yI+4GPA88HFkfEacAtwBbA/sAjKBa2/NfM/Mo4bS2NiAMoEpa9gfMi4pfAX4GtgOdSDPz/E3BIZi6p7YNJkiRJM5TJTA9l5ucj4sfA0cDzKF4D24BiLZpLgdOBr2bmrR20dV1E7AccCrwc2AV4OnAbcD5wMnB8Zt5bx2eRJEmSZjqTmR7LzGuA95dbt22tAL5bbpIkSZIqHDMjSZIkqS+ZzEiSJEnqSyYzkiRJkvqSyYwkSZKkvmQyI0mSJKkvzbhkJiLWiYi1pzsOSZIkSTPbjEpmIuJwinVUlpb7kiRJktTUjEpmgE8D65Tbp6c5FkmSJEkz2ExbNPM+ICv7kiRJktTUTOuZeR1wU7m9bppjkSRJkjSDzaiemcw8FdhyuuOQJEmSNPPNtJ4ZSZIkSeqIyYwkSZKkvmQyI0mSJKkvTdmYmYjYDngJsCfFuJj1gbuA64HfAN/LzCVTFY8kSZKk/lZ7MhMRjwI+DxxM856g+cAQ8NGIOAV4a2b+o+64JEmSJPW3Wl8zi4jtgUuBQ4HVgRhnWx04DLg0IubVGZckSZKk/ldbz0xErAOcCmxBkaysoEhs/gjcCiwHBoDHAP8E7FaW2xI4NSJ2yUwXzpQkSZLUVJ2vmb0R2AFI4NPAJzJzpFXhiNgU+HfgzWW9N5b1JEmSJGkVdb5m9lKKRObVmflv4yUyAJl5c2a+DXgdRQ/NwTXGJkmSJKnP1ZnM7AhcnpnHTaRSZn4N+ENZX5IkSZKaqjOZWRP4v0nWvQBYq4exSJIkSZpl6kxmbuyy/i09iUKSJEnSrFRnMvMr4MmTrPtk4MIexiJJkiRplqkzmfkSsEtEvGgilcryewDfqCUqSZIkSbNCbclMZl4OvAX4dkS8OSLGHQMTEWtGxJuB7wJfyswz64pNkiRJUv/rap2ZiPhAB8UuAj4LfCgizgOuAu6kWERzNWB94LHAvsAGwA3ArRHxgcz8UDfxSZKkuWfZsmUMDw+zePFi5s2bx9DQEAMDA9MdlqQadLto5jEUa8m0E8AjgYPalAHYAvjPct9kRpIkdeyiiy5iwYIFjIyMLW83ODjIwoULmT9//jRGJqkOvXjNLDrYOinbWEaSJKljy5cvXyWRARgZGWHBggUsX758miKTVJdue2YATgX+twftVB0CHNDjNiVJ0iw2PDy8SiIzamRkhOHhYQ4//PApjkpSnXqRzPwxM4/vQTsPi4idMZmRJEkTsGjRoq6uS+o/dU7N3A1fNZMkSRMyb968rq5L6j/d9sxsB9zR7EJE7Ndw6sLMfKDDdj8CfKGbwCRJ0twyNDTE4OBg01fNBgcHGRoamoaoJNWpq56ZzLwmM29vcfls4FeVbZMJtHt7Zl7TTWySJGluGRgYYOHChQwODq50fnQ2M6dnlmafXoyZaecG4CcUa8tIkiTVZv78+SxevJjh4WEWLVrkOjPSLFd3MnM98E+ZeXfN95EkSQKKHhpnLZPmhjonALgdOM1ERpIkSVId6kxmltTYtiRJkqQ5rs5k5kdA44xmHYmIT0TEgz2OR5IkSdIsUmcy80VgvYh41yTru86MJEmSpJZqS2Yy8zbgBcAbIuL4iNilrntJkiRJmntqm80sIs4qd28HXg68PCKWAouBu4Ecp/oOdcUlSZIkaXaoc2rmZ7BywhLAxsBGHdQNxk92JEmSJM1xda8z02zci2NhJEmSJHWt7mTmWOBjk6j3XuDoHsciSZIkaRapO5m5MzOvmWiliLizjmAkSZIkzR51Ts18DXDbJOteDfy6h7FIkiRJmmVq65nJzO26qPsV4Cs9DEeSJEnSLFNnz8ykRcR2EbHfdMchSZIkaeaakckM8AbgV9MdhCRJkqSZa6YmM5IkSZI0rrpnMwMgIjYADgR2BR4FrNmmyvzag5IkSZLU12pPZiLi7cB/AutPpBqQ9UQkSZIkaTaoNZmJiA9TLIAZE6hmEiNJkiSprdqSmYjYmbFEZhj4HnAz8DrgpcCzKsVXA7YGjijP/wj4XF2xSZIkSep/dfbMvJYikflYZv7H6MmIeB5AZp7TpM7xEfFfwNspEqG+FxGbA38CHlmeOiozvzV9EUmSJEmzQ52zme0LjAAfnmC99wI3AK/veUTT40uMJTITFhGrRcRhEfHTiLg2Iu6NiBsj4syIeE1ErNPDWCVJkqS+UWcyszXwm8y8dyKVMvMh4EzgGXUENZUi4iXAi7qovyVwDvBd4CDgL8A3gIuB/YCvApeUr/RJkiRJc0qdr5k9Ari2yfkHASJi7cy8r0XdB4Bt6gpsKkTERsAXKCY0+DuwySTqnw7sBNwOPD8zz69c3wk4DXgCcEZEPC0zl/QmekmSJGnmq7Nn5i6aP8DfUf73sePU3REY6HlEU+tTwKYUvSd/mkT9z1MkMgBvrCYyAJl5JXA4RbK0KXDC5EOVJEmS+k+dycxVwN4R0dj7s4hiYoBXNKsUEXtQvEK1tMbYahURzwaOohj78+5J1N8NeFl5eFVmfrdZucw8DzirPNw3Il44iXAlSZKkvlRnMnMRsAWrTgBwIUVvwtsi4h0Rse7ohYh4JsUUzgH8rsbYalN+nmPLwzdm5p2TaOZVjK3Nc0qbsidX9o+exL0kSZKkvlRnMnMqxQP5uyLiwrK3gsy8jmKA/xrAJ4ClEXFdRNwO/BLYtqz/nRpjq9OHgHnA9zPzx5Ns48WV/QvalK1e3z8iNpjkPSVJkqS+UmcyczrFwPcA9gSeXrn2DuCecn9Nih6cDRjrjTiz1atVM1lEPBl4G8WA/TdPso2tKcbAjPpDmyp/ppxUAVgLeNJk7itJkiT1m9qSmcx8ENieYhKATYCPVa5dARwILG6sBhxPF9MZT5dybNA3gNWBd2bmzZNs6omV/YeAm8YrnJkrGso8sVVZSZIkaTapc2pmMvOuca6dHxGPpei12Zaip+a3mTlSZ0w1ejewC3A2RVIzWVtU9peW6+60cwuwVZP6TUXEJS0uPb6De0mSJEkzQq3JTDuZmcD/lVvfiogdgfcD9wKvKT/XZK1f2e90wdHqej3rtywlSZIkzSLTmszMBhERwNeAtYH3ZuZVXTa5bmX//g7rVJOZdVuWKmXmHs3Olz02u3d4T0mSJGla1TkBwFzxOmBf4DKK2dm6tayyv1aHdarllrUsJUmSJM0iJjNdiIgtgY9TDNQ/upz0oFvVcUbrdFinWq7lOCVJkiRpNukqmYmIhyLiv3oVzDj3+URE9CJR6LUvU0wp/bnMvLhHbV5f2d8oIlbvoM4mlf0behSHJEmSNKN12zMTjK0NU7epus9ELCj/+46IyFYbK6+x882G62c3tHlFZX91YLPxAoiI1RrKtFuXRpIkSZoVnACgO5/qsNwhwJbl/i+AP1auXV0tmJnXRsTNjC2cuTMr99Y02pFi4VEoJgz4fYcxSZIkSX3NZKYLmflvnZSLiCczlsyckpnfalPlB8Aby/29KBKgVvaq7J8+3to+kiRJ0mzSi2TmkPJhvU471Nz+TPMN4A0Ur9YdAnxgnLKHVPa/XmdQkiRJ0kzSi2RmS8Z6HeoSQDcLUfaVzLw0Ik4EXg48LiIOzcyTG8tFxF7Ac8rDczPzx1MZpyRJkjSdejE1c0zBNhe9Bbiy3P9ymbg8LCJ2BE6i+PncDLxiasOTJEmSple3PTPP7EkUs0xE7A/sXzm1fWX/kIjYuXL8/2Xm0sY2MnNpRBxAkbDsDZwXEb8E/gpsBTyXYuD/n4BDMnNJbz+FJEmSNLN1lcxk5jm9CmSW2Qv41xbXDiy3UV8EVklmADLzuojYDziU4pWzXSimeb4NOB84GTg+M+/tUdySpD60bNkyhoeHWbx4MfPmzWNoaIiBgYHpDkuSaudsZjXIzGOAY3rU1grgu+UmSdJKLrroIhYsWMDIyMjD5wYHB1m4cCHz58+fxsgkqX69GDMjSZKmwfLly1dJZABGRkZYsGABy5cvn6bIJGlqmMxIktSnhoeHV0lkRo2MjDA8PDzFEUnS1DKZkSSpTy1atKir65LU70xmJEnqU/PmzevquiT1O5MZSZL61NDQEIODg02vDQ4OMjQ0NMURSdLUMpmRJKlPDQwMsHDhwlUSmtHZzJyeWdJs59TMkiT1sfnz57N48WKGh4dZtGiR68xImlNMZiRJ6nMDAwMcfvjh0x2GJE05XzOTJEmS1JdMZiRJkiT1JZMZSZIkSX3JZEaSJElSXzKZkSRJktSXap/NLCI2A+YDjwW2AtYH1gTuAW4FlgCXAZdn5gN1xyNJkiRpdqglmYmIvYBDgIOAeR1WuzcizgF+ApySmUvriE2SJEnS7NCz18wiYiAi3hgRfwHOBd5EkchEh9sAcADwJeCmiPhOROzeq/gkSZIkzS5d98xExJrAG4D3AJuMni7/uwL4K3A5cA1wE8XrZQ9SJC8bA1sAjwd2ATYs660FHAYcFhE/B/4jMy/vNlZJkiRJs0dXyUxEHAR8jrEeGIC/Az8CFgK/zsw7JtDeLsCzgX8B9irbPAg4MCK+RpHU+PqZJEmSpK57Zn5a2T8D+Arwk8x8aDKNlb0vlwOfiYitgVcDr6Ho8XktcDPwoa4iliRJkjQr9GLMzI+BPTLzgMwcnmwi0ygzr83M9wPbAG8FbulFu5IkSZJmh257ZvbJzAt6EkkLmXkv8IWIOI7OZ0aTJEmSNMt11TPTKpGJiI26abfFve7JzD/0ul1JkiRJ/alnUzM3uKqcprmu9iVJkiTNcXUlGxsDnwcuj4j9a7qHJEmSpDmsrmTmdopplXcCTo2In0TE42q6lyRJkqQ5qK5kZgeKaZpXUCQ1z6PopflkRGxQ0z0lSZIkzSG1JDOZeVtmvgHYHfgVRUKzFvB24G8R8ZqIiPHakCRJkqTx1DpAPzP/kJnPBl4MLKJIah4N/A9waUQ8s877S5IkSZq9pmS2scwcBp4AvBe4iyKpeSLwy4j4QUS4fowkSZKkCZmyqZMz8/7M/DjwOOCE8nQALwL+GBEfi4hHTFU8kiRJkvrblK8Dk5kjmXkksCdwIUVCszbwLor1aY6a6pgkSZIk9Z9pW9QyMy/OzL2BI4AbKJKaQeDrEXFxROwzXbFJkiRJmvmmLZkZlZknAo8HvleeCopZ0M6JiJMjYptpC06SJEnSjLXGdNw0IrYAngLML/+7B7ABkNViwEuBBRHxceC/MvP+qY5VkiRJ0sxUezITERtRJC2jict8itfJVirWcLwCuBV4DDAAHAMcGhGvyMxLag1YkiRJ0v/f3p2HV1ZVCRt/FyAQ5kEJggNGRWkUUAkqipaMgqb9gnwCpa3YTq22dNuOoCig3SK2fk7ddrcDaDsgKhFKBUG0EMGhUMQJFEkQRAioYAEVEGV9f+wTciqVm9yq3Nwh9f6e5zzZ95x991lJbqXuuufstXvCgiQzEfHPTCUvM5Vdnp683Ap8n1IQ4HvA9zNzZUQcRUlkdgV2A74TES/JzM8uRNySJEmSesdCXZl5H1O3jM101eVnlKTlu8B3M/OXMw2SmWdExBeAfwHeQal6dnpE/NIrNJIkSdL6bSFvM5tMYv7IVOIyedXljmYHycy/Au+JiBXABcCGwOuApa0NV5IkSVIvWahk5r+ZuupydSsGzMzl1VWao4AntWJMSZIkSb1rQZKZzHzlQowL/JCSzOy8QONLkiRJ6hEdX2dmLd1Vfe1ISWlJkiRJ3aPXkoLzgZMoi2pKkiRJWo/1VDJTzb85qdNxSJI6a9WqVYyMjDA2NsbAwADDw8P09fV1OixJUpv1VDIjSdKKFSsYGhpifHz8vn39/f0sW7aMwcHBDkYmSWq3ec2ZiYjTIqItk/Ej4uiIOKYd55IkdaeJiYk1EhmA8fFxhoaGmJiY6FBkkqROmG8BgBcBV0fEhyJil/mHs7qI2KBKYn4MfBp4SKvPIUnqHSMjI2skMpPGx8cZGRlpc0SSpE6abzIzCmwKvIqS1JwTEcMRscl8Bo2IXSPiROA3lCRmDyCBsXnGK0nqYaOjo/M6LklaXOY7Z2Z34I3AG4AtgGdV250R8U1gObAC+GlmrpxpgIgI4BHAnsBTgQOB3SYPV18vBY7NzB/NM15JUg8bGBiY13FJ0uIyr2QmM+8G3hER/wUcD7wU2JyS2AxVGwARsRK4EVgF/IVyRWc7YEdgw2lDTyYxlwEnZ+ZX5hOnJGlxGB4epr+/f8Zbzfr7+xkeHu5AVJKkTmnJopmZeUtmvhZ4MOVKzc8pCUl92xp4FPA4YBB4LLAzJaGq97sL+Czw9Mzcx0RGkjSpr6+PZcuW0d/fv9r+yWpmlmeWpPVLS0szZ+ZtwL8D/x4RuwOHAU8H9gZ2YOqKS909lOTn+5RFMc/PzDtbGZckafEYHBxkbGyMkZERRkdHXWdGktZjC7bOTGb+nJKkvAcgIrakXLnZqjrvKuAW4IbMvHeh4pAkLT59fX0sXbq002FIkjpsXslMRHwX+CFwUWZ+Yba+mXk78Iv5nE+SJEmSJs13zswTgVcCn6tuK5MkSZKktmhJAQDKXJjjWjSWJEmSJM2plcnM8yLi4S0aT5IkSZJm1apkJilrxZzSovF6TkQ8JCJeGxEjETEWEXdGxF0RcVNEfCsiToqIXdZyzA0i4uiI+EpEXFeN97uIuDAiXh4Rmy7MdyNJkiR1v1ZVM5ssuYHlqE4AACAASURBVHx4ROybmZfOe8CIQ4DnUtan+TUwkpmXzXfcVouIfYATgUOrXRPAcuBrlJ/L7sDTgCXA8RFxKnDCXBXcIuJBwOeAp1KSxQuBZZSKcIcC+wP/FBFHZubPWvpNSZIkST2gVcnM2cBzKG/ePxgRT8zMv67rYBHxbuD103a/OSJGgBdXldG6xbFMJTLnAC/JzN/XO0TEnsBZwABwPGWx0GMaDRgR21LW3NkNuA14dmZeUju+G/B14G+ACyLiyZl5bYu+H0mSJKkntOo2s4uBM6r245hHMYCIeBQlkYkZtmHgvIhYsPVx5uFnwBHTExmAzLwCeBZlgVCAF0XEc2YZ64OURAbg1fVEphrvSmAp5YrNjsCn5hm7JEmS1HNalcwAvAH4EyXpeGtEPH4dx3lqNUYCn6AkR08BvlntfxLwD/OOtvU+kJn3NDqYmVdRrmBNetlM/SLiccDzq4dXZ+ZnG4z3HcrPBGC/OZIjSZIkadFpWTKTmTcA/1w93BgYiYgd1mGoB9Tax2bmFZn5XcptbL+r9h+97pG23G+AKyjzZObyvVr7CQ36vISpOUifn2O8M2rtlzZxfkmSJGnRaOWVGTLzk8AXq4cPAs6OiC3Xcphtq693ZOaq2th3Ut7c3w48Zr6xtkpmviUz98rMXzfR/Y5ae6sGfZ5ba89VSKF+/OCIaDSmJEmStOi0NJmpHEO5UhHAPpQJ6tusxfP3qr7eOv1AZr4uM7ehi5KZtfSgWvua6Qcj4iGUOTCTfjrHeFcBf6naGwN7zis6SZIkqYe0PJmprqb8LTBW7RoEVkTE3nM9NyJ2BJ5OmS9z5SznuL4FoXbC7rX2WTMcf2yt/VfgxtkGq8o71/s8tlFfSZIkabGZb1Wwn1HKA68mM6+PiCWUCeoPr7bvRMT/AO/KzDXepFcVyj5GucKQwHfmGVtXiYjtgMOqhyuBD8/Qbeda+9Ymy1vfTFl7ZvrzZ4vlhw0OPbqZ50uSJEndYF7JTGbuUc2J2WyGY9dXC0qeARxESVJeDbw8Ii4GLgCuptwm9UjKxPfJN9P3AKfNJ7Yu9Apgk6r95plKOAP1+UV3NTnu3Q2eL0mSJC1q816vpVrAcsZFLDPz1oh4JvAa4CRga0pSs3+1TTdZkvmUzPzdDMd7UkQ8AnhL9fCszPxIg671pPDPTQ5fT2bWSCpnkpkzVlKrrtisa0ltSZIkqa0WogDAarL4IOXqy0mUOR4zLYgZlHkip2bmiQsdV7tExBbAF4DNgcuAF87SfVWtvXGTp6j3W9WwlyRJkrTIzPvKTLOq26pOAk6qFtR8KjAA7EApWfxL4MuZuUaVr14VERtTEpm9KJXJDq1KTDdSv8K1aZOnqfeb8QqZJEmStBi1LZmpy8wfAT/qxLnbJSI2oSQyzwQuBw5uME+m7re19rYRsWETRQDqi4zesPaRSpIkSb1pwW8zWx9FRB9wDjAEfA/Yv4lEBkp1uEkbAg+c4zwbTOsz17o0kiRJ0qJhMtNi1RyZc4GDgeXAQZl5WzPPzczrgJtqu+ZaHPRRwP2q9p+BH69VsJIkSVIPM5lpoYjYhlJy+unAecBhmXnHDP32jogjIuIB048BX6q1953jlPXj51eV5SRJkqT1gslMi0TE/SmLhD4J+DLwnMycaND9HynzaXaf4djHKeWpAY6c47T14x9rPlpJkiSp95nMtEBE7Ei5pexxwOeA/5uZza4Ts5rMvBz4TPVw14g4qsE59wUOrB5enJlnr8v5JEmSpF7VkWpmi0lEPBi4kLKOzu2UOS+nRMRsT9t7jmGPBZ4A7Ab8Z0Rcl5mX1s75KErSFNX5Zlu7RpIkSVqUTGbm77OURAZgS+C18x0wM2+NiEMoCctTgO9ExDeAXwEPBg6lTPz/BXBkZl4733NKkiRJvcZkZv62XIhBM/P6iHgacBTwAmAPSmGBPwKXAGcAn8zMuxbi/JK6z6pVqxgZGWFsbIyBgQGGh4fp6+vrdFiSJHWMycw8ZeZeCzj2vZQrP59dqHNI6g0rVqxgaGiI8fHx+/b19/ezbNkyBgcHOxiZJEmdYwEASepyExMTayQyAOPj4wwNDTEx0ahwoiRJi5vJjCR1uZGRkTUSmUnj4+OMjIy0OSJJkrqDyYwkdbnR0dF5HZckabEymZGkLjcwMDCv45IkLVYmM5LU5YaHh+nv75/xWH9/P8PDw22OSJKk7mAyI0ldrq+vj2XLlq2R0ExWM7M8syRpfWVpZknqAYODg4yNjTEyMsLo6KjrzEiShMmMJPWMvr4+li5d2ukwJEnqGt5mJkmSJKknmcxIkiRJ6kkmM5IkSZJ6ksmMJEmSpJ5kMiNJkiSpJ5nMSJIkSepJJjOSJEmSepLJjCRJkqSeZDIjSZIkqSeZzEiSJEnqSSYzkiRJknqSyYwkSZKknmQyI0mSJKknmcxIkiRJ6kkmM5IkSZJ6ksmMJEmSpJ5kMiNJkiSpJ5nMSJIkSepJG3U6AElqZNWqVYyMjDA2NsbAwADDw8P09fV1OixJktQlTGYkdaUVK1YwNDTE+Pj4ffv6+/tZtmwZg4ODHYxMkiR1C28zk9R1JiYm1khkAMbHxxkaGmJiYqJDkUmSpG5iMiOp64yMjKyRyEwaHx9nZGSkzRFJkqRuZDIjqeuMjo7O67gkSVo/mMxI6joDAwPzOi5JktYPJjOSus7w8DD9/f0zHuvv72d4eLjNEUmSpG5kMiOp6/T19bFs2bI1EprJamaWZ5YkSWBpZkldanBwkLGxMUZGRhgdHXWdGUmStAaTGUldq6+vj6VLl3Y6DEmS1KW8zUySJElSTzKZkSRJktSTTGYkSZIk9SSTGUmSJEk9yWRGkiRJUk8ymZEkSZLUk0xmJEmSJPUkkxlJkiRJPclkRpIkSVJPMpmRJEmS1JM26nQAkqasWrWKkZERxsbGGBgYYHh4mL6+vk6HJUmS1JVMZqQusWLFCoaGhhgfH79vX39/P8uWLWNwcLCDkUmSJHUnbzOTusDExMQaiQzA+Pg4Q0NDTExMdCgySZKk7mUyI3WBkZGRNRKZSePj44yMjLQ5IkmSpO5nMiN1gdHR0XkdlyRJWh+ZzEhdYGBgYF7HJUmS1kcmM1IXGB4epr+/f8Zj/f39DA8PtzkiSZKk7mcyI3WBvr4+li1btkZCM1nNzPLMkiRJa7I0s9QlBgcHGRsbY2RkhNHRUdeZkSRJmoPJjNRF+vr6WLp0aafDkCRJ6gneZtblImLHiDghIi6LiN9HxKqIuDoiTouI/TodnyRJktQpJjNdLCIOB34BnAwMAF8HPgWsAo4Bvh0RH42IjTsWpCRJktQh3mbWpSLiWcCZwIbAhcDhmbmydvwfgQ8CLwU2j4jnZ2Z2JNh5WrVqFSMjI4yNjTlPRJIkSU0zmelCEbE98GlKInMzcEQ9kQHIzA9HxJ6UZOZo4BvAJ9od63ytWLGCoaEhxsfH79s3WcFrcHCwg5FJkiSp23mbWXd6K7BN1f5gZt7WoN87gMmrMe+MiE0XPLIWmpiYWCORARgfH2doaIiJiYkORSZJkqReYDLTZSLifsCLarvOaNQ3M68DLq0ePhB41gKG1nIjIyNrJDKTxsfHGRkZaXNEkiRJ6iUmM93nAGDbqn1zZl4zR/9La+0jFiakhTE6Ojqv45IkSVq/mcx0n31q7Z820b/eZ5+GvbrQwMDAvI5LkiRp/WYy030eW2v/ton+N9TaD4uILVocz4IZHh6mv79/xmP9/f0MDw+3OSJJkiT1EquZdZ+da+1bmuh/c60dlLkzV8/2hIj4YYNDj27ifC3T19fHsmXLGlYzszyzJEmSZmMy0322rLXvaqL/3bM8v+sNDg4yNjbGyMgIo6OjrjMjSZKkppnMdJ/Nau0/N9F/ejKz2Yy9ajLzCTPtr67YPL6Jc7ZUX18fS5cubfdpJUmS1OOcM9N9VtXaGzfRf3qfVTP2kiRJkhYZk5nuc3ut3cwimNP73D5jL0mSJGmRMZnpPvUKZg9oon+9TwI3tjYcSZIkqTuZzHSfn9XaD2qif7362Vhm3tHieCRJkqSuZDLTfb5faz+mif71dWl+0OJYJEmSpK5lMtN9vgncWrX7I2Jgjv771tpfXJiQJEmSpO5jMtNlMvMe4JO1XUc16hsRD2IqmbkR+OoChiZJkiR1FZOZ7vRO4LaqfWxEbN2g3wlM/Q7fmpnNLLIpSZIkLQomM10oM/8AvAD4K9APfCEitqr3iYhXAS+rHn4OOK2tQUqSJEkdtlGnA9DMMvOrEXEk8FHgIGAsIs6lrCPzZGDPquvHgVdlZnYmUkmSJKkzTGa6WGZ+KSIuAV4O/B/gMKAP+B3wKeDjmfntDoYoSZIkdYzJTJfLzJuAk6tNkiRJUsU5M5IkSZJ6UjjVQpMi4g99fX3b7bbbbp0ORZIkSYvYlVdeycTExB8zc/v5jGMyo/tExBiwFXBth0NZ3z26+npVR6NQt/L1oUZ8bagRXxuaTadeH7sAKzPzYfMZxGRG6jIR8UOAzHxCp2NR9/H1oUZ8bagRXxuaTa+/PpwzI0mSJKknmcxIkiRJ6kkmM5IkSZJ6ksmMJEmSpJ5kMiNJkiSpJ1nNTJIkSVJP8sqMJEmSpJ5kMiNJkiSpJ5nMSJIkSepJJjOSJEmSepLJjCRJkqSeZDIjSZIkqSeZzEhSj4mInSLitojIajum0zFJkrpHRBwcEddW/0cs73Q8C2mjTgcgrc8i4iHAc4GnAXsBOwAbArcBVwLfBk7LzGs7FaO60n8AW3c6CHWH6u/IUcCzgIdR/o7cCYwD1wOXAecDF2fmvZ2KU+0TEVsAzweGgD2A+1P+b7kV+AXl9XBaZo53LEgtiIjYBngf8OIWjLUJ8CLgSGA3YDvgZuCnwGeAM7rhb4qLZkodEBH7ACcCh1a7JoDlwBgQwO7AUylXT/8CnAqc0A1/NNRZEXEE8IVpu1+cmad3IBx1UERsBBwHHA9sCvwEuBy4HdgJ2B/YpvaUh/nByOIXEfsD/0t5DQD8CFgB3APsSnldbASsBF6dmZ/uRJxqvYh4DvAR4IGUvwNbVocuyswlaznW7sDnKe9H/gKcS/lwZFfgAMp7lUuAozLzt62If115ZUbqjGOZSmTOAV6Smb+vd4iIPYGzgAHKm5WdgWPaGKO6TERsC3wISOD3wAM6G5E6JSI2pHwy+jzKJ+3HZOaKaX02B/4HWNr+CNUJEfEE4GvAJpQPyZ6XmV+Z1udRwFeARwCfioi7M3P6ByTqIRHRB5xGuYJyF+VDjluAj63jeLsA3wB2pCQwB2fmVbXjT6G8hp4CnB8RT8nMW+fxLcyLc2akzvoZcMT0RAYgM6+g3DZyT7XrRdWnLlp/vZfyn8t/U97Aav31bkoicx3wjOmJDEBm3kn5AOQP7Q1NHXQqJZEBeNv0RAYgM38JHF09DOADVXKs3tVPSWS+A+yZmacAf53HeJ+i/F+TwNH1RAYgMy8B/rF6uBvwgXmca95MZqTO+kBm3tPoYPUH5OzarpctfEjqRhFxAOUe6BuAN3U4HHVQRDwO+Ofq4Rsz8+ZGfau/L/sDzwBuakN46pCI2BRYUtt1RqO+mXkZMFo9fCDwxIWLTG1wN/Aa4GmZ+av5DFR9aLpf9fDCKnFZQ2Z+Bvh19fAF1d+ljjCZkTrjN8AVlHkyc/lerf2EBYlGXS0iNqPcLgTlHveVnYxHHXc8U5O5z5qrc2b+JDOXZ+ZdCx6ZOmk7Vn9fN1fyWj/+kNaHo3bJzBsz88PZmonw9Q9NGybElc9XXwP4+xace52YzEgdkJlvycy9MvPXc/fmjlp7q4WKSV3tZMrcqS9m5tlzddbiFRHbAX9bPbxotiu7Wu/8gfIJ/aQd5+hfP35n68NRr4mIrYCDarsuneMp9eNHtD6i5lgAQOp+D6q1r+lYFOqIiNibckvRbZTbCLR+OxDYuGrfN2+qKhiyH+Xe+T9Tbke8KDP9m7GeyMy7I+IspubDPI9SoncNVaGAgerhn4HvLnyE6gF7MfX35R7gl3P0/2mtvWNEPDgzr1+QyGZhMiN1v91r7TlvKdHiUZXe/TjllqI3ZKZzHlS/1XQ8Ip4MfBh4/EydI+JC4LWZ+dOZjmvR+WfKa2RX4B0RcWVmnlvvEBGPBD5b2/X+mYrQaL302Fr7d00sB3EjcC9Td3o9llL9rK28zUzqYtUtJYdVD1dS3rRo/fEmyoJ3yylJjfSYWvsgymtjF0ploQdRKlk9AjiJ8on7AcB3I+IgtOhVxSD2oVQ1WwV8LSJWRMRHIuKDEXEe5YrerpQ3oe+nzMGSoCwBMemWuTpn5l8oc/dmen7beGVG6m6vYKrM5pv99Gz9Ua0FcQJlzYCXt2hip3rfdrX2sylriSyZduXlGuDEiLiCcjV3c+DMiNgzM69rX6jqhMz8U0ScRlno8EXA3tU26XbgdOAjmXll+yNUF9uy1m62YEh9ntaWDXstIK/MSF0qIh4BvKV6eFZmfqST8ah9IiKAj1IS2ZMz8+oOh6TusfW0x+9vdAtZZo4Ay6qH21CSYy1iEXG/iPgw8HPKFZerKFfwtgY2pdy2/B+UilUfjIj9OxWrutJmtfafm3xOPZnZrGGvBWQyI3WhiNgC+ALlE9XLgBd2NiK12T9QJnNfAbynw7Gou9xv2uPPzdH/f2vto6t5WFq8Pgm8mvL+7rOUldu/kZkrM/PuzPxFZh5HWWDxAODCiPjXDsar7rKq1t64Ya/V1futathrAZnMSF0mIjamJDJ7USqFHFqt5K31QEQ8CJhcvfml1T3J0qTba+27qVU0a+CyWntzyt8VLUIRcQhTlczuoKxJNeME7sw8h/L/DMDxEfGiNoSo7lf/+7Jpk8+p97u9Ya8FZDIjdZGI2AT4IvBM4HJgf+fJrHf+k7Ke0AeqVbqluttq7T9m5l/n6D8+7fEDWxyPukf9Cv4FmXlbw57FmbX2SQsQj3rPb2vtB8zVOSI2BLat7bqh5RE1wWRG6hIR0QecAwwB38NEZn01VH39l4jIRhvw9NpzTpt2fHn7w1abXFVrN1MUYvp975vM2EuLQb2s7lzrg0zv89CIGGjYU+uLn9XaO0XEXHnCA1k9l+hICXjvnZW6QDVH5iuUN6jLgaHMvKOjQalT3ttkvyOZWlD1PMqE30kulLh4XV5rb9NE/+kFA/yAZPGqJ6rNTN6+e9rj+wOjrQtHPejHlNfOxpT5ebuy+gco09UT6Bs7sWAmmMxIHRcR2wDnAk+ivCk9PDMnZui3N2U9iYsyc8767+pNmfn6ZvpVr4fJZObzmXn6ggWlbvJVphap2ywidsnMa2fp/6ha+15KUQktTjdT3nwC7NBE/x2nPf5ja8NRr8nMlRFxAfCsate+zJ7M7Ftrf2nBApuDt5lJHRQR9we+SUlkvgw8Z6ZEpvKPlAmbu7cpPEldJjN/B1xQ23VYo76VQ2rtizLz1oY91esuqbWf3rDXlKfV2n8ExlobjnrUR2vto+boe2T1NYFPLEw4czOZkTokInak3FL2OEp51f+bmc3WdZe0/noTpdodwOsiYsaqQ9VV31dWDxN4extiU+d8grJQJsBuEfG3jTpGxNZMvTYAPtVEMQmtBzLzbODi6uGBEfHkmfpFxNHAI6uHn87My2fq1w7eZiZ1QEQ8GLiQ8ofgduAm4JSyVmJDe892UNL6ITOviIg3U9YgGgC+EBF/V69eFRH9lGpVkxWJ3pqZF685mhaLzPxVRLwN+Ldq1ycj4ujMPK/eLyJ2onyAtnO165dYzUyreyGlEFE/cEZEHJyZ9xWMiIh9KYuvAlwJ/FP7Q5wSmc0UQ5HUShFxMfDUdXz6MzJzeQvDUQ+IiIOBg2u7ZisA8K/eTrT4RcSxlDWJ+iglm79OmTexM+W1sgVlEbvXZeZ/dSpOtVdEvIbyuphcjf3HwA8oE/4fDuzP1Nog5wPHZOaN7Y5TrTXD/xG7U5Z5gFJy+fO1Y9dk5kfmGO8x1XP+BriHMrf3esq8rAOBAC4FjurUxP9JJjNSB0TEj4E91/HpJjProYg4keZvE3rYHJPCtUhExEOBl1Im7D6EskbRbZRJu+cD/23BkPVPROxA+XT9AOAxwPaUu3Fup8yN+QHwOa/WLR5r+X/ERZm5pIkxNwGOocydeTSwHXAL8BPgM5TX0IwLs7aTyYwkSZKknmQBAEmSJEk9yWRGkiRJUk8ymZEkSZLUk0xmJEmSJPUkkxlJkiRJPclkRpIkSVJPMpmRJEmS1JNMZiRJkiT1JJMZSZIkST3JZEaSJElSTzKZkSRJktSTTGYkSZIk9SSTGUmSJEk9yWRGkiRJUk8ymZEkSZLUk0xmJEmSJPUkkxlJaoOIyGq7tkPn3zQifl3F8Mk2nO8pte/52S0cd0lt3DW2Vp2nlSJilwbxntjp2NR6EXHiLK/R5Z2OT1psNup0AJKktngD8HDgbuCEhT5ZZl4SEWcDzwE+EBEXZObdLT7Nb4HPt3jMhfAn4L1Ve3fgmR2MZVGIiKcBZwA3As/OzBs7HFLdpUz9vgEeDDyvQ7FIi57JjCQtchGxA/DG6uEnMvO6Np36ZEoyMwC8Cvh/LR7/msx8fYvHbLnMvBV4PUBEHIPJTCu8G3hgtR0LHNeoY0ScDryoeviMzFy+kIFl5vnA+bXzL8FkRlow3mYmSYvfccAWwL3Av7frpJn5I+CCyRgiYvN2nVuLXnQ6AEndwWRGktogM6PadmnneSNiW+Bl1cPzMnO0necH/qv6+gDg79t8bi1ex1FuMfsx8KEOxyKpg0xmJGlxewkweUXkEx04/znA76v2sR04vxahzPxWZu6UmY/LzN91Oh5JnWMyI0lNiojHRcSHI+LyiLgtIu6JiN9HxC8i4sKIeHtE7BsRG87w3FmrmU2reLW82hcRsTQivh4RN0TE3RFxY0SMRMTBTYZ9TPX1TuBrTXyPp9TiuGiOvhtFxNdq/c+PiPvV+2TmX4AvVw8fERFPbTJuSZLmZDIjSXOokor3AD8EXg3sBWxNKaKyPbAbsD9wInBJ9Xi+59wO+DrwGeBgYCdgY2BH4P8AX4+I9zYeASLiMZTqWQDfzMyJJk59CvDHqv20iDholr4fAw6t2iuAwzPznhn6Lau1j2wihpaLiPtFxLOqZPT7EfHHKhm9NSKuqPY/do4xrm1Uajcito+It1WJ7q3T+iyZY9w9IuK/I+LqiLizSpS/HxGvj4i+1v0UZo1hrwalhNeIPSKWz9Dv9AbjzvYz2ykiTo2IqyJiVUT8KSK+FxGvjogZCxTNNt60fvd9OMDU5H+Ab831/Orf+/OqDw1+ExETEXFXRFwfEedGxHERsTuSuoLVzCRpbq+hqkZVuQT4PuX2qY0o80EeCzwZ2KQF59sI+CLwDOAmSjLwG2BL4LDqXAD/EhE/zMzPNhjnsFp7eTMnzszbIuJdwHuqXe9gahL/fSLiFKbeJP4SOCwz72gw7LcpxQc2qGJ6TTOxtEpEbAX8mvJ7AriB8j3dAjwEeCIlSX1VRPxbZr61wVD/A2wHbMXUPCQi4vGU2+lWUb7XHwKHAA9qIrZXUOZ8/BT4ZrX7ScA+1faKiDg0M3/d7Pe7jm5mqpzwM5lKgmfyeeAymis53Ohntg/ldX0t5fveGDiQ8rt4InBIRDwnM6evHTTjeDOol8Oufz9nAtdP63tNLa5tKL/L/YCk/Fv/BnAPpbT5gdV4/xYR52XmoUjqrMx0c3Nzc5tlA66jvLH5M3DgLP02p9zWtfMMx7Larm3w3F1qfSa3jwB90/oF8P5an6tmieertX77rcX3u2nte05gaNrx19SO3QA8tIkxr6o9Z42fz1rEtqQ2zvImn3P/2nNOBTaednwz4F21Pq+bY7z67+oKSqJ5HBC1PltR3jQnsKS2/5jac79Fuf3vuTOc46WUBDAp6+k8oI2v99NrMS6ZpV/9d3H6OvzMXjCtz8bTXrMvbHK8WV8HzX4/Vd8zq35/AgZnOP5ISrLa8N9yK16zbm5uzW/eZiZJs4iI7SmfQAN8PTO/0ahvZt6Zmadn5g0tOPVXM/OVOe3WsMxMygKYk58uP2qWW172rrV/2uyJM/Mu4O21XSdHRABExPMoyRTAbcAhmfmbJob9Sa092GwsLbYiM9+YmX+u78zMVZl5HDBS7Xp79Ql9M/YALs7Md1W/m8kxV1I+4Z/NEuAtmfml6Qcy82NMrcuzM/DBJuPpBXsAX87MT9d3Vr+X+noxL25nUFHWY3pu9fDMzFwxvU9mXg08v51xSZqdyYwkza4+mb8t8xcqjW51Isu8lPob5cdN71PdWrVD9XBlZt62luf/JPDzqr0XcEREPAP4X8r/HROUKzY/a3K8esLzyLWMZb5WAf8KvGWOfl+ovm7J2i1s2WjtnuMoifB3GxxfyVTp6pm8h3J1BuB5EfHwtYip2/3HTDsz8yeUJBlgcDKJbpMBpt4X/bVRp8y8CriU2u1pkjrHZEaSZpGZN1PWswA4ICL+aXrFrgVwU2b+eI4+v6q1d5jh+INr7RtnOD6rzLwXOL62692UqmQbU97oHZmZ31mLIesxPLhhrwVQXXl5a2auMfdnmptq7b2aHP7WRr+rzFyZmb/NzLsbPPc71VWwGWXmTcDl1cMNgCOajKnb/T4zfzXL8euqr5sD27Yhnkn1Es/Pj4g1PiSYlJlPycwD2hCTpDlYAECS5nYqU7f8vB84ISLOAy6mFAL4SfXmv1WauW3r9lp7ixmOb1Vrr1qXIDLznIj4DvBU4GG1Qy/LzGUNntbInbX2lusSTytExEMohRoGmKpIN6meZG3f5JBj8wjn6ib6/Bx4QtV+4jzO1U3men3XC0lswVR1vQWVmddFxKXAvtV5fxARZ1KuUn4rZ67UJ6nDTGYkaQ6Z+f6I2IJym9KmlDe6z2fq3vnbImIZ8F+ZeWkLTtnw0/p6WLX2TFfZ63/f/zKPWD5FSWYmyM1i7AAAB71JREFUvS0zT1uHceoxLPSVrTVUZarfR6lG1cytS83G2KiCWzNWNtHnllp7zupoPeLOOY7Xk4Z230HyQuBcyq2QGwFLq21l9QHG2cA52bhyn6Q28zYzSWpCZr6TcnXidcB5rP5GdBvg74BLIuK0RmtktFn9asym6zJAte7KqdN2b7aO8dTnG831ZralIuIpwPeAgyhzUN4H7AlslpkxuVFKYa+t6aWD10YzV/PqBSA6dkWrxebzM1tQmXkNpUDBsZSqa5O2opSh/gxwQ0T8a7vWAJI0O5MZSWpSZt6Ume/LsrbEtsDjKevP/KDW7RjgpA6EN139E/3t1vbJEfFQStI2WdVrckL0P0XETusQTz2GWxr2arGI2IBym9Dm1a7jMvN1mfmT6ZXiOqCZ/4Prb5hvb9irM9o5Ob9tMvOuzPxQZu4FPBo4gdWr8W1FmU/2jYhYpw8KJLWOyYwkrYPMvDczL8/M92bmEynlkif9Q/UmupNuYOp2nR0jYsPZOtdFxP2B84HJpOWdlDVvoLy5PnEd4tm51r52HZ6/rp5IWewQyq1uH5mlb7s1c6WlXtzhtwsVyDT1K0azvW5mmqu1qGTmLzPznZm5J6UoxFm1w/sCr+hMZJImdfo/W0laLN7H1O1T2zG12nxHZOZfmSqtvCHwiGaeFxGbUxYu3LXa9fHMPIFS2njy1rW/j4hHrWVIj661r2jYq/V2qbVvnmOuQ7v/T2ymRHV9DaHvL1Qg09RvA9y8Ya/Vf7Y9LyI2jYhdGq0xlJlXZOZzKbeaTdq/PdFJasRkRpJaYwNW/0S707cwwepvfvecq3NVcvpLwD7VrmVUnzxXZYIn1wbZEPi3ZoOo1grZo3p4F6vfsrPQVquiNse6JQ9Z6GCm2S8iNml0MCIeyNQaQvcytQ7OQqtfAZrtZ/LUWY51k4YFBSJiv4g4JiL2AJ5EqU73tjnG+3yt3fQVT0kLw2RGkmYREU+LiK9FxLMiYuMGfTYC3sXUbUNXVCvAd9r5tfasbzyrN/mnA4dUu75LWUumvnjgu5kqfHB4RDRbKngPpubeXDTLuisL4QdMTTjfktk/SX/Bwoezmq2Y/TalNzE1L+XMzBydqVNEHBoRv4mI8Yhoxer09ST4KQ3OuTPwty04Vzv8vtbeatqx44HTgCW1fQfOkfTWr7q28yqjpBmYzEjS7DYADgW+AtwcEV+PiPdFxPERcVJEfAy4nlIIAMob5+MbjNVu5zN1hejAOfq+l1KCFuBK4NnTJ8hn5h+YWm8H4JQm46gvLnhOk89pieqK0qdquz4eEXvX+0TERhHxblaPsx1uAE6NiOHpByLiZZSKWlAWczx2ep+aj1KuoOxA+f7WteLcpG8Dk4nT4RHxpGmxbQ+cCXxznudpl3pyNnnVkYjYAdivelgv4vFY4P0zfXgREZMFAaAk9t00B0taL3VD+VBJ6mb1W1S2Bg6utpncBrwyM7+24FE1ITPviIgRSpKyW0Q8OjOvmt4vIt4MvLZ6eANwSGY2WqjwfcBrKPOClkTEoZl57hyhHF59vYfVb9Fpl1dT1mg5AHgo8P2I+DbwS8p6MgdUx88GnlM9Z++I+Peq/ZHMvCYiXkkpJlD/dP/htX5k5uuZJiK2paxRBKvPgfkY5VP+syLih8Bl1f59KW+oAa4BDs3M2SrAxbT2vEofZ+a9EfFiynormwEXV2usjFbxHkq5HfEzwGHV0+o/rzMy8zKAJn5mkz/bvYGjJo/X+h4fESuBFZn5+Yg4nvLaazTe+ZlZvyIJ8DXK/LHdgTdFxK6UhTgPpcwJ+npmfi8idgduAnakJI9HR8S3gBspV/UeQUl+oup3RGa2qyiDpEYy083Nzc1tlo3yqffLKSV+Lwf+QHljfhflzf8FlPVntp9ljKy2axsc36XWZ3kTMR1T63/iLP2eVut38hzj3Ao8polzv7H2nB8DG8zS96GU+R4JfK4Fv4sla/Nzqj1vA8ptZOcBN1e/v5XAT4EPA38zbez6tqQaY3mD4/dtTfxu69uJ1fGDgDOA31CupP2JcqXgDUBfE9/bsyhXB28G/q6Fr/vdqtf8dcDd1fjnA4fP8Luob8fUxpjrZzb5sz1mjn6nV/2unaPfjP8WKEnYhynJ4d2Uf7u/oJRR76v12wh4JvAB4JLqe7672m6svv9jgS0X+jXr5ubW3BaZXbt2lSSpBSJiBbA35Xalh2bmX9p47ncAb60eDmb1if08xlsCfKt6eFFmLpnPeNJC8zUrLSznzEjS4ndy9XUn4Mh2nbRaIX1ygvu5801kJEmazjkzkrTIZeayiLiUMhfjTRHx2WzPZfmXUm7vuZepOSOttNp8FZh5zorUThExfV7dgzsVi7Q+8DYzSVoPRMQTKPMwNgBekJmfmeMp8z3fFsCvgX7gfzKzJSulT7tlZw2ZOVtJXWnBRcSJwNsbHPY2M6nFTGYkaT0RES8CHgZcl5mfWOBz7cFUFbMPZSnrLElSS5nMSJIkSepJFgCQJEmS1JNMZiRJkiT1JJMZSZIkST3JZEaSJElSTzKZkSRJktSTTGYkSZIk9SSTGUmSJEk9yWRGkiRJUk8ymZEkSZLUk0xmJEmSJPUkkxlJkiRJPclkRpIkSVJPMpmRJEmS1JNMZiRJkiT1pP8PwaVnUrcbpIMAAAAASUVORK5CYII=" }, "execution_count": 85, "metadata": { "image/png": { "height": 294, "width": 409 } }, "output_type": "execute_result" } ], "source": [ "import matplotlib as mpl\n", "mpl.rc(\"font\", family=\"serif\", size=16)\n", "\n", "plt.plot(x, y, \"k.\")\n", "plt.xlabel(r\"$\\sin({x)}$ [arb. units]\")\n", "plt.ylabel(r\"$\\zeta(y)$ [arb. units]\")\n", "plt.title(\"Some XY data\")" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "### Using NumPy and Matplotlib Together\n", "\n", "Here we create some fake data with NumPy and plot it, including a legend." ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 86, "metadata": { }, "output_type": "execute_result" }, { "data": { "image/png": "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" }, "execution_count": 86, "metadata": { "image/png": { "height": 277, "width": 418 } }, "output_type": "execute_result" } ], "source": [ "x = x=np.linspace(-np.pi, np.pi, 1000,endpoint=True)\n", "c = np.cos(x)\n", "s = np.sin(x)\n", "\n", "plt.plot(x,c,label=\"Cosine\",color=\"r\",linestyle=\"--\",linewidth=2)\n", "plt.plot(x,s,label=\"Sine\",color=\"b\",linestyle=\"-.\",linewidth=2)\n", "plt.xlabel(\"$x$\",fontsize=14)\n", "plt.xlim(-np.pi,np.pi)\n", "\n", "# Override default ticks and labels\n", "xticks = [-np.pi, -0.5*np.pi, 0, 0.5*np.pi, np.pi]\n", "labels = [\"$-\\pi$\", \"$-\\pi/2$\", \"$0$\", \"$\\pi/2$\", \"$\\pi$\"]\n", "plt.xticks(xticks, labels)\n", "\n", "plt.ylabel(\"$y$\",fontsize=14)\n", "plt.ylim(-1,1)\n", "plt.legend(fontsize=14, loc=\"best\", numpoints=1)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "## Help Manual and Inspection\n", "\n", "When running interactive sessions, you can use the built-in help function to view module and function documentation.\n", "\n", "For example, here is how to view the internal documentation for the built-in function that calculates the greatest common divisor of two numbers:" ] }, { "cell_type": "code", "execution_count": 87, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function gcd in module fractions:\n", "\n", "gcd(a, b)\n", " Calculate the Greatest Common Divisor of a and b.\n", " \n", " Unless b==0, the result will have the same sign as b (so that when\n", " b is divided by it, the result comes out positive).\n", "\n" ] } ], "source": [ "from fractions import gcd\n", "\n", "help(gcd)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "The `inspect` module is nice if you actually want to look at the **source code** of a function. Just import inspect and call the `getsource` function for the code you want to see:" ] }, { "cell_type": "code", "execution_count": 88, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "def gcd(a, b):\n", " \"\"\"Calculate the Greatest Common Divisor of a and b.\n", "\n", " Unless b==0, the result will have the same sign as b (so that when\n", " b is divided by it, the result comes out positive).\n", " \"\"\"\n", " while b:\n", " a, b = b, a%b\n", " return a\n", "\n" ] } ], "source": [ "from inspect import getsource\n", "\n", "print(getsource(gcd))" ] }, { "cell_type": "code", "execution_count": 0, "metadata": { "collapsed": false }, "outputs": [ ], "source": [ ] } ], "metadata": { "kernelspec": { "display_name": "Python 2 (SageMath)", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.15" } }, "nbformat": 4, "nbformat_minor": 0 }