{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"# Python\n",
"*Notes by Mary Richardson (2021) with modifications by Jakob Heinz (2024) and Boyan Li (2026)*\n",
"\n",
"If you're new to Python or coding as a whole, have no fear! Soon you'll be a pro. If you can get comfortable with everything in this notebook, you'll have all the tools you need to tackle the first pset. Let's start with the essentials. "
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "skip"
}
},
"source": [
"* [Variables and Output](#Variables-and-Output)\n",
" * [Comments](#Comments)\n",
" * [Typecasting](#Typecasting)\n",
"* [Types](#Data-Types)\n",
" * [Numbers](#Numbers)\n",
" * [Strings](#Strings)\n",
" * [Booleans](#Booleans)\n",
" * [Lists](#Lists)\n",
" * [Dictionaries](#Dictionaries)\n",
"* [Control Flow](#Control-Flow)\n",
" * [Conditional Statements](#Conditional-Statements)\n",
" * [While Loops](#While-Loops)\n",
" * [For Loops](#For-Loops)\n",
"* [File Handling](#File-Handling)\n",
" * [Writing](#Writing)\n",
" * [Reading](#Reading)\n",
"* [Functions](#Functions)\n",
"* [Numpy](#Numpy)\n",
"* [Matplotlib](#Matplotlib)\n",
"* [Troubleshooting](#Troubleshooting)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {
"id": "HRg7iytjI4l2",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Variables and Output\n",
"\n",
"We can easily store a value as a variable in Python. To do this we use a single `=`, with the variable name always to the left, and the assigned variable always to the right. \n",
"\n",
"There are several important **data types and structures** for storing values in Python you should be familiar with:\n",
"- **int**: integer number\n",
"- **float**: decimal number\n",
"- **str**: string/text\n",
"- **bool**: boolean (true or false)\n",
"- **list**: list of values\n",
"- **dict**: dictionary of keys and associated variables"
]
},
{
"cell_type": "code",
"execution_count": 136,
"metadata": {
"id": "BPf-8FGGI4l3",
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"# Define an integer\n",
"num_human_genes = 20000 # -ish\n",
"answer_to_life = 42\n",
"\n",
"# Define a float\n",
"e = 2.71828182845904523536028747135 # And so on ...\n",
"my_shoe_size = 13\n",
"\n",
"# Define a string\n",
"python_greeting = 'hello world'\n",
"shine_dalgarno_consensus = \"AGGAGG\"\n",
"multiline_text = \"\"\"\n",
"This is line one.\n",
"This is line two.\n",
" This line is indented.\n",
"\"\"\"\n",
"\n",
"# Define a boolean\n",
"likes_dogs = True\n",
"is_last_example = False\n",
"\n",
"# Define a list\n",
"prime_nums = [19, 31, 7, 97, 11] # A random selection\n",
"greek_alphabet = ['alpha', 'beta', 'gamma', 'delta'] # ...\n",
"\n",
"# Define a dictionary\n",
"olympic_sports = {'swimming':True, 'fencing':True, 'hiking':False}\n",
"sport_types = {'swimming': ['breast stroke', 'butterfly', 'freestyle'], \n",
" 'fencing': ['foil', 'epee', 'sabre'],\n",
" 'hiking': ['mountaineering', 'backpacking']}\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "T7yJj6BTI4l3",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Comments\n",
"\n",
"It's good practice to write comments to explain your code and make it more readable. Even if something seems incredibly obvious to you, comments will help make it clear to anyone else who tries to run your code... and to your future self!\n",
"\n",
"Everything to the right of a `#` symbol is ignored by the Python interpreter\n",
"\n",
"Triple-quoted string can be used to comment multiple lines."
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"id": "K86kxVDEI4l4"
},
"outputs": [],
"source": [
"# You can use comments to write high-level descriptions of blocks of code\n",
"\n",
"x = 1 # And you can add comments to individual lines of code\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zb23kVGpI4l5",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Typecasting\n",
"\n",
"Python uses domething called *soft typing*, which means it infers the type of each variable. We don't explicitly set the type of variables. But sometimes it infers incorrectly or we need to switch between types. \n",
"\n",
"We can check the type of a variable with the `type()` function. We can change the type by using the name of the new type as a function (e.g. `int()`, `float()`, `str()`)."
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"id": "1Gf0fAw4DqbT"
},
"outputs": [
{
"data": {
"text/plain": [
"(str, float)"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = '3.9'\n",
"y = 3.9\n",
"type(x), type(y) # type() checks the data type"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"id": "ZVug3emkDrVs",
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Other data types can also be converted, but be careful when you cast numbers!\n",
"x = 3.8\n",
"x = int(x) \n",
"x"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "LcrVg1rTI4l6",
"outputId": "aa3ee9fa-4bc4-42cb-ad9b-f75dd4bf8785"
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# When casting to a boolean, any nonzero value will be True\n",
"x = bool(4)\n",
"x"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"id": "ft0ZcOsBDrS6",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"text/plain": [
"6.0"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# A str value can't be used to do any math until it is converted into a number\n",
"x = '3'\n",
"float(x) + 3\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "I4jgiS2NI4l9",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Types\n",
"\n",
"Now let's get into some more details about the data types we'll be using and how to manipulate them."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "cKXiCpm4I4l9"
},
"source": [
"### Numbers\n",
"\n",
"Throughout your journey with Python, you'll make use of at least two types of numbers: floating points and integers. At this point, all you need to know is that a floating point number (or `float`) is a number with a decimal point (e.g. 12.34546789) and an integer (or `int`) is a number without a decimal point (i.e. 0, negative and non-negative whole numbers). \n",
"\n",
"Python supports standard arithmetic operations, follows the usual order of operations, and supports parentheses.\n",
"\n",
"Operator | Operation\n",
"--- | ---\n",
"`+` |\tadd\n",
"`-` |\tsubtract\n",
"`*` | multiply\n",
"`/` | divide\n",
"`%` | modulus\n",
"`**` | exponentiate\n",
"`//` | Floor divide"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"id": "7vQaLrSbCWoC",
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(float, float)"
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = 10 # int\n",
"y = 1.23456789 # float\n",
"\n",
"# Try addition and multiplication, what is the type of the output?\n",
"type(x+y), type(x*y)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"id": "KWo1A8ivCQCK"
},
"outputs": [
{
"data": {
"text/plain": [
"(112.3456789, 101.23456789)"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Specify order of operations with parentheses\n",
"x * (x + y), x * x + y"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"id": "RXsRiOuUCRwh"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n"
]
},
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Modulus (%) calculates the remainder\n",
"x = 7\n",
"y = 2 \n",
"print(x % y)\n",
"\n",
"# Floor divide (//) returns the integer portion of the quotient\n",
"x // y"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"id": "g2qDKQ1HCdh7"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7\n",
"8\n"
]
}
],
"source": [
"# To increment an int, you can use this shorthand\n",
"print(x)\n",
"x += 1 # Equivalent to x = x + 1\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "rOxLxeDMI4l-",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Strings\n",
"\n",
"A string (or `str`) is the name for a variable that holds text, not numbers. In Python, strings are created by surrounding text with double or single quotes. Importantly, if you see a number in a string, that number cannot be used as a number until it is **typecast** (or converted) into a number."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "rOxLxeDMI4l-",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Basic string operations\n",
"\n",
"Python has many useful string operations.\n",
"\n",
"Operation | Result\n",
"--- | :---: \n",
"`+` | concatenate strings\n",
"`*` | repeat the same string\n",
"`x in s`| True if substring x is in s, else False\n",
"`x not in s` | False substring x is in s, else True\n",
"`s[i:j:k]`| slice of s from i to j with step k\n",
"`len(s)`| length of s"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"id": "Ex3IVf4HCjUe",
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [],
"source": [
"x = 'this'\n",
"y = '9.2'\n",
"z = \" is a string\""
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"id": "QCmk87bpCqr2"
},
"outputs": [
{
"data": {
"text/plain": [
"'this is a string'"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Append two strings\n",
"x + z"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"id": "ORBlF87GCqvF"
},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Count the number of characters in a string\n",
"len(x)"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"id": "x4V0E2kgCqyi"
},
"outputs": [
{
"data": {
"text/plain": [
"'h'"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# To access an individual character, use its position in the string (starting from 0)\n",
"x[1]"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"id": "8pzk535PCq0l"
},
"outputs": [
{
"data": {
"text/plain": [
"'is'"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# To access a range of characters, specify a slice range (starting from 0)\n",
"z[1:3] # This range always includes the start index but excludes end index, i.e. [0,3)"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"id": "ezg2AmAwCijp"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['is', 'a', 'string']\n"
]
},
{
"data": {
"text/plain": [
"['9', '2']"
]
},
"execution_count": 62,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# To separate a string into a list of strings, use split\n",
"# and specify the delimiter (separator)\n",
"print(z.split()) # Default is to split on whitespace\n",
"y.split('.') # We can specify alternate delimiters"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"id": "9lk94yRwI4l_",
"outputId": "3a6de604-9f5d-403c-8ceb-d456dca20cfe"
},
"outputs": [
{
"data": {
"text/plain": [
"'is a string'"
]
},
"execution_count": 63,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# To merge a list of strings into one string, use join\n",
"\" \".join([\"is\", \"a\", \"string\"])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "XkSGijNlI4l7",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Formatting strings for output\n",
"\n",
"Sometimes we need to put variables into a string for output. In Python, there are several ways to include variables inside a string."
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {
"id": "aVWT4gusI4l7",
"outputId": "aaf8649a-96c3-4ec8-804e-f8d4a930f7f8"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"hello world\n",
"hello world\n",
"hello world\n",
"hello world\n",
"hello world\n"
]
}
],
"source": [
"# To format strings, we have several equivalent options (pick your favorite!)\n",
"x = \"hello\"\n",
"y = \"world\"\n",
"\n",
"print(x + \" \" + y)\n",
"print(' '.join([x,y]))\n",
"\n",
"print(\"%s %s\" % (x, y)) # Specify %s as a placeholder for a string value\n",
"\n",
"print(\"{} {}\".format(x, y)) # Alternatively use {} as a placeholder for a value\n",
"\n",
"print(f\"{x} {y}\")"
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {
"id": "snxNo-qII4l8",
"outputId": "90795379-f867-4458-f2a3-9784ee2fd16d",
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"I'm taking MCB112!\n",
"I'm taking MCB112!\n",
"I'm taking MCB112!\n",
"I'm taking MCB112!\n"
]
}
],
"source": [
"# To print numbers, we first have to convert them to strings or use one of the other print methods\n",
"x = 'MCB'\n",
"y = 112\n",
"\n",
"# Use different ways to generate \"I'm taking MCB112!\"\n",
"print(\"I'm taking \" + x + str(y) + \"!\")\n",
"print(\"I'm taking %s%i!\" % (x, y))\n",
"print(\"I'm taking {}{}!\".format(x, y))\n",
"print(f\"I'm taking {x}{y}!\")"
]
},
{
"cell_type": "code",
"execution_count": 141,
"metadata": {
"id": "u-tA694aI4l8",
"outputId": "08cf388e-dbd3-4368-f6c6-5b6e4a37c76a"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"I'm taking \n",
"MCB112\t!\n"
]
}
],
"source": [
"# new lines and tabs\n",
"# \\n or \\t\n",
"print(f\"I'm taking \\n{x}{str(y)}\\t!\")"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.141592653589793\n",
"3.142\n",
"3.142\n"
]
}
],
"source": [
"# Round floats through format \n",
"import math\n",
"pi = math.pi\n",
"print(pi)\n",
"print(\"{:.3f}\".format(pi))\n",
"print(f\"{pi:.3f}\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ubENffm4I4l_",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Booleans\n",
"\n",
"A boolean (or `bool`), named after [George Boole](https://en.wikipedia.org/wiki/George_Boole), is data type that can be either **True** or **False**. Booleans will become important for making comparisons and controlling the flow of your code."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ubENffm4I4l_",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Logic comparison\n",
"\n",
"Python allows basic logic comparisons through a set of relational operators.\n",
"\n",
"Operator | Operation\n",
"--- | ---\n",
"`==` | equal\n",
"`!=` | not equal\n",
"`<` | less than\n",
"`<=` | less than or equal to\n",
"`>` | greater than\n",
"`>=` | greater than or equal to\n",
"\n",
"**Note that `=` is used for assignment, while `==` is used to test for equality.**"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"id": "H-i1p7pXDaUu",
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"(True, False)"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Compare numbers\n",
"3 > 2, 3 < 2"
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {
"id": "umHzzCVdDaiZ"
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 82,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = 5\n",
"y = 2+3\n",
"x == y"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"id": "qt3NRNn9Dak3"
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Compare strings\n",
"a = 'apple'\n",
"b = 'banana'\n",
"a == b"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"id": "qt3NRNn9Dak3"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"True\n"
]
},
{
"ename": "TypeError",
"evalue": "'<' not supported between instances of 'str' and 'int'",
"output_type": "error",
"traceback": [
"\u001b[31m---------------------------------------------------------------------------\u001b[39m",
"\u001b[31mTypeError\u001b[39m Traceback (most recent call last)",
"\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[16]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m 5\u001b[39m \u001b[38;5;28mprint\u001b[39m(a == b)\n\u001b[32m 6\u001b[39m \u001b[38;5;28mprint\u001b[39m(a != b)\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[43m<\u001b[49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m)\n",
"\u001b[31mTypeError\u001b[39m: '<' not supported between instances of 'str' and 'int'"
]
}
],
"source": [
"# What happens if data types are different?\n",
"a = \"3\"\n",
"b = 3\n",
"\n",
"print(a == b)\n",
"print(a != b)\n",
"print(a < b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Bitwise operators\n",
"\n",
"Operator | Operation\n",
"--- | ---\n",
"`&` | AND \n",
"`\\|` | OR\n",
"\n",
"These operate on the binary bits (0s and 1s) of integers. They compare each bit of the numbers and return a new number based on that comparison."
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"False\n",
"True\n",
"7 1\n"
]
}
],
"source": [
"# True AND/OR False\n",
"print(True | False)\n",
"print(True & False)\n",
"\n",
"# If x is in a certain range\n",
"x = 3\n",
"print((x > 1) & (x < 4))\n",
"\n",
"\n",
"print(5 | 3, 5 & 3)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "9qV_wA4II4mA",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Lists\n",
"\n",
"A `list` is a convenient data structure for organizing variables. Lists group data of any type into a structure that can be sampled via **indexing**, where an item or items in a list are referred to by their position in the list.\n",
"\n",
"\n",
"Python has a ton of useful built in functions for operating on lists.\n",
"\n",
"Operation | Result\n",
"--- | :---: \n",
"`x in s` | True if an item of s is equal to x, else False\n",
"`x not in s` | False if an item of s is equal to x, else True\n",
"`s[i:j:k]`| slice of s from i to j with step k\n",
"`len(s)`| length of s\n",
"`min(s)`| smallest item of s\n",
"`max(s)`| largest item of s\n",
"`sum(s)`| sum of the items in s\n",
"`s.index(x)`| index of the first occurrence of x in s\n",
"`s.count(x)`| total number of occurrences of x in s\n",
"`sorted(s)`| for a list of numbers, returns a sorted list in ascending order\n",
"`s.append(x)` | adds item x to list s\n",
"\n",
"Note that Python uses a 0-based counting system. This means that in a list, the initial index is set to 0, not 1. For exmample, let's say I have this list \\[5, 3, 2, 8, 10\\]. You might say that the first item in the list is five – the value at index 1 is five. In Python though, you would say that the value at index 0 is five and the value at index 1 is three.\n"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {
"id": "meoVH0qTHQfF"
},
"outputs": [
{
"data": {
"text/plain": [
"(0, [2])"
]
},
"execution_count": 78,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = [0, 2, 1]\n",
"b = ['apple','banana','orange']\n",
"\n",
"# Slice the list\n",
"a[0], a[1:-1]"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(3, 0, 2)"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Stats of a list\n",
"sum(a), min(a), max(a)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"id": "meoVH0qTHQfF"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n"
]
},
{
"data": {
"text/plain": [
"'banana'"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# index\n",
"# Element in b where the corresponding position in a is 2?\n",
"print(a.index(2))\n",
"b[a.index(2)]"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[0, 2, 1, 'apple', 'banana', 'orange']"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Merge two lists\n",
"c = a + b\n",
"c\n",
"\n",
"a += b\n",
"a"
]
},
{
"cell_type": "code",
"execution_count": 92,
"metadata": {
"id": "VlmPs9I4HVPW"
},
"outputs": [],
"source": [
"# We can mix data types in lists, and even have lists within lists!\n",
"a = [['apple',5], ['banana',3],['orange',7]]"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WZ7ImawlI4mB",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Dictionaries\n",
"\n",
"A dictionary (or `dict`) is a special data structure that allows you to associate **values** with a specific **keys**. The data structure takes its name from a dictionary, because a word dictionary is organized similarly: take a word, look it up in the dictionary, see some associated description. In a Python dict, you take a word (the key), look it up in the dict, and see some list of numbers or strings associated with that word (the values).\n",
"\n",
"\n",
"Python has several additional useful functions for dicts.\n",
"\n",
"Operation | Result\n",
"--- | :---:\n",
"`s.clear()` | erases the dict\n",
"`s.values()` | returns a list with all the assigned values in the dictionary\n",
"`s.keys()` | returns a list with all the keys in the dictionary\n",
"`s.items()` | returns a list containing of (key, value) for each key in the dictionary"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {
"id": "TlRWnohtHelF",
"slideshow": {
"slide_type": "-"
}
},
"outputs": [],
"source": [
"a = {'apple': 'red', 'banana': 'yellow', 'orange': 'orange'}"
]
},
{
"cell_type": "code",
"execution_count": 81,
"metadata": {
"id": "d1TdJU-EHfTL",
"slideshow": {
"slide_type": "slide"
}
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 81,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Filling an empty dictionary\n",
"\n",
"b = {}\n",
"\n",
"#Values can be added to the dictionary in the form a[Key] = Value\n",
"b[\"apple\"] = \"red\"\n",
"b[\"banana\"] = \"yellow\"\n",
"b[\"orange\"] = \"orange\"\n",
"b == a"
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {
"id": "1jrgwa_XHjZb"
},
"outputs": [
{
"data": {
"text/plain": [
"dict_keys(['apple', 'banana', 'orange'])"
]
},
"execution_count": 82,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get just the keys of the dict\n",
"b.keys()"
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {
"id": "jPU6PFXAHjii"
},
"outputs": [
{
"data": {
"text/plain": [
"dict_values(['red', 'yellow', 'orange'])"
]
},
"execution_count": 83,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get just the values of the dict\n",
"b.values()"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {
"id": "QJWVgW_fHmSA"
},
"outputs": [
{
"data": {
"text/plain": [
"dict_items([('apple', 'red'), ('banana', 'yellow'), ('orange', 'orange')])"
]
},
"execution_count": 84,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Get the key, value pairs of the dict\n",
"b.items()"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'avocado': 'green', 'blueberry': 'blue', 'apple': 'red', 'banana': 'yellow', 'orange': 'orange'}\n",
"{'apple': 'red', 'banana': 'yellow', 'orange': 'orange', 'avocado': 'green', 'blueberry': 'blue'}\n"
]
}
],
"source": [
"# Merge two dictionaries\n",
"c = {\"avocado\": \"green\", \"blueberry\": \"blue\"}\n",
"\n",
"c.update(b)\n",
"print(c)\n",
"\n",
"print(b | c)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "J2QDR7224-y1",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Control Flow\n",
"Now that you've got a handle on variables, we're ready to learn how to connect individual lines of code. So far we've just run Python commands sequentially – every line runs, one after another, from top to bottom. But sometimes we need to skip chunks of code under certain conditions, or run different chunks of code depending on some condition. And sometimes we want to run the same chunk of code multiple times. There are several important ways to accomplish this."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zjT_z5q-5jil"
},
"source": [
"### Conditional Statements\n",
"\n",
"Conditional statements allow you to write code that only runs when certain conditions are met. The most common conditional structures are `if`, `elif` (else if), and `else` statements. \n",
"\n",
"An `if` statement can have as many `elif` statements as you want. Each `if`/`elif` statement is evaluated in sequence, and only the code for the first condition that evaluates to True is run. Then Python jumps to the end of the conditional statement, and continues through your script line by line as usual.\n",
"\n",
"We can use `else` to specify what to do if *none* of the `if` or `elif` statements evaluate to True. An `if` statement can only have one `else` statement, and it must come last."
]
},
{
"cell_type": "code",
"execution_count": 102,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"y is greater than x\n"
]
}
],
"source": [
"# Compare x and y\n",
"x = 4\n",
"y = 5\n",
"\n",
"if x > y:\n",
" print('x is greater than y')\n",
"elif x < y:\n",
" print('y is greater than x')\n",
"else:\n",
" print('x and y are equal')"
]
},
{
"cell_type": "code",
"execution_count": 103,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "4BSj_kxr5t1j",
"outputId": "a735b86f-575b-4329-c25e-a9e1554eb118"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"there aren't any carrots\n"
]
}
],
"source": [
"# Print the color of banana if banana is in a dictionary\n",
"fruit_dict = {'apple': 5,'banana': 3,'orange': 7}\n",
"fruit = 'carrot'\n",
"\n",
"if fruit in fruit_dict.keys():\n",
" print('there are {} {}s'.format(fruit_dict[fruit], fruit))\n",
"else:\n",
" print('there aren\\'t any {}s'.format(fruit))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "EmOH2m4s5xZr",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Moving forward, note that Python is sensitive to indentation. The indentation level of your code tells python something about how to run it. I find the easiest way to ensure correct indentation is to use tab (rather than spaces) to indent your code at each level or shift + tab to unindent your code so that the indentation levels stay consistent.\n",
"\n",
"Other formatting conventions, such as adding ':' at the end of a conditional statement, are also necessary."
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {
"id": "OA-Ghwba5yFg"
},
"outputs": [
{
"ename": "IndentationError",
"evalue": "unindent does not match any outer indentation level (, line 3)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m print('incorrect')\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unindent does not match any outer indentation level\n"
]
}
],
"source": [
"if True:\n",
" print('correct')\n",
" print('incorrect')"
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {
"id": "ZQs-A6065vdQ"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2.0\n"
]
}
],
"source": [
"#Calculate x/y below. If y is zero, print an error message: \n",
"# Define x and y\n",
"x = 4\n",
"y = 2 # Try changing the value of y to test your method\n",
"\n",
"# FIXME!\n",
"\n",
"if y == 0: \n",
" print('silly')\n",
"else: \n",
" print(x/y)\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "o82qkVtE596B",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### While Loops\n",
"\n",
"Often in this course you will want to run code over and over until some condition is met. Loops allow you to perform a task repeatedly with **iteration**, meaning after each task repetition, something changes. In a `while` loop, the loop runs until the specified condition is true."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"id": "yVS_ZTGh5-rU"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n",
"4\n"
]
}
],
"source": [
"# Print integers from 1 to 4\n",
"\n",
"i = 1 # Remember to initialize i\n",
"while i < 5: # Continue as long as i < 5\n",
" print(i)\n",
" i += 1 # This is a shortcut way to say i = i + 1"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "hfnfOw6a_0W2"
},
"source": [
"It's easy to make while loops that run forever (an infinite loop). For example if we forgot to increment our variable i above, the loop would never stop. This is something to watch out for.\n",
"\n",
"We can also use `break` statements to end while loops when a condition is met."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "aMDhQXBK_095",
"outputId": "94799cef-b3ff-4ddd-c41e-b81e75396ade"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n"
]
}
],
"source": [
"a = [10, 2, 3, 7, 8, 199, 3, 4]\n",
"# Find the first element that is equal to 7\n",
"\n",
"i = 0\n",
"while True:\n",
" if a[i] == 7:\n",
" print(i)\n",
" break\n",
" i += 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can also use `continue` statements to skip to the next iteration when a condition is met."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"4\n",
"5\n"
]
}
],
"source": [
"# Print integers from 1 to 5 but skip 3\n",
"i = 1\n",
"while i <= 5: \n",
" if i == 3: \n",
" i+=1\n",
" continue \n",
" print(i) \n",
" i+=1"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AVZby0aS_3Pm",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### For Loops\n",
"\n",
"Instead of iterating until a condition is met, you might want to iterate through a set list of values. In a `for` loop, the loop addresses each item in a group, in sequence, until the last item in the group. We can iterate through an existing list or we can use the `range` function to specify numeric values."
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"id": "z_l6bDqc_-_U"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"apple\n",
"banana\n",
"orange\n",
"plum\n"
]
}
],
"source": [
"fruit_list = ['apple', 'banana', 'orange', 'plum']\n",
"\n",
"# Print each fruit\n",
"for fruit in fruit_list: # For each item in the list\n",
" print(fruit)"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 apple\n",
"2 orange\n"
]
}
],
"source": [
"#iterate through a list with index calls\n",
"# Print first three\n",
"# for i in range(3):\n",
"# print(i, fruit_list[i])\n",
"\n",
"# Print every other\n",
"# for i in [0, 2]:\n",
"for i in range(0, len(fruit_list), 2):\n",
" print(i, fruit_list[i])\n",
"\n",
"# Use enumerate\n",
"# for i, fruit in enumerate(fruit_list):\n",
"# print(i, fruit)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "SxhfFmBNXpL1",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## File Handling\n",
"\n",
"Frequently, we will need to read in data from a file or write results to a file. To access a file, we first need to open it. It's good practice when you open a file to specify what type of access you will need: read (`r`), write (`w`), or append (`a`) are common modes. Use read if you only need to read from the file and don't want to edit it, write if you want to write (or overwrite) to the file, or append if you want to add to an existing file."
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bbtpX5U-XvKe"
},
"source": [
"### Writing"
]
},
{
"cell_type": "code",
"execution_count": 113,
"metadata": {},
"outputs": [],
"source": [
"# Write to a file\n",
"data = ['header',\n",
" 'line 1',\n",
" 'line 2',\n",
" 'line 3']\n",
"\n",
"with open('test.txt', 'w') as outfile: # Open a file named 'test.txt' for writing ('w')\n",
" for line in data: # For each item in the list data\n",
" outfile.write(line + '\\n') # Write the item to the file with a newline character in between (\\n)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "9PDeBdwTXu_u",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"### Reading"
]
},
{
"cell_type": "code",
"execution_count": 114,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"line 1\n",
"line 2\n",
"line 3\n"
]
}
],
"source": [
"# Read from a file\n",
"with open('test.txt', 'r') as infile: # Open a file named 'test.txt' for reading ('r')\n",
" next(infile) # Skip the first line (header line, for example)\n",
" for line in infile: # Iterate through each remaining line in the file\n",
" print(line.strip()) # Print the line stripped of the trailing newline character (.strip())"
]
},
{
"cell_type": "code",
"execution_count": 115,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['header\\n', 'line 1\\n', 'line 2\\n', 'line 3\\n']"
]
},
"execution_count": 115,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#or use readlines()\n",
"lines = open('test.txt', 'r').readlines()\n",
"lines"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-Mydjf1shf4c",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Functions\n",
"\n",
"Functions allow us to define routines that we will need to run repeatedly. Functions take some inputs (**arguments**) and **return** some outputs. In programming lingo, functions are **called** when you use them, and functions are **passed** arguments:\n",
"\n",
"`return1, return2 = function(argument1, argument2)`\n"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {
"id": "c9DM-_V8hk-B"
},
"outputs": [],
"source": [
"# Define the function\n",
"def my_function(fruit, fruit_counts):\n",
" '''\n",
" Given: a str (fruit) and a dict of fruit counts (fruit_counts)\n",
" Return: the count for the given fruit\n",
" '''\n",
" count = 0 # Initialize the fruit count to zero\n",
" if fruit in fruit_counts.keys(): # If this fruit is in the dictionary of fruits\n",
" count = fruit_counts[fruit] # Get its count\n",
" \n",
" return count # Return the count of this fruit"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "u8-gBKMMhmFa",
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"Note that in the example below where we call the function, our variables (`fruit` and `fruit_counts`) that we're going to input into the function and the function arguments have the same names. This does not have to be the case! \n",
"\n",
"If we say `my_function(any_variable_name, any_variable_name_2)`, the function will still interpret these inputs as `fruit` and `fruit_counts`, based on the order they're inputted. This is what allows functions to be generalizable to any inputs. \n",
"\n",
"Similarly, we can name our output anything when we call the function (not just `counts`), and python will assign it the same value as the count output generated by the function."
]
},
{
"cell_type": "code",
"execution_count": 117,
"metadata": {
"id": "Tsv0223lhtKd"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"there are 5 apples\n"
]
}
],
"source": [
"# Call the function\n",
"fruit_counts = {'apple': 5,'banana': 3,'orange': 7}\n",
"fruit = 'apple'\n",
"\n",
"count = my_function(fruit, fruit_counts) # Run the function on these arguments and save the returned count\n",
"print('there are {} {}s'.format(count, fruit)) # Print the results"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### Exercise\n",
"\n",
"Write a function to calculate the quadratic formula given a, b, and c. (Hint: Use math.sqrt() for the square root function.)"
]
},
{
"cell_type": "code",
"execution_count": 118,
"metadata": {},
"outputs": [],
"source": [
"import math # Import the math package to calculate the square root\n",
"def quadratic_formula(a, b, c):\n",
" '''\n",
" Given: a (int), b (int), c(int)\n",
" Return: x as calculated by the quadratic formula\n",
" '''\n",
" #FIXME!\n",
" return x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## NumPy \n",
"**NumPy** (Numerical Python) is an incredibly powerful package for computation. It's the standard for working with numerical data in Python, and makes mathematical operations on arrays and matrices much more efficient.\n",
"### Import Statements\n",
"These packages contain specific functions that are useful to us. The `import` command allows you to access installed Python packages. `import` only needs to be used once per package, at the beginning of a Python session or Jupyter notebook. There are a few ways to use import:"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {},
"outputs": [],
"source": [
"# Import the entire package\n",
"import numpy\n",
"\n",
"# Import the entire packagae but give it a shorter, easy-to-type name (alias)\n",
"import numpy as np\n",
"\n",
"# Import only a specific part of the package\n",
"from numpy import random\n",
"\n",
"# Import only a specific part of the package and give it a shorter, easy-to-type name (alias)\n",
"from numpy import random as rd"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Arrays\n",
"\n",
"Numpy comes with an important central data type called an **array**. It's easy to get confused between Python lists and NumPy arrays, but they are distinct data types. You can convert a list of a single data type (a list of floats or a list of ints) to an array, and you can convert an array to a list. But functions and methods that work on arrays won't work on lists and vice versa. So it's important to keep track of what type you are using (remember the `type()` method!)\n",
"\n",
"There are several ways to create an array, all of which can be useful in different contexts:\n",
"- `np.array()`: create an array from a list of values\n",
"- `np.zeros()`: create an array of zeros with the given dimensions\n",
"- `np.ones()`: create an array of ones with the given dimensions\n",
"- `np.arange()`: create an array with a range of evenly spaced values (provide the first number, last number, step size)\n",
"- `np.linspace()`: create an array with a range of linearly spaced values (provide the first number, last number, number of values) "
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1 2 3 4 5 6]\n"
]
}
],
"source": [
"# Create a 1D numpy array\n",
"a = np.array([1, 2, 3, 4, 5, 6])\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 90,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 1 2 3 4]\n",
" [ 5 6 7 8]\n",
" [ 9 10 11 12]]\n"
]
}
],
"source": [
"# Create a 2D numpy array\n",
"a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 91,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0. 0. 0.]\n",
" [0. 0. 0.]]\n"
]
}
],
"source": [
"#create and array of all zeros\n",
"a = np.zeros([2,3])\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 92,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1. 1. 1.]\n",
" [1. 1. 1.]]\n"
]
}
],
"source": [
"#create and array of all ones\n",
"a = np.ones([2,3])\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 93,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0 1 2 3]\n"
]
}
],
"source": [
"a = np.arange(4) # number of elements\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 94,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 1. 3.25 5.5 7.75 10. ]\n"
]
}
],
"source": [
"a = np.linspace(1, 10, num=5) # first number, last number, number of elements\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Axis\n",
"\n",
"Since NumPy arrays can be 2D (or 3D or even higher dimensional), they have multiple **axes**. I *still* have to look up which axis is which when I'm trying to remember. (There's no shame in googling here!)\n",
"- `axis=0`: down a column\n",
"- `axis=1`: across a row\n",
"- We won't need higher dimensional arrays in MCB112, but you can continue incrementing the axis for higher dimensions.\n",
"\n",
"Many functions in NumPy accept `axis` as an optional argument. For example:\n",
"- `np.sum()` sums over the whole array \n",
"- `np.sum(axis=0)` sums down columns \n",
"- `np.sum(axis=1)` sums across rows"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Basic Array Operations\n",
"\n",
"NumPy supports standard elementwise operations:\n",
"\n",
"Operator | Operation\n",
"--- | ---\n",
"`+` |\tadd\n",
"`-` |\tsubtract\n",
"`*` | multiply\n",
"`/` | divide\n",
"\n",
"Note that `*` performs elementwise multiplication, not matrix multiplication. Instead, the `@` operator calculates the dot product of two matrices!\n",
"\n",
"We can also use the equivalent methods for each operation:\n",
"- `np.add(a,b)`: a+b\n",
"- `np.subtract(a,b)`: a-b\n",
"- `np.multiply(a,b)`: a*b\n",
"- `np.divide(a,b)`: a/b\n",
"- `np.matmul(a,b)` or `np.dot(a,b)`: a@b\n",
"\n",
"Some operations are performed universally on each element of the array:\n",
"- `np.sqrt(x)`: square root\n",
"- `np.log(x)`: natural log\n",
"- `np.log10(x)`: log base 10\n",
"- `np.exp(x)`: exponentiate\n",
"- `np.power(x,p)`: raise to the power p\n",
"\n",
"Finally, we can perform operations as if the array were a list of numbers (or compute row-wise or column-wise values by specifying `axis`):\n",
"- `np.sum()`: sum of the whole array\n",
"- `np.mean()`: mean of the whole array\n",
"- `np.max()`: max value over the whole array\n",
"- `np.min()`: min value over the whole array\n",
"\n",
"### Indexing, Slicing, and Filtering\n",
"\n",
"You can index and slice NumPy arrays just like you can slice Python lists. But you can also filter the values, which is incredibly powerful! The function `np.nonzero()` is a handy way to select values that satisfy a certain condition in an array. \n",
"\n",
"Some other ways you might want to filter data include:\n",
"- `np.isnan()`: returns whether each element in an array is NaN\n",
"- `np.isinf()`: returns whether each element in an array is positive or negative infinity\n",
"- `np.isfinite()`: returns whether each element in an array is finite"
]
},
{
"cell_type": "code",
"execution_count": 100,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[False False True False False]\n",
"[ True True False True True]\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/var/folders/98/rznf0_4s6rn6kbnnwcb6hc8r0000gn/T/ipykernel_5852/3990028981.py:1: RuntimeWarning: divide by zero encountered in divide\n",
" a = 5 / np.array([1, 2, 0, -3, -9])\n"
]
}
],
"source": [
"a = 5 / np.array([1, 2, 0, -3, -9])\n",
"\n",
"# Try isinf and isfinite\n",
"print(np.isinf(a))\n",
"print(np.isfinite(a))"
]
},
{
"cell_type": "code",
"execution_count": 103,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5. 2.5 inf]\n",
"[False False False True True]\n",
"[-1.66666667 -0.55555556]\n"
]
}
],
"source": [
"# Slice the array\n",
"print(a[:3])\n",
"\n",
"# Filter the array (e.g., only values > 0)\n",
"print(a < 0)\n",
"print(a[a < 0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Generating random values\n",
"check out the documentation for [numpy random generators](https://numpy.org/doc/stable/reference/random/generator.html)\n",
"Here are some useful examples, but every case is unique and you want to consider how you randomly sample"
]
},
{
"cell_type": "code",
"execution_count": 104,
"metadata": {},
"outputs": [],
"source": [
"rng = np.random.default_rng(42) \n",
"\n",
"#one random number \n",
"val = rng.random()\n",
"\n",
"#10 random values between 0 and 1 \n",
"vals = rng.random(10)\n",
"\n",
"#a binomial of n =1 is a bernoilli trial\n",
"val = rng.binomial(1,0.4, 1)\n",
"\n",
"#you can sample from nearly any distribution, check the documentation to see which are available \n",
"vals = rng.gamma(10,0.4, 10)\n",
"\n",
"#generate a random sequence: \n",
"sequence = rng.choice(list('ACGT'), 100, p= [0.9,0.05,0.04,0.01])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Matplotlib\n",
"\n",
"Now, to the fun part! Let's plot things. Most of these examples are straight out of the fabulous matplitlib tutorial.\n",
"\n",
"Source: [Matplotlib Pyplot Tutorial](https://matplotlib.org/stable/tutorials/introductory/pyplot.html#sphx-glr-tutorials-introductory-pyplot-py)"
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Figures and Axes\n",
"\n",
"To start, we need to create a figure. We can do this in several ways:\n",
"- `fig = plt.figure()`: an empty figure with no Axes\n",
"- `fig, ax = plt.subplots()`: a figure with a single Axes\n",
"- `fig, axs = plt.subplots(2, 2)`: a figure with a 2x2 grid of Axes\n",
"\n",
"I'd recommend sticking with options 2 and 3 because defining new axes for each figure avoids conflicts between multiple figures in your notebook. Otherwise you could end up plotting things on the wrong figure!"
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": 106,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Single axis\n",
"fig, ax = plt.subplots() # Create a figure\n",
"ax.plot([1,2,3,4], [1,4,2,3]) # Plot some data on the axes "
]
},
{
"cell_type": "code",
"execution_count": 107,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": 107,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Multiple axes\n",
"fig, [ax1,ax2] = plt.subplots(1,2,figsize=(8, 4)) # Create a figure with two subplots\n",
"ax1.plot([1,2,3,4], [1,4,2,3]) # Plot some data on the first set of axes\n",
"ax2.plot([1,2,3,4], [3,9,2,5]) # Plot some data on the second set of axes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Labels, Titles, and Legends\n",
"\n",
"These plots are meaningless, but this is *horrible* practice. We have no axes labels, no title, and no legend. So let's learn how to add those.\n",
"\n",
"If you take one thing away from this section, let it be this: **ALWAYS label your axes!**"
]
},
{
"cell_type": "code",
"execution_count": 108,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(0.0, 8.0)"
]
},
"execution_count": 108,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Generate a plot, Add legend, x/y labels, and Set x/y axis limits\n",
"x = np.linspace(0, 2, 100)\n",
"\n",
"fig, ax3 = plt.subplots(figsize=(6, 4)) # Create a figure and an axes\n",
"ax3.plot(x, x, label='linear') # Plot some data on the axes\n",
"ax3.plot(x, x**2, label='quadratic') # Plot more data on the axes...\n",
"ax3.plot(x, x**3, label='cubic') # ... and some more\n",
"\n",
"ax3.set_xlabel('x label') # Add an x-label to the axes\n",
"ax3.set_ylabel('y label') # Add a y-label to the axes\n",
"ax3.set_title(\"Simple Plot\") # Add a title to the axes\n",
"ax3.legend() # Add a legend\n",
"\n",
"ax3.set_xlim([0,2]) # Set the x-axis limits\n",
"ax3.set_ylim([0,8]) # Set the y-axis limits"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Plot Types\n",
"\n",
"In general here are a few types of plots you might want to generate in matplotlib:\n",
"- `plot()` generates a [line plot](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html)\n",
"- `scatter()` generates a [scatter plot](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.scatter.html)\n",
"- `bar()` generates a [bar plot](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.bar.html?highlight=bar%20plot#matplotlib.pyplot.bar)\n",
"- `hist()` generates a [histogram](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.hist.html#matplotlib.pyplot.hist)"
]
},
{
"cell_type": "code",
"execution_count": 109,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAwQAAAEwCAYAAAAJj7ZwAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOapJREFUeJzt3Ql8VNXZ+PEn+wJZICwhJkCAoOwKKAIiEYR/rSiKdUOrVKlgFItUKby2CrwWFBWpIotat9ci2rovpaDsorIJKCAgBAhLDGsSIHvu//OcMNOsJIFJZu7M7/v5jNy5987MmXPnxPvcc85z/SzLsgQAAACAT/J3dwEAAAAAuA8BAQAAAODDCAgAAAAAH0ZAAAAAAPgwAgIAAADAhxEQAAAAAD6MgAAAAADwYQQEAAAAgA8jIAAAAAB8GAEBAFvbvHmz/O53v5PExEQJDQ2Vhg0bSvfu3WX69Oly7NixWr/fF198IZMmTRK72LNnj/j5+ckbb7xRZ5+h71+TOtH9Sj+ioqIkOTlZPv/88zL7tW7dWkaMGFHrcpw+fdqUY9myZRW2rV692mw7ceJEhW1aBn0AACpHQADAtl555RXp0aOHrF27Vh599FFZuHChfPjhh3LzzTfL3Llz5d577z2ngGDy5MliFy1atJBvvvlGrr32WvEEv/nNb0x5vv76a3nppZckPT1drrvuugpBwbnQgECPTVUBgW6rLCCYPXu2eQAAKhdYxXoA8Gh60nn//ffLoEGD5KOPPpKQkBDnNl33xz/+0QQI3qqoqEgKCwvN97788svFUzRv3txZnj59+kjv3r2lXbt2MnPmTLcFLR07dnTL5wKAXdBDAMCWpk6daoalvPzyy2WCAYfg4GC5/vrrnc/fffddGTx4sLmiHhYWJh06dJAJEybIqVOnnPvoMBa9qq1KD33RYTnKsixzpfniiy8279GoUSNzRXz37t1lPlv30/K1atXKDGPq2bOnLF68uNKhK/v27ZM777xTmjVrZr6Hluu5556T4uLiCsOCdBjUk08+aYZH6b5Lly6tcsjQTz/9JLfffrs5Qdd9W7ZsKXfddZfk5eWZ7YcPH5aUlBRzsqzDrPTzBwwYICtXrhRXatu2rTRt2lT27t171v2qqwf9nvo+SnsCHMdGj5kOFdIeIqV149jm6EkoX++OOnv22WdlxowZ5jVaBxq8fPvtt5X2RLVv396US+tr/vz55nN16BMAeAN6CADY8ur4kiVLzHChhISEGr1m586d8utf/1rGjh0rDRo0MCfMTz/9tKxZs8a8l/rLX/5iAoR//etfpgfCQYMINWrUKHPi/dBDD5nX6hyFKVOmmCvhmzZtMiff6rHHHpNp06bJfffdJ8OGDZO0tDQZOXKkFBQUmBNLBz0p19fm5+fL//7v/5oTzM8++0weeeQR2bVrV4VhLi+88IJ5vZ7IRkZGSlJSUqXfVctyxRVXSJMmTUz5dL9Dhw7JJ598Yj5LT2wd8yueeOIJiY2NlZMnT5rhVnri/NVXX7lszP3x48fl6NGjVZa1pvWgx0B7fH71q1+ZoWBan0qDBMf3efHFF+WDDz5wHq/qegY0+LvoootM74Xj+OtvJDU11cx/UBpw6nG/6aab5Pnnn5fMzEwTkDgCKwDwChYA2Ex6erqlf75uu+22c3p9cXGxVVBQYC1fvty8z6ZNm5zbHnjgAbOuvG+++casf+6558qsT0tLs8LCwqzx48eb58eOHbNCQkKsW2+9tdLX9+/f37luwoQJZt13331XZt/777/f8vPzs7Zv326ep6ammv3atm1r5efnl9nXse311193rhswYIAVHR1tZWRk1LhOCgsLTZ0MHDjQuvHGG8ts0/d/4oknqn0P3S8lJcW8j5Zz27Zt1jXXXGPWv/TSS879WrVqZd199921rofDhw9XWZZnnnnGbNP6KE/rvHS9O+qsS5cu5ns7rFmzxqx/5513zPOioiIrNjbW6tWrV5n327t3rxUUFGS+BwB4A4YMAfAJOqxn+PDh5mp4QECABAUFSf/+/c22bdu2Vft6vWKtw0x0WIuO3Xc89P26devmHJ6iQ0706vEtt9xS5vU6rr78EBPtmdCr2JdddlmZ9TocRc+vHT0XDjoESstd3cTb5cuXm893DLGpik681oxMOqwpMDDQvLf2DtSkPqqiV/P1fXTIlg770cm+2kuhw5OqUtt6cBWd06C/BYeuXbuafx3Dm7Zv324mRZc/ljr8qm/fvnVSJgBwB4YMAbAdHQoTHh5uhnbUhA6H6devnznx1TH4OuxGX69DeXRIT05OTrXv8csvv5iTU8ewoPLatGlj/tXhMaqy/cqv030rG4ceFxdX5r0cHENhqhuio0Oq4uPjz7qfjp3XidejR482w3S0TvXkWIfNnE9AoCfPOp5fg6eIiAgzh6D0SXdlalsPrhITE1PmuWMuiuP3UN2xrOnvDwA8HQEBANvRE8yBAwfKv//9b9m/f3+1J796hfngwYPmKr6jV0BVlqKyKnrCrCe5Oum2sknMjnWOk0wNIMrTq82lT3x1Xx3bX56W1fGZpennV6dx48amfrRezubtt9828wTmzJlTZn12dracD+2V0EnUtVHbeqgv1R1LAPAWDBkCYEsTJ040V+x///vfm8mo5ekE3k8//bTMiXT5E/l58+ZVeF35q8QOQ4YMMZ934MABc8Jb/tGlSxezX69evcx7aFaj0nQoUflMOxrUbN26VTZs2FBm/VtvvWXKfNVVV0ltafYjDXr++c9/ypEjR6rcT9+/fH3oTd5KT6auLzWth6qOTXXbztWFF15ohoS99957FTIi6VAoAPAW9BAAsCVNEalXt3VsumYb0nsSdOrUyQQC33//vckO07lzZ3NTLM1goylCdXiMZtXRMe7/+Mc/TDae8hwn9ppF6JprrjFX23VsuY4Z16xBelfkdevWyZVXXmmyFemV7VWrVpnXaRn0Cv24ceNMliH9zBtvvNFcrdfMNDrkx9//v9dhHn74YXPSq2PZdZy9pinVG3jpOHx9r9IZiWpDhwNpliENTjS1qt4HQK9ya5YhDYJ0KI8GODpUSOtDAwgdL69l0BScOjeiPtW0HrTcuu3jjz82QYTWtfYeaK+L47j97W9/k7vvvtscYz2h19ecKz1Wetw0y5Cml73nnntMr1JlxxIAbM3ds5oB4Hxs3LjRZKxp2bKlFRwcbDVo0MC65JJLrMcff7xMlp3Vq1dbvXv3tsLDw62mTZtaI0eOtDZs2FAhQ09eXp7ZpvtohpvymWtee+01k3VGP0ezC2nmn7vuustat25dmSxGTz75pBUfH2/K1LVrV+uzzz6zunXrViGDj2asGT58uBUTE2My11x44YUmY45muCmfFUfXl1dZliG1detW6+abbzbvq2XQ+hkxYoSVm5vr/J6PPPKIdcEFF1ihoaFW9+7drY8++sjUZfnsObXJMqRZmqpTPstQTetBffnll+b4aiYn/bzS7zNx4kQrLi7O8vf3N9uWLl161ixDldVnZd/15Zdfttq1a2fqsX379uY3MHToUFMOAPAGfvofdwclAODtdAKq5rzXK/L/8z//4+7i4DxoL4H2Wtxwww2mJwoA7I6AAABcTIcivfPOO2aokt5ATIfj6F2Gs7Ky5Mcff6wyUxE8j04e/utf/2rmMegkY50Hojco0xvb6dAxHaYGAHbHHAIAcDGdW6Ani3//+9/N1WS9661m9NETS4IBe9HJynv27DFzVfRuyJquVu8pofdwIBgA4C3oIQAAAAB8GCkSAAAAAB9GQAAAAAD4MAICAAAAwIcREAAAAAA+jIAAAAAA8GEEBAAAAIAPIyAAAAAAfBgBAQAAAODDCAgAAAAAH0ZAAAAAAPgwAgIAAADAhxEQAAAAAD4sUGyouLhYDh48KBEREeLn5+fu4gAez7Isyc7Olri4OPH399zrALRtwPvaNu0a8Px2bcuAQIOBhIQEdxcDsJ20tDSJj48XT0XbBryvbdOuAc9v17YMCLRnwFFRkZGR7i4O4PGysrJMEO1oO56Ktg14X9umXQOe365tGRA4hglpMEBAANS+7Xgq2jZwfm3HE9GuAc9v15454BAAAABAvSAgAAAAAHwYAQEAAADgw2w5hwAAAG9VVGzJmtRjkpGdK80iQuWyxMYS4O+5cwQA+GAPwYoVK+S6664zuVF1ssNHH31UIXfqpEmTzPawsDBJTk6WLVu2lNknLy9PxowZI02aNJEGDRrI9ddfL/v37z//bwPgnNCuAc+w8MdDcsXTS+T2V76VPyzYaP7V57q+tmjXAOosIDh16pR069ZNZs2aVen26dOny4wZM8z2tWvXSmxsrAwaNMjcYMFh7Nix8uGHH8qCBQtk1apVcvLkSRkyZIgUFRXVtjgAXIB2DbifnvTf//YGOZSZW2Z9emauWV/boIB2DaDGrPOgL//www+dz4uLi63Y2Fjrqaeecq7Lzc21oqKirLlz55rnJ06csIKCgqwFCxY49zlw4IDl7+9vLVy4sEafm5mZaT5b/wXg2jbjrnZN24YvKywqti6f+qXV6k+fVfpo/afPzHbd71zaNu0acL8Dx09bU7/Yah3OzvW481yXTipOTU2V9PR0GTx4sHNdSEiI9O/fX1avXm2er1+/XgoKCsrso8OLOnfu7NynPB1ipDdpKP0AUD/qql0r2jZQQucMlO8ZKE3PDnS77ucKtGug/s1bvkvmLd8tf3xvk3dPKtaTBtW8efMy6/X53r17nfsEBwdLo0aNKuzjeH1506ZNk8mTJ7uyqPBhrSd8Lt5mz1PX1tl711W7VrRtoIROIHblftWhXQP1KyMrV95Zm2aWR13ZxjfSjpa/s5r2VlZ3t7Wz7TNx4kTJzMx0PtLSSioUQP1xdbtWtG2ghGYTcuV+NUW7BurHyyt2S35hsfRo1Uh6t43x7oBAJxCr8lcEMzIynFcXdZ/8/Hw5fvx4lfuUp8MTIiMjyzwA1I+6ateKtg2U0NSiLaJCparwWdfrdt3PFWjXQP05ejJP/vHdPrM8ZkC7ai+m2T4gSExMNH9kFi9e7FynJwnLly+XPn36mOc9evSQoKCgMvscOnRIfvzxR+c+ADwH7Rqoe3qfgSeu62iWy58qOJ7rdlfdj4B2DdSfV1elSk5BkXSNj5L+7Zt6ZNXXeg6Bpgj9+eefy0xM2rhxozRu3FhatmxpUopOnTpVkpKSzEOXw8PDZfjw4Wb/qKgouffee+WPf/yjxMTEmNc98sgj0qVLF7n66qtd++0A0K4Bm/hV5xYy587uMvnTrWUmGMdGhZpgQLfXBv+/BtzvxOl8eWv1HrM8ZkCSR/YOnFNAsG7dOrnqqqucz8eNG2f+vfvuu+WNN96Q8ePHS05OjqSkpJjhA7169ZJFixZJRESE8zXPP/+8BAYGyi233GL2HThwoHltQECAq74XgFqgXQOeQU/6B3WMdcmdimnXgPu99vUeOZVfJB1aRMrVHZqJp/LT3KNiM5p2VHsadIIx8wlQW76YZcgubcYu5QQ8hR3ajB3KCNSFrNwC6fvUEsnOLZTZd3SXX3dp4bFtpk6yDAEAAAC+7M2v95hgIKlZQ/lVp5IEHZ6KgAAAAABwoZN5hfL3r1PN8oMD2om/ixIC1BUCAgAAAMCF3v52r5w4XSCJTRrIkK5x4ukICAAAAAAXyckvkldX7jbLKcltXZYuuC4REAAAAAAuMn/NPjlyMl/iG4XJDZdcIHZAQAAAAAC4QG5BkcxbvssspyS3k6AAe5xq26OUAAAAgIf757o0ycjOkxZRoXJTD3v0DigCAgAAAOA85RcWy5xlJb0Do/u3lZBA+9xwl4AAAAAAOE8fbNgvBzNzpWlEiNx6aYLYCQEBAAAAcB4Ki4pl9pnegVFXtpHQIPv0DigCAgAAAOA8fLzxoOw7dloaNwiW4b1ait0QEAAAAADnqKjYkpeW/myWR/ZLlPDgQLEbAgIAAADgHH3+wyHZfeSURIUFyV29W4sdERAAAAAA56C42JJZS3aa5Xv6JkrDEPv1DigCAgAAAOAcLNqaLjt+OSkRIYEyoq89ewcUAQEAAABQS5ZlyYtLSuYO3N2ntRkyZFcEBAAAAEAtLfkpQ7YczJLw4AC554pEsTMCAgAAAKCWvQMvnOkd+O3lrUy6UTsjIAAAAABqYeXOI7Ip7YSEBvnLyH5txO4ICAAAAIBazR0oySw0/LJW0jQiROyOgAAAAACooW93H5O1e45LcKC/jOpv/94BRUAAAAAA1JCjd+DWngnSPDJUvAEBAQAAAFAD6/cek9W7jkpQgJ+MTm4r3oKAAAAAAKiBF74qySx0U/d4uSA6TLwFAQEAAABQjY1pJ2T5jsMS4O8nKcntxJsQEAAAAADVmHVm7sDQi+OkZUy4eBMCAgAAAOAsthzMlC+3ZYifn8gDV3lX74AiIAAAAADOYtaZuxIP6RonbZs2FG9DQAAAAABUYccv2fLvH9PN8oNe2DugCAgAAACAanoHftUpVi6MjRBvREAAAAAAVGL34ZPy2eaDZvnBAd7ZO6AICABUq7CwUP785z9LYmKihIWFSZs2bWTKlClSXFzs3MeyLJk0aZLExcWZfZKTk2XLli3ULuChaNdA9V5aukuKLZGBFzWTzhdEeW2VERAAqNbTTz8tc+fOlVmzZsm2bdtk+vTp8swzz8iLL77o3EfXzZgxw+yzdu1aiY2NlUGDBkl2djY1DHgg2jVwdvuOnpaPNh4wy2MGJnl1dbk8IOCKA+B9vvnmGxk6dKhce+210rp1a/nNb34jgwcPlnXr1jl7B2bOnCmPPfaYDBs2TDp37ixvvvmmnD59WubPn+/u4gOoBO0aOLs5y3+WomJL+iU1kYsTor26ulweEHDFAfA+V1xxhXz11VeyY8cO83zTpk2yatUq+fWvf22ep6amSnp6ugkSHEJCQqR///6yevXqKt83Ly9PsrKyyjwA1A/aNVC1Aydy5F/r95vlh7y8d0AF1uUVB6VXE995550qryQqvZLYvHlzcyVx1KhRri4SgPP0pz/9STIzM+Wiiy6SgIAAKSoqkr/+9a9y++23m+0aDChtx6Xp871791b5vtOmTZPJkydzfAA3oF0DVZu3fJcUFFlyeZvGcmnrxl5fVf52uOLAVUTAvd599115++23TdC+YcMGE8Q/++yz5t/S/PQWjqXoBYDy60qbOHGiCTQcj7S0tDr7DgDKol0DlcvIypUFa0v+f/TQAO/vHaiTHoK6uOLAVUTAvR599FGZMGGC3HbbbeZ5ly5dTHvVtnn33XebCcSO9t2iRQvn6zIyMiq09dL0YoA+ANQ/2jVQuXkrdkt+YbH0aNVIereN8Ylq8rfDFQeuIgLupZOD/f3L/rnQgN+RdlTTkWpQsHjxYuf2/Px8Wb58ufTp06feywugerRroKIjJ/PkH9+VXKAeM6DdWXu5vUmgHa44cBURcK/rrrvO9PS1bNlSOnXqJN9//71JMXrPPfeY7foHc+zYsTJ16lRJSkoyD10ODw+X4cOHc/gAD0S7Bip6dWWq5BYUS9f4KOnfvqnPVFGgO684XHLJJWWuJGqGIgCeR+838Je//EVSUlJM8K43H9MEAI8//rhzn/Hjx0tOTo7Z5/jx49KrVy9ZtGiRRER4523eAbujXQNlHT+VL//3zR6zPGZAks/0Dig/S8fquNCIESPkyy+/lHnz5jmvJN53333mSqLjhF//1R6D119/3XklcdmyZbJ9+/YanTxoasKoqCgzVyEyMtKVxYcPaD3hc/E2e54qyepl9zZjl3ICnsIObcYOZQTUjEXb5YUlP0uHFpHyxUNXuC0gcEebcXkPAVccAAAAYCdZuQXy+uo9Pjd3oM4CAr3Cr/cZ0EdVtJInTZpkHgAAAIA7vfn1HsnOLZSkZg3lV51K5rv6EpdnGQIAAADs4mReofz961Sz/OCAduLv71u9A4qAAAAAAD7r7W/3yonTBdKmSQMZ0jVOfBEBAQAAAHxSTn6RvLpyt1lOuaqdBPhg74AiIAAAAIBPmr9mnxw5mS8JjcNk6MW+2TugCAgAAADgc3ILimTe8l1mOSW5nQQF+O5pse9+cwAAAPis99alSUZ2nsRFhcpN3ePFlxEQAAAAwKfkFxbL3GUlvQOjk9tKcKBvnxL79rcHAACAz3l/w345mJkrzSJC5JaeCeLrCAgAAADgMwqKimX2sp/N8n1XtpHQoADxdQQEAAAA8BkfbzwoacdyJKZBsNzRq5W7i+MRCAgAAADgE4qKLZm9tKR3YGS/NhIWTO+AIiAAAACAT/hs80HZfeSURIcHyW970zvgQEAAAAAAr1dcbMlLZ3oH7umbKA1DAt1dJI9BQAAAAACv958t6bLjl5MSERIod/dp7e7ieBQCAgAAAHg1y7LkxSUlvQMj+raWqLAgdxfJoxAQAAAAwKt9tS1Dth7KkgbBAWa4EMoiIAAAAICX9w7sNMt39m4ljRoEu7tIHoeAAAAAAF5rxc4jsml/poQG+cvv+7Vxd3E8EgEBAAAAvLd34KuS3oHhl7WSJg1D3F0kj0RAAAAAAK/0ze6jsm7vcQkO9JdR/ekdqAoBAQAAALzSi1+VZBa6tWeCNI8MdXdxPBYBAQAAALzOuj3HTA9BUICfjE5u6+7ieDQCAgAAAHidF87cd+Cm7vFyQXSYu4vj0QgIAAAA4FU2pp2QFTsOS4C/n6Qkt3N3cTweAQEAAAC8yqwz9x0YenGctIwJd3dxPB4BAQAAALzGloOZ8uW2DPH3E3ngKnoHaoKAAAAAAF5j1pm5A0O6xknbpg3dXRxbICAAAACAV9jxS7b8+8d0s/zgAHoHaoqAAAAAAF7VO3BN51hp3zzC3cWxDQICAAAA2N6uwyfls80HzTK9A7VDQACgRg4cOCB33nmnxMTESHh4uFx88cWyfv1653bLsmTSpEkSFxcnYWFhkpycLFu2bKF2AQ9Gu4Y3eWnpz1JsiVzdoZl0iotyd3FshYAAQLWOHz8uffv2laCgIPn3v/8tW7duleeee06io6Od+0yfPl1mzJghs2bNkrVr10psbKwMGjRIsrOzqWHAA9Gu4U32HT0tH28s6R0YMyDJ3cWxnUB3FwCA53v66aclISFBXn/9dee61q1bl+kdmDlzpjz22GMybNgws+7NN9+U5s2by/z582XUqFGVvm9eXp55OGRlZdXp9wDwX7RreJPZy36WomJLrmzfVLol/PdiFdzYQ0AXJOBdPvnkE+nZs6fcfPPN0qxZM7nkkkvklVdecW5PTU2V9PR0GTx4sHNdSEiI9O/fX1avXl3l+06bNk2ioqKcDw06ANQP2jW8xYETOfL+hv1m+SEyC3lGQEAXJOB9du/eLXPmzJGkpCT5z3/+I6NHj5aHHnpI3nrrLbNdgwGlPQKl6XPHtspMnDhRMjMznY+0tLQ6/iYAHGjX8BZzl+2SgiJLereJkZ6tG7u7OLYUaJcuSADuU1xcbHoIpk6dap5rD4FOGNYg4a677nLu5+fnV+Z12t7LrytNexH0AaD+0a7hDX7JypV315VcTBozkPsOeEwPQV10QeoYYx1bXPoBoP60aNFCOnbsWGZdhw4dZN++fWZZJxCr8r0BGRkZFXoNAHgG2jW8wbzluyW/sFh6tmpkegjgIQFBXXRBMs4YcC/NMLR9+/Yy63bs2CGtWrUyy4mJiSYoWLx4sXN7fn6+LF++XPr06VPv5QVQPdo17O7IyTyZv2avWR4zMOmsPdKo5yFDddEFqeOMx40b53yuPQRMPgTqz8MPP2xO7LVd33LLLbJmzRp5+eWXzUNp2x07dqzZrhcD9KHLer+C4cOHc6gAD0S7ht29snK35BYUS7f4KLkyqYm7i2NrgfXVBfn+++9XGFqg+9ZkaAHjjAH3uvTSS+XDDz80wfmUKVNMj4DOBbrjjjuc+4wfP15ycnIkJSXFJBfo1auXLFq0SCIiuHU84Ilo17Cz46fy5f++OdM7MIDeAY8LCGrTBam9B6WHFuiEZACeaciQIeZRFe0l0DsV6wOAPdCuYVevfZ0qp/OLpGOLSBnYoZm7i2N7Lg8I6IIEAABAXcnMKZA3vt5jlscMaMfcAU8MCOiCBAAAQF15c/Ueyc4rlPbNG8r/61QyFB0eFhAouiABAADgaifzCs1wIfXAVe3E35/MQh6ZdhQAAACoCzqR+MTpAmnTpIEM6RpHJbsIAQEAAAA83un8Qnl15W6znHJVOwmgd8BlCAgAAADg8eZ/t0+OnsqXhMZhMvRiegdciYAAAAAAHi23oEheXnGmdyC5nQQFcArrStQmAAAAPNp769IkIztP4qJC5abu8e4ujtchIAAAAIDHyi8slrnLdpnl0cltJTiQ01dXo0YBAADgsd7fsF8OZuZKs4gQuaVngruL45UICAAAAOCRCoqKZfayn83yqP5tJTQowN1F8koEBAAAAPBIH288KGnHcqRJw2AZfllLdxfHaxEQAAAAwOMUFVsye2lJ78DIfm0kLJjegbpCQAAAAACP89nmg7L7yCmJDg+SOy9v5e7ieDUCAgAAAHiU4mJLZi0p6R24t2+iNAwJdHeRvBoBAQAAADzKwi3psjPjpESEBsrdfVu7uzhej4AAAAAAHsOyLHnxTO/A7/q0lsjQIHcXyesREAAAAMBjfLktQ7YdypIGwQFyzxWJ7i6OTyAgAAAAgAf1Duw0y7/t3Vqiw4PdXSSfQEAAAAAAj7B8x2HZvD9TQoP8ZWQ/egfqCwEBAAAAPGruwB29WkmThiHuLpLPICAAAACA232z66is33tcggP9ZdSVbdxdHJ9CQAAAAAC3e+HM3IHbLk2QZpGh7i6OTyEgAAAAgFut3XNMvt19TIIC/GR0/7YcjXpGQAAAAAC3euGrkt6B3/SIl7joMI5GPSMgAAAAgNtsTDshK3cekQB/P7m/fzuOhBsQEAAAAMBtXjzTO3DDxRdIy5hwjoQbEBAAAADALX48kClf/ZQh/n4iD1zF3AF3ISAAAACAW8w6c9+BIV3jpE3ThhwFNyEgAAAAQL3bnp4tC7ekm+UHBzB3wJ0ICAAAAFDvZi0t6R24pnOstG8ewRFwIwICALU2bdo08fPzk7Fjx5a55fykSZMkLi5OwsLCJDk5WbZs2ULtAjZBu0Z92nX4pHy2+aBZpnfA/QgIANTK2rVr5eWXX5auXbuWWT99+nSZMWOGzJo1y+wTGxsrgwYNkuzsbGoY8HC0a9S3l5b+LJYlcnWHZtIpLooD4GYEBABq7OTJk3LHHXfIK6+8Io0aNSrTOzBz5kx57LHHZNiwYdK5c2d588035fTp0zJ//nxqGPBgtGvUt31HT8vHG0t6B8YMSOIAeAACAgA19sADD8i1114rV199dZn1qampkp6eLoMHD3auCwkJkf79+8vq1aurfL+8vDzJysoq8wBQv2jXqG+zl/0sRcWWXNm+qXRLiOYAeIBAdxcAgD0sWLBANmzYYIYWlKfBgGrevHmZ9fp87969Zx2zPHny5DooLYCaoF2jvh04kSPvb9hvlv8wkMxCPtNDwCQlwP7S0tLkD3/4g7z99tsSGhpa5X460bg0HUpUfl1pEydOlMzMTOdDPwdA/aBdwx3mLtslBUWW9GkbIz1aNeYg+EJAwCQlwDusX79eMjIypEePHhIYGGgey5cvlxdeeMEsO3oGHD0FDvqa8r0GpemwosjIyDIPAPWDdo36lp6ZK++uLbnww9wBHwkImKQEeI+BAwfKDz/8IBs3bnQ+evbsaSYY63KbNm1MVqHFixc7X5Ofn2+Chj59+ri17AAqR7tGfZu3YpfkFxXLpa0byeVt6B3wiTkEpScpPfnkkzWefDhq1KhKJx7qw4GJh0D9ioiIMJmDSmvQoIHExMQ41+s9CaZOnSpJSUnmocvh4eEyfPhwDhfggWjXqE+Hs/Nk/nf7nL0DZxtOCi8JCFw9SYmJh4DnGz9+vOTk5EhKSoocP35cevXqJYsWLTInHQDsiXYNV3l15W7JKyw2WYX6JTWhYr09IHBMUtITAVdNPtSJh+PGjSvTQ5CQkODCUgOorWXLlpV5ru1X71SsDwD2RLtGXTh2Kl/+79uSi74PDWhH74AvBASlJyk5FBUVyYoVK8wdTLdv3+7sKWjRokWNJh/qkCJ9AAAAwF5eW5Uqp/OLpFNcpAy4qJm7i4P6mFTMJCUAAACozJwCeXP1HrM8ht4B3+khYJISAAAA1Btf75HsvEK5sHmEDO4YS6V4KLfcqZhJSgAAAN4tO7dAXvs61Sw/MKCd+PuTWcinAwImKQEAAPgWnUisQ4baNG0g13b577xR+NidigEAAOB7TucXyqsrz/QOJLeTAHoHPBoBAQAAAFxKb0Km6UZbNg6XoRfHUbsejoAAAAAALpNbUCTzVuw2yynJbSUwgNNNT8cRAgAAgMu8uzZNDmfnyQXRYTKsezw1awMEBAAAAHCJvMIimbt8l1ke3b+NBAdyqmkHHCUAAAC4xPvrD8ihzFxpFhEiN/dMoFZtgoAAAAAA562gqFhmL/vZLI/q31ZCgwKoVZsgIAAAAMB5++j7A7L/eI40aRgswy9rSY3aCAEBAAAAzktRsSWzl5XMHRjZr42EBdM7YCcEBAAAADgvn20+KKlHTkl0eJDceXkratNmCAgAAABwzoqLLZm1pGTuwL19E6VhSCC1aTMEBAAAADhnC7eky86MkxIRGih3921NTdoQAQEAAADOiWVZ8uKZ3oHf9WktkaFB1KQNERAAAADgnHy5LUO2HcqSBsEBcs8VidSiTREQAAAA4Bx7B3aa5bv6tJbo8GBq0aYICAAAAFBry3ccls37MyUsKEBG0jtgawQEAAAAqHXvwAtflfQO3NGrpcQ0DKEGbYyAAAAAALWyetdR2bDvhAQH+st9V7ah9myOgAAAAAC14ugduP3SBGkWGUrt2RwBAQAAAGpsTeox+S71mAQF+Mmo/m2pOS9AQAAAAIAac2QW+k2PBImLDqPmvAABAQAAAGrk+33HZeXOIxLg7ycpyfQOeAsCAgAAANSI467EN15ygSQ0DqfWvAQBAQAAAKr144FMWfJThvj7iTxwVTtqzIsQEAAAAKDGcweu6xYniU0aUGNehIAAAAAAZ/VTepb8Z8sv4ucn8iC9A16HgAAAAABnNevM3IFrOsdKUvMIasvLEBAAqNa0adPk0ksvlYiICGnWrJnccMMNsn379gq3sZ80aZLExcVJWFiYJCcny5YtW6hdwEPRrlFTP2eclM9/OGSWH7wqiYrzQgQEAKq1fPlyeeCBB+Tbb7+VxYsXS2FhoQwePFhOnTrl3Gf69OkyY8YMmTVrlqxdu1ZiY2Nl0KBBkp2dTQ0DHoh2jZqavfRnsSyRqzs0l45xkVScFwp0dwEAeL6FCxeWef7666+bnoL169fLlVdeaXoHZs6cKY899pgMGzbM7PPmm29K8+bNZf78+TJq1KhK3zcvL888HLKysur4mwBwoF2jJvYePSUfbzpolh8aSGYhb0UPAYBay8zMNP82btzY/Juamirp6emm18AhJCRE+vfvL6tXrz7rkIWoqCjnIyEhgaMBuAntGpWZvXSXFBVb0r99U+kaH00leSkCAgC1or0B48aNkyuuuEI6d+5s1mkwoLRHoDR97thWmYkTJ5qTEMcjLS2NowG4Ae0aldl//LS8v2G/WaZ3wLsxZAhArTz44IOyefNmWbVqVYVtfpqPrtxJRvl1pWkvgj4AuBftGpWZu3yXFBZb0qdtjPRoVdIjDO/k8h4CshYA3mvMmDHyySefyNKlSyU+Pt65XicQq/K9ARkZGRV6DQB4Fto1KpOemSvvrS3pHRgzgMxC3s7lAQFZCwDvo1f69QriBx98IEuWLJHExMQy2/W5BgWagcghPz/f/D3o06ePG0oMoDq0a5zNvBW7JL+oWC5t3Ugub0PvgLcLtEvWAgDuoylHtX1+/PHH5l4Ejp4AnQis9xzQYUFjx46VqVOnSlJSknnocnh4uAwfPpxDB3gg2jWqcjg7T+Z/t8/ZO3C2oZ/wDoGelrWgsoCA1ISAe82ZM8f8qzcbKx/wjxgxwiyPHz9ecnJyJCUlRY4fPy69evWSRYsWmQACgOehXaMqr67cLXmFxdItIVr6JTWhonxAoCdlLdi7d2+V8xImT55cl0UFUE1bro5eQdI7FesDgOejXaMyx07ly/99W3I+9tCAdvQO+Aj/+sha8M4775xXNhJSEwIAANS911alyun8IukUFykDLmpGlfuIwLrOWrBixYoqs5G0aNGiRtlISE0IAABQtzJzCuTN1XvMMnMHfIvLewjIWgAAAGA/b3y9R7LzCuXC5hEyuCMpo32Jy3sIyFoAAABgL9m5BfL3VbvN8oMD2om/P5mFfInLAwKyFgAAANjLW9/slazcQmnTtIH8ust/h3TDN7g8ICBrAQAAgH2czi+Uv69KNcsPXtVOAugd8Dl1mmUIAAAAnu0f3+4z6UZbxYTL9d3i3F0cuAEBAQAAgI/KLSiSeStK5g6kJLeVwABODX0RRx0AAMBHLVizT46czJMLosPkxkv+myYevqVO71QMALC3omJL1qQek4zsXGkWESqXJTZmfDHgJfIKi2Tu8pLegdHJbSU4kOvEvoqAAABQqYU/HpLJn26VQ5m5znUtokLlies6yq86k4UEsLt/rd8v6Vm50jwyRG7uQe+ALyMUBABUGgzc//aGMsGASs/MNet1OwD7KigqljnLdpnlUVe2ldCgAHcXCW5EQAAAqDBMSHsGrErqxbFOt+t+AOyluNiSnzNOyswvd8j+4znSpGGw3H5ZS3cXC27GkCEAQBk6Z6B8z0BpGgbodt2vd9sYag/wUHpvqLRjObJp/wn54UCmbN5/Qn48kCUn8wqd+/y+XxsJC6Z3wNcREAAAytAJxK7cD0D9nPzrfIBNaZnyw4ETsnm//pspJ04XVNg3NMhfOsdFyZXtm8o9VyRyeEBAAAAoS7MJuXI/AK6nqUJ/2J9ZcvXf/Jtp1pUXHOAvHVpESJf4KOkaHy1d46OkXdOG3G8AZdBDAAAoQ1OLajYhnUBc2SwBPxGJjSpJQQqg7mWeLjBX+x0n/zr052Alw/oC/P2kffMI6XpBlAkAusVHS/vYhhISyJAgnB0BAQCgwkmFphbVbEJ68l86KNDnSrfrfgBcS8f3bzHj/TNl85lx/3uPnq6wn5+fSNumDZ0n/3r1v2OLSOYD4JwQEAAAKtD7DMy5s3uF+xBozwD3IQBcI7egSLYeypLNaSfOnPxnyq7DJ8WqpGuuVUy4dLlAT/xLTv47xUVKRGgQhwIuQUAAAKgyKBjUMZY7FQMukF9YLDt+yS4z5l+fV5a+V4fsOU789V8NBKLDgzkOqDMEBACAKumwIFKLArVTdCbXv3PM/4FM2XYoywQF5el9APTEX0/6uyVESecLopiwj3pHQOAjWk/4XLzRnqeudXcRAAA+fqOvPUdPlYz5N6k+S3L95xQUVdg3KizIecXfcfVfewP8dEIA4EYEBAAAADXM9a939y2Z8Fty9V+z/2Tn/vdGXw4NggPM1f7SQ39aNg7n5B8eiYAAAACgEr+YG3057vJbcvJ/7FR+hf1CAv3NJN/SQ38SmzQkExdsg4AAAAD4vKMn88xY/5I8/yXpPjOyK97oK9DfTy5qEVFy1f/M0J+k5g0lKMDf5+sQ9kVAAAAAfEpmToHJ9b/pzJj/TWmZcuBEToX99FYbeqOv0uk+L4yNkNAgbvQF70JAAAAAvNbp/ELZcjCrzNCf1COnKt23TZMGJZN+46OlW3yUdIyLlPBgTpXg/fiVAwAAr7nR10/p2Wa4j2PYj6b/rCTVv8Q3CpNuOubfXPkvSfcZyY2+4KMICADYKrf3mtRjkpGda/J0X5bYmEl7gI8qKCq50Zcj3aee/G9Pz5bCSs7+m0eGOMf8lwQA0dK4ATf6AhwICADYwsIfD8nkT7fKocxc5zrN3/3EdR3NHXUBePfFgN2H9UZfOun3hPl3axU3+tITfTPe35z8l6T7bB4Z6pZyA3ZBQADAFsHA/W9vkPLX/dIzc836OXd2JygAvCjX/96jp8vc5VcnAJ/Kr3ijr4jQwDI3+dLHBdFh5PoHaomAAIBLzZ49W5555hk5dOiQdOrUSWbOnCn9+vU7ryuD2jNQyRBgs07v76nbB3WMZfgQYJN2XVpOfpEs255RKuXnCcmq5EZfYUF6o6+SXP+OjD+tGoeLv6YCAnBeCAgAuMy7774rY8eONScPffv2lXnz5sk111wjW7dulZYtW57Te+qcgdLDhCoLCnS77te7bcx5lB5AfbXr0vIKi+T+f2wosy44wF86xEWaTD8lN/qKlrZNudEXUFcICAC4zIwZM+Tee++VkSNHmud6FfE///mPzJkzR6ZNm3ZO76kTiF25HwD3t+vSosOD5eoOzaRpRIh0uaDk6r/m/g8O5EZfQH0hIADgEvn5+bJ+/XqZMGFCmfWDBw+W1atXV/qavLw883DIysqqsI9mE6qJmu4HwP3turxX776UwwK4EeE3AJc4cuSIFBUVSfPmzcus1+fp6emVvkavLkZFRTkfCQkJFfbR1KKaTaiqUcK6XrfrfgDs0a4BeBYCAgAu5efnVyFjSPl1DhMnTpTMzEznIy0trcI+Af5+JrWoee/yn3XmX92u+wGwR7sG4FkYMgTAJZo0aSIBAQEVrhpmZGRUuLroEBISYh7V0fsMaGrR8vchiOU+BIBt2zUAz0FAAMAlgoODpUePHrJ48WK58cYbnev1+dChQ8/7/TUo0NSi3KkY8J52DcAzuHXIkKYwS0xMlNDQUPMHZ+XKle4sDoDzNG7cOHn11Vfltddek23btsnDDz8s+/btk9GjR7ukbnVYkKYWHXrxBeZfhgkB9m/XAHy4h6Cu8xoDqH+33nqrHD16VKZMmWJuYNS5c2f54osvpFWrVhwOwKZo14D387N0ZpAb9OrVS7p3727yGDt06NBBbrjhhmrzGmsKM81coJOVIiMjz7pv6wmfi7fZ89S1tX6NN9aDoi5qVg+1aTPuZJdyAp7CDm3GDmUEfL3NBNohr3H5nMZaQTXNbVycd1q8TU2+ty/Ug6IualYPju1uiv9rzFG+czmugC+yQ9umXQOe364D7ZDXWHsMJk+eXGG9r+Y2jprp7hJ4DuqidvWQnZ1trjp4Ki2fL7dt4Fx5ctumXQOe364D7ZDXWHMa66Qmh+LiYjl27JjExMRUmQe5viM5PYHRXMu+3h1KXXhmXWjb0j8scXFx4sm0fFpfERERVbZtT6pXX0Gde26d26Ft0649E+3ac+vdckO7DrRDXuPKchpHR0eLp9EDywkKdeGpvwtPvXpYmr+/v8THx9uqXn0Jde6Zde7pbZt27dlo155Z7/Xdrv3dnde4NH3ep08fdxQJAAAA8EluGzKkQ4B++9vfSs+ePaV3797y8ssvk9cYAAAA8JWAwJvyGutwpieeeIJbtVMX/C5ob16Jv3HUOb8x70O7pt494j4EAAAAANzPLXMIAAAAAHgGAgIAAADAhxEQAAAAAD6MgAAAAADwYQQE8GjLli0zd6w9ceKEu4sCwIVo24D3oV3bFwEBAAAA4MMICMrJz893z5HwMNQD9cHvzDvRtql3fmPeh3ZNvZ8vrw8IsrOz5Y477pAGDRpIixYt5Pnnn5fk5GQZO3as2d66dWt58sknZcSIERIVFSW///3vzfr3339fOnXqZG7cofs899xzZd5Xh7F89NFHZdZFR0fLG2+8YZb37Nlj9lmwYIH06dNHQkNDzftpd1pNFBUVyb333iuJiYkSFhYmF154ofztb3/zuXpw+Prrr6Vbt27m9b169ZIffvjhnOvC7vWxZcsWufbaayUyMlIiIiKkX79+smvXLvEEdq1XV7e3+mTXOq+rtl1ffOlviF2/K+2adl1b2Tb9rbvk3MDyciNHjrRatWplffnll9YPP/xg3XjjjVZERIT1hz/8wWzXbZGRkdYzzzxj7dy50zzWrVtn+fv7W1OmTLG2b99uvf7661ZYWJj510Gr7sMPPyzzWVFRUc59UlNTzT7x8fHWv/71L2vr1q2mLPrZR44cqbbc+fn51uOPP26tWbPG2r17t/X2229b4eHh1rvvvutT9bB06VLz+g4dOliLFi2yNm/ebA0ZMsRq3bq1qaNzZdf62L9/v9W4cWNr2LBh1tq1a005XnvtNeunn36yPIFd69XV7a0+2bXO66pt1xdf+hti1+9Ku6Zd19ZIHz438OqAICsrywoKCrL++c9/OtedOHHC/I++9MG94YYbyrxu+PDh1qBBg8qse/TRR62OHTvW+uA+9dRTzu0FBQXmYD/99NPn9H1SUlKsm266yafqwXHSsGDBAue6o0ePmsZ2ridrdq6PiRMnWomJiR55wmTnenVle6tPdq7zumjb9cWX/obY+btWhnZNu/bG3/pEF5wbePWQod27d0tBQYFcdtllznXaxaPDAUrr2bNnmefbtm2Tvn37llmnz3fu3Gm6IGujd+/ezuXAwEDzWfr+NTF37lyzf9OmTaVhw4byyiuvyL59+8TX6qH86xs3bmzKXpvXe0t9bNy40XQDBgUFiaexc726sr3VJ7vXuavbdn3xpb8hdv6uinZNu66p3T5+buDVAUFJUFYydquy9Q46Vqz89upeo9vLr9MfUk2Uf+/KvPfee/Lwww/LPffcI4sWLTIH+3e/+905TRyycz3UxevtXB86vt1T2bleXdne6pOd67wuX1/XfOlviJ2/K+2adu0rv/UwF5wbeHVA0LZtWxMtrVmzxrkuKyvLRG1n07FjR1m1alWZdatXr5b27dtLQECAea5XEQ8dOuTcru95+vTpCu/17bffOpcLCwtl/fr1ctFFF1Vb9pUrV5qJJSkpKXLJJZdIu3btznniqJ3robLXHz9+XHbs2FGr13tLfXTt2tX8Nmr6h6Q+2bleXdne6pOd67wu2nZ98aW/IXb+rrRr2nVttPX1cwPLy+mkDB1XtWTJEuvHH380Y4J1ksbYsWOd48Gef/75Mq9Zv359mQkib7zxRoUJIrfddpuZDKf76gSOAQMGmLFn5ceDtWzZ0vrggw+sbdu2Wffdd5/VsGFD6/Dhw9WWe+bMmWbiysKFC00Z/vznP5vn3bp186l6cIwz7tSpk3OSz/XXX2/eLy8v75zqws71oZOLYmJinBOHduzYYb311lseNanYjvXq6vZWn+xa53XVtuuLL/0Nset3pV3TrmtrpA+fG3h9QKCTRHTCh04KiY2NtWbMmGFddtll1oQJE6o8uEpneeuEED1geoB0RnlpBw4csAYPHmw1aNDASkpKsr744otKJ4jMnz/f6tWrlxUcHGx+DF999VWNyp2bm2uNGDHCvGd0dLR1//33mzKf6wmKXevBcdLw6aefmhMHff2ll15qbdy48Zzqwe71oTZt2mQ+Q8uuf6j69etn7dq1y/IEdq1XV7e3+mTXOq+rtl1f7Frv5/I3xK7flXZNu66tLJv+1l1xbuD1AUF5J0+eNAfh1VdfrdPPcRzc77//3vJE1AP1we/MO9G2qXd+Y96Hdk2917VA8XLff/+9/PTTT2bWeGZmpkyZMsWsHzp0qPgS6oH64HfmnWjb1Du/Me9Du6be65tXTyp2ePbZZ82dMK+++mo5deqUmXjRpEkTt5Zp9OjRJrVhZQ/dVheoB+qjPvA7q3/UuXv4Ur370nf1FNQ59V6fv3U/7SZwyTuhVjIyMszs9crobaebNWvmEzVKPVAf/M68E22beuc35n1o195b7wQEAAAAgA/ziSFDAAAAACpHQAAAAAD4MAICAAAAwIcREAAAAAA+jIAAAAAA8GEEBAAAAIAPIyAAAAAAxHf9f5XIxW3HS0IpAAAAAElFTkSuQmCC",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Generate a 1x3 figure\n",
"names = ['group_a', 'group_b', 'group_c']\n",
"values = [1, 10, 100]\n",
"\n",
"plt.figure(figsize=(9, 3))\n",
"\n",
"plt.subplot(131)\n",
"plt.bar(names, values)\n",
"plt.subplot(132)\n",
"plt.scatter(names, values)\n",
"plt.subplot(133)\n",
"plt.plot(names, values)\n",
"plt.suptitle('Categorical Plotting')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Formatting\n",
"\n",
"This is a whole can of worms. You can get lost for hours on Stack Overflow pages troubleshooting how to customize your plot formatting in matplotlib.\n",
"\n",
"For now, here are some basic options for line plots you may want to play with:\n",
"- `linewidth` sets the line thickness\n",
"- `linestyle` sets the style (`-` solid, `--` dashed, `:` dotted)\n",
"- `color` sets the color\n",
"- `alpha` sets the transparency"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Troubleshooting\n",
"\n",
"What's the best way to troubleshoot when you're stuck?\n",
"\n",
"- **Python Documentation**: Python has terrific online documentation for all of its functions. Python packages, which we'll talk about next week, also (usually) have their own documentation pages. These pages include descriptions and examples.\n",
" - [Python Docs](https://docs.python.org/3/)\n",
" - [Numpy Docs](https://numpy.org/doc/)\n",
" - [Matplotlib Docs](https://matplotlib.org/stable/index.html)\n",
"\n",
"\n",
"- **Google**: Many coding questions have already been answered online and can be found with a quick search. A popular site to troubleshoot coding questions is Stack Overflow. You should not just copy/paste code (this usually will not work for your specific problem anyway). But sites like Stack Overflow are helpful for figuring out little quirks in Python functions and also for seeing ways that other people have solved different problems.\n",
" - [Stack Overflow](https://stackoverflow.com/)\n",
"\n",
"\n",
"- **Class Resources**: These include the Piazza page for directly asking questions, as well as lecture, section, and office hours. Working together with classmates can also be super helpful. You are expected to submit your own work for each pset (your code and text should not look like your friend's submission), but we encourage you to talk to each other about ideas and help each other figure out problems along the way. That's part of science!\n",
" - [Ed](https://edstem.org/us/courses/87874/discussion/7563924)\n",
" \n",
"- **LLMs**: Can be a useful tool for debugging. There is no guarantee it will be correct! It can also explain code to you and be used as a learning tool. In the end, you must figure out how much to rely on it, and for this class you should understand every line of code you turn in! \n",
" - [ChatGPT](https://chatgpt.com/)\n",
" - [Claude](https://claude.ai/)\n",
" - [Gemini](https://gemini.google.com)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"colab": {
"collapsed_sections": [],
"name": "python_section_01.ipynb",
"provenance": [],
"toc_visible": true
},
"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.14.2"
}
},
"nbformat": 4,
"nbformat_minor": 4
}