lecture-2-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 2-1: Python decathlon\n",
    "\n",
    "In our first workshop, we gave a basic introduction to Python and talked about two applications: solving differential equations and evaluating integrals. \n",
    "\n",
    "To begin today, we'll revisit 10 main concepts that we visited in the first workshop:\n",
    "- Printing (and Python notebook functions)  \n",
    "- Data types  \n",
    "- Basic operations  \n",
    "- Variables  \n",
    "- Lists  \n",
    "- Using libraries  \n",
    "- Making plots  \n",
    "- Functions  \n",
    "- For loops  \n",
    "- Modular programming  \n",
    "\n",
    "If you finish working through the activities below, there's a brief assignment that will help us to develop some material for this afternoon's session. \n",
    "\n",
    "### 1. Printing\n",
    "\n",
    "Just like last time, click on this cell and type `b` (or click on `+ Code` in the upper lefthand corner of the screen if you are using Google Colaboratory) to insert a new code cell below. ([This page](https://towardsdatascience.com/jypyter-notebook-shortcuts-bf0101a98330) has more useful Jupyter shortcuts.) Then, type `print('Hello world!')` into the code cell and run it with `control/command + enter`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that `print` is a built-in Python **function**, and `'Hello world!'` is its **argument**. When this code is executed it prints out the **string** `'Hello world!'`. \n",
    "\n",
    "We can get more information about `print` using another built-in Python function called `help`. Try typing\n",
    "```\n",
    "help(print)\n",
    "```\n",
    "in a new code block below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's recall that we can print out all different types of data using `print`. Try running the example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The print function prints out all the arguments that you give it,\n",
    "# in the order that they appear. This works even if the arguments\n",
    "# aren't strings!\n",
    "\n",
    "print('zero', 1, 2.0, [3], True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data types\n",
    "\n",
    "Our first example printed out a **string**. Other basic data types in Python include **integers**, **floating-point numbers**, **arrays**, and **booleans** (true/false values) -- all shown in the example above! \n",
    "\n",
    "There's a built-in Python function called `type` that can tell you the format that a particular piece of data is stored as. \n",
    "\n",
    "Try creating a new code block below and running the following code:\n",
    "```\n",
    "print(type(2))\n",
    "print(type(1+1))\n",
    "print(type(2.))\n",
    "print(type(1+1.))\n",
    "print(type('type'))\n",
    "print(type([2]))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that adding an integer and a floating point number together converts the result into a floating point number, even if the float (1.) is also an integer.\n",
    "\n",
    "We can also use data types as functions to convert data from one type into another. Try running the code block below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting a floating point number into an integer\n",
    "# -- note that the number isn't rounded!\n",
    "\n",
    "print('Converting floats into ints...')\n",
    "print(int(2.1))\n",
    "print(int(2.9))\n",
    "print('')\n",
    "\n",
    "# And now converting an integer into a float\n",
    "\n",
    "print('Converting int into float...')\n",
    "print(float(2))\n",
    "print('')\n",
    "\n",
    "# We can also convert numbers into strings\n",
    "\n",
    "print('Converting int into string...')\n",
    "print(str(2))\n",
    "print('')\n",
    "\n",
    "# And (some) strings into numbers!\n",
    "\n",
    "print('Converting string into int...')\n",
    "print(int('2'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, not everything can be converted. For example, try executing the code block below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(int('two'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic operations\n",
    "\n",
    "Often, we're interested in using Python to do math. Let's try some examples. Type the expressions below into code blocks. What result do you expect in each case?\n",
    "- `2 + 2`  \n",
    "- `50 - 5*2`  \n",
    "- `(50 - 5)*2`  \n",
    "- `8 / 5`  \n",
    "- `3**2`  \n",
    "- `8 // 5`  \n",
    "- `8 % 5`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In summary, the basic mathematical operations in Python are\n",
    "- **addition** `+`  \n",
    "- **subtraction** `-`  \n",
    "- **multiplication** `*`  \n",
    "- **division** `/`  \n",
    "- **integer division** `//`  \n",
    "- **modulus** `%`  \n",
    "- **power** `**`  \n",
    "\n",
    "You can use parentheses to control the order of operations. Expressions in parentheses will always be evaluated first."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables\n",
    "\n",
    "Assigning and using variables is especially easy in Python because the type is automatically inferred from the value of the variable, and the variable type can be changed arbitrarily. \n",
    "\n",
    "To refresh this concept, try executing the following lines in code cells below, which will create and modify two variables `x` and `y`:\n",
    "- `x = 5`  \n",
    "- `x**2`  \n",
    "- `x = 7 + 0.1`  \n",
    "- `print(x)`  \n",
    "- `y = 0.2`  \n",
    "- `x + y`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remember that variables are persistent between code cells in Jupyter**! Once you define and use a variable, it will also be accessible in any other code cell. To get rid of a variable, you can use `del`.\n",
    "\n",
    "Try this with:\n",
    "- `del x`   \n",
    "- `print(x)`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "We can store multiple bits of data together in a `list` by using square brackets. To access different elements of the list, we use an **index** (starting at zero) combined with the name of the variable that stores the list. For example, `x[i]` refers to the $i$th element of the list `x`. To see this, try typing in and executing the following code:\n",
    "- `[0, 1, 2]`  \n",
    "- `x = [1, 2, 3]`  \n",
    "- `x[0]`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that:\n",
    "- We can access elements of a list from the **back** with negative indices  \n",
    "- If you try to access a list element that doesn't exist, Python will throw an error  \n",
    "\n",
    "To see examples, type the following lines into code blocks below:\n",
    "- `x[-1]`  \n",
    "- `x[4]`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, here are a few more useful ways that we can manipulate lists. Try each of these below.\n",
    "- Adding new elements to the list with `append`: \n",
    "    - `x.append(4)`  \n",
    "    - `print(x)`  \n",
    "- Checking the length of a list with `len`: `len(x)`  \n",
    "- Modifying specific elements in a list: `x[0] = 0`  \n",
    "- **Concatenating** two lists together (note that this is **not** vector addition): `x + x`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using libraries\n",
    "\n",
    "One of the things that makes Python so useful is the ability to import **libraries**, which are collections of functions and classes designed for a wide variety of computational problems. One of the libraries we talked about last time was `NumPy`, which (among many other uses) provides a data type called an **array** that can be used as a vector or a matrix.\n",
    "\n",
    "To use `NumPy` arrays, we first have to **import** the library. We can then use the functions and data types that are defined by `NumPy`. Let's execute the code block below for an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First, we'll import numpy using the special command `import`\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# When we import numpy \"as np\", that means that we can use the shortcut\n",
    "# \"np\" to access numpy functions and data types\n",
    "\n",
    "x = np.array([0, 1, 2])\n",
    "y = np.array([1, 2, 3])\n",
    "\n",
    "# numpy arrays behave like vectors!\n",
    "\n",
    "print('x =', x)\n",
    "print('y =', y)\n",
    "print('x + y =', x+y)\n",
    "print('x * y =', x*y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making plots\n",
    "\n",
    "Python libraries such as `matplotlib` and `seaborn` can be used to make plots and visualize different types of data. To see a very simple example, execute the code block below. This plots the displacement versus time of a falling object, which we used as an example during the first Python workshop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt  # import the matplotlib library\n",
    "import seaborn as sns            # and seaborn\n",
    "%matplotlib inline\n",
    "\n",
    "g = 9.8\n",
    "t = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n",
    "x = g * (t**2) / 2\n",
    "\n",
    "sns.lineplot(t, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many, many ways that the style of plots can be manipulated. We'll explore some of these at the end of the workshop today. To get a sense of the options available, execute the code block below, which describes options for the `lineplot` function in `seaborn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "help(sns.lineplot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before moving one, let's consider one more type of plot (see the `seaborn` [gallery](https://seaborn.pydata.org/examples/index.html) for many more examples). Run the code block below to create a **scatter plot**. Multiple plots can also be combined on the same figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.scatterplot(t, x)\n",
    "sns.lineplot(t, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "Last time, we created our own functions to help us perform integrals and solve differential equations. In general, functions are incredibly useful for all kinds of repetitive tasks.\n",
    "\n",
    "Recall that we can define our own function using the keyword `def`. To practice this, add a new code block below and type\n",
    "```\n",
    "def f(x):\n",
    "    return 3 * (x**2)\n",
    "\n",
    "y = f(1)\n",
    "print(y)\n",
    "```\n",
    "You can use `tab` to indent the second line. Make sure that the value of `y` is what you expect it to be!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Caution**: remember that variables are persistent in Jupyter notebooks. Variables used inside a function will be **local** ones if they are parameters of the function. However, if there are no local parameters that match the variable name then Python will look for **global** variables with the same name. This can easily cause confusion. To see an example, execute the code block below. Can you see why this happens?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "\n",
    "def f(y):\n",
    "    return 3 * (x**2)\n",
    "\n",
    "y = f(1)\n",
    "print(y)\n",
    "\n",
    "y = f(4)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For loops\n",
    "\n",
    "In programming, there are many times when we want to repeat many variations of the same process, or to repeat the same process many times. Some examples might include analyzing different sets of data, solving the same differential equation with different initial conditions, or making a series of plots. In such cases it's helpful to have methods to **iterate** through a list of items. The **for loop** is designed for this purpose.\n",
    "\n",
    "Let's recall what for loops do by typing in and executing the code below in a new code cell:\n",
    "```\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that `range(i)` is a function that makes a list of numbers from 0 to $i$. (To check this, try executing `print(list(range(10)))`.)\n",
    "\n",
    "For loops can be used for many purposes. For one more example, let's use a for loop to sum the integers from 0 to 9. To do this, execute the code block below. We're using `print` statements in each loop so that we can see exactly what is happening as the code executes.\n",
    "\n",
    "(Note: if you're unsure what the `\\t` values below mean, these are **escape characters** that insert a `tab`. Some more escape characters in Python can be found [here](http://python-ds.com/python-3-escape-sequences).)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "\n",
    "print('iteration (i)\\ttotal before add\\ttotal after add')\n",
    "for i in range(10):\n",
    "    print('%d\\t\\t%d\\t\\t\\t%d' % (i, total, total + i))\n",
    "    total = total + i\n",
    "\n",
    "print('')\n",
    "print('The sum of', list(range(10)), 'is', total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modular programming\n",
    "\n",
    "The goal of modular programming is to separate programming tasks into small components that can be freely interchanged to build more complicated functions. This framework can help to eliminate repetitive, unnecessary code, which is often a source of errors. Taking a modular perspective can also help to make complex tasks approachable by separating them out into smaller pieces that are easy to tackle. Last time, we used a modular approach to solve differential equations.\n",
    "\n",
    "Here, as a simple test let's write two very simple functions: one that adds two numbers together, and one that multiplies two numbers. Let's then use these (sub-)functions to define two operations:\n",
    "$$\n",
    "f(a, b, c, d) = (a + b) \\times (c + d), \\\\\n",
    "g(a, b, c, d) = (a \\times b) + (c \\times d)\\,.\n",
    "$$\n",
    "Note that we could do this just in terms of basic operations, but let's use this opportunity to practice modular programming!\n",
    "\n",
    "Fill in the code block below with your modular code and check to see if you get the expected answers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use this space to define your functions to add or multiply two variables\n",
    "\n",
    "def f(a, b, c, d):\n",
    "    # Use the functions you defined above!\n",
    "    \n",
    "\n",
    "def g(a, b, c, d):\n",
    "    # Use the functions you defined above!\n",
    "    \n",
    "\n",
    "print('f(1, 2, 3, 4) = %d (expected %d)' % (f(1, 2, 3, 4), 21))\n",
    "print('g(1, 2, 3, 4) = %d (expected %d)' % (g(1, 2, 3, 4), 13))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bonus assignment: Thinking about examples of great (and not so great) data visualization\n",
    "\n",
    "One of our most important jobs in research is to communicate our knowledge to others. In the latter half of the workshop today we'll talk about how we can do that effectively through figures.\n",
    "\n",
    "Of all the figures that you've seen in academic papers or in textbooks, can you think of some that did an especially good job of conveying information? What features did those figures have in common? Try to find an example figure from a textbook or paper that you find to be particularly clear and compelling.\n",
    "\n",
    "On the other hand, are there certain figures or visualizations that you've seen that are especially hard to understand? What features make those figures difficult to interpret? \n",
    "\n",
    "As much as possible, try to think about the **visual presentation** of the data rather than the complexity of the underlying topic. Even a great figure may be hard to interpret if we don't understand the topic area, and we'll probably still be able to puzzle out the meaning of a poor figure if we know the area well. We're more interested in design features that make it easier or more difficult to extract meaning from a visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}