lecture-1-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 1-1: The basics\n",
    "\n",
    "The file you're currently looking at is a **Jupyter notebook**. It contains a mixture of text, formatted using a language called [Markdown](https://en.wikipedia.org/wiki/Markdown), and blocks of Python code. We won't talk much about Markdown today, but it's very useful for formatting text. You can even use $\\LaTeX$ to write equations!\n",
    "\n",
    "### Printing\n",
    "\n",
    "To get started with Python, **let's learn by doing**. 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 handy 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": [
    "`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",
    "Here's another basic exercise. Add a new code block below, then type\n",
    "```\n",
    "# print(1)\n",
    "print('two', 2) # 2\n",
    "print(3)\n",
    "```\n",
    "and execute the code block. Make sure to type in the `#` characters exactly as above!"
   ]
  },
  {
   "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": [
    "What happened? As you can see, nothing that comes after a `#` character is evaluated. These parts of the code are **commented out**. You can use comments to explain what your code is doing, like 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 and basic operations\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",
    "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`  "
   ]
  },
  {
   "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": [
    "Some of the numbers above are integers, and some are floats. Generally, you won't have to keep track of which is which -- Python automatically converts between types as needed. But what if we want to do integer division? Try:\n",
    "\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": [
    "### Defining and using variables\n",
    "\n",
    "In Python, you don't need to specify the type of a variable when it's created. The type is automatically inferred from the value of the variable. You can also change the type of a variable arbitrarily. \n",
    "\n",
    "Let's give this a try with:\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": [
    "Notice 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",
    "Let's try:\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": [
    "# Example exercise: falling object\n",
    "\n",
    "An object dropped from rest accelerates toward the earth at $g = 9.8\\,m/s^2$. The distance that the object travels as a function of time is then $x = \\frac{1}{2} g t^2$. \n",
    "\n",
    "Imagine that we know the height of a building, which we store in a variable `h`. In the code block below, write some code to print out the time that it will take for an object to hit the ground when it is dropped from rest from a building of height `h`.\n",
    "\n",
    "If an object is dropped from a building that is $125\\,m$ tall, how long does it take to hit the ground?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": [
    "### Collections of variables\n",
    "\n",
    "We can store multiple bits of data together in a `list`. Check out:\n",
    "- `[0, 1, 2]`  \n",
    "- `x = [1, 2, 3]`  \n",
    "- `x[0]`  \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": [
    "These examples show us that:\n",
    "- Python lists are indexed from 0, not 1  \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",
    "Let's consider a few more ways that we can manipulate lists:\n",
    "- `x.append(4)`  \n",
    "- `print(x)`  \n",
    "- `len(x)`  \n",
    "- `x[0] = 0`\n",
    "- `x + x`  \n",
    "- `x = x[-1]`  "
   ]
  },
  {
   "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",
    "The above example shows that Python lists **don't** behave like vectors: when we add two lists, they are just concatenated. \n",
    "\n",
    "Fortunately, we can use a library called `NumPy` to define **arrays**, which can behave like vectors or matrices. This is very useful for computation! \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": [
    "### Visualizing data\n",
    "\n",
    "Python also has popular libraries for visualizing data. Two examples are `matplotlib` and `seaborn`.\n",
    "\n",
    "Let's use `seaborn` to plot distance versus time for a falling object. ~First, we'll need to \"install\" `seaborn` into the notebook, because it is not loaded by default on Google Colaboratory.~ Colaboratory has been updated, so `seaborn` should be installed by default!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install seaborn --upgrade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline               # this tells Jupyter to display plots\n",
    "import seaborn as sns            # now we import the seaborn library\n",
    "import matplotlib.pyplot as plt  # and the matplotlib library\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": [
    "For the example above, note that the `NumPy` array `t` is being treated as a **vector**. So, when we write `x = g * (t**2) / 2`, this squares the elements of `t`, multiplies each element by `g / 2`, and assigns the result to the variable `x`!\n",
    "\n",
    "This plot is fine, but it's not very descriptive. Let's add labels to the plot to make it easier to interpret."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.lineplot(t, x, label='$x(t)$')\n",
    "plt.xlabel('time, ' + '$t$')\n",
    "plt.ylabel('distance, ' + '$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 other types of plots that we can make. The `seaborn` [gallery](https://seaborn.pydata.org/examples/index.html) has a lot of examples. \n",
    "\n",
    "For the moment, let's consider one more type: 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, label='$x(t)$')\n",
    "#sns.lineplot(t, x)\n",
    "plt.xlabel('time, ' + '$t$')\n",
    "plt.ylabel('distance, ' + '$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"
   ]
  }
 ],
 "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
}