Introduction to Jupyter Notebooks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Jupyter Notebooks\n",
    "\n",
    "This first notebook will introduce you using Jupyter Notebooks, a handy coding environment for learning as well as sharing code with others.\n",
    "\n",
    "### At the end of this notebook, you'll be able to:\n",
    "* Recognize the main features of Jupyter Notebooks\n",
    "* Use Jupyter Notebooks to run Python3 Code\n",
    "* Identify and edit simple Markdown code\n",
    "\n",
    "### Table of Contents\n",
    "1. [Part I. About Jupyter Notebooks](#one)\n",
    "2. [Part II. Using Markdown](#markdown)\n",
    "3. [Part III. Python Syntax](#python)\n",
    "4. [Part IV. Generate some plots](#plots)\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"one\"></a>\n",
    "## Part I. About Jupyter Notebooks\n",
    "\n",
    "\n",
    "Jupyter notebooks are a way to combine executable code, code outputs, and text into one connected file. They run in a web browser, but don't require the internet (unless you're running it on a Jupyter Hub). \n",
    "\n",
    "The <b>'kernel'</b> is the thing that executes your code. It is what connects the notebook (as you see it) with the part of your computer, or the DataHub computers, that runs code.\n",
    "\n",
    "### Menu Options & Shortcuts\n",
    "To get a quick tour of the Jupyter user-interface, click on the 'Help' menu, then click 'User Interface Tour'. There are also a large number of useful keyboard shortcuts. Click on the 'Help' menu, and then 'Keyboard Shortcuts' to see a list.\n",
    "\n",
    "\n",
    "### Types of Cells\n",
    "Jupyter Notebooks have two types of cells, a <b>Markdown</b> (like this one) and <b>Code</b>. Most of the time you won't need to run the Markdown cells, just read through them. However, when we get to a code cell, you need to tell Jupyter to run the lines of code that it contains.\n",
    "\n",
    "Code cells will be read by the Python interpreter. In other words, the Python kernel will run whatever it recognizes as code within the cell.\n",
    "\n",
    "<span style=\"color:blue\">When you're in <b>Command mode</b>, cells are outlined in blue</span>. <span style=\"color:green\">When you're in <b>Edit mode</b>, blocks are outlined in green</span>.\n",
    "\n",
    "><b>Task:</b> Run the cell below!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# In Python, anything with a \"#\" in front of it is code annotation,\n",
    "# and is not read by the computer.\n",
    "# You can run a cell (this box) by pressing shift-enter.\n",
    "# Click in this cell and then press shift and enter simultaneously.\n",
    "# This print function below allows us to generate a message.\n",
    "print('Nice work!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"markdown\"></a>\n",
    "## Part II. Using Markdown\n",
    "Markdown is useful because it can be formatted using simple symbols. [Here's a full cheatsheet of markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) for more tips, but the main syntax is below:\n",
    "* You can create bulleted lists using asterisks.\n",
    "* Similarly, you can create numbered lists using numbers.\n",
    "* You can **bold** with two asterisks or underscores on either side (`**bold**`) or *italicize* with one asterisk or underscore (`*italicize*`)\n",
    "* Pound signs (#) create headers. More pound signs means a smaller header.\n",
    "\n",
    "><b>Task:</b> Edit the markdown cell below with a quick biography of yourself. You should have your name as a big header, a short quippy subtitle for yourself as a smaller header, and a three bullet points that use both <b>bold</b> and <i>italic</i>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Edit this markdown cell!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"python\"></a>\n",
    "## Part III: Basic Python Syntax\n",
    "\n",
    "Like any language, Python follows a set of rules, known as the language **syntax**. Below, we'll see how to write expressions in Python, create variables, and then manipulate those variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Expressions\n",
    "\n",
    "We can perform various arithmetic operations in Python:\n",
    "\n",
    "| Symbol |    Operation   | Usage |\n",
    "|:------:|:--------------:|:-----:|\n",
    "|    +   |    Addition    |  10+2 |\n",
    "|    -   |   Subtraction  |  10-2 |\n",
    "|    *   | Multiplication |  10*2 |\n",
    "|    /   |    Division    |  10/2 |\n",
    "|   **   |    Exponent    | 10**2 |\n",
    "| %      |    Modulo      |  10%2 |\n",
    "\n",
    "Notes:\n",
    "* The default order of operations is the same as in mathematics! (PEMDAS)\n",
    "* If you want a whole number from your division, use // instead"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "><b>Task:</b> Try each of the operators above. Before using the modulo operator, predict what it will output, and make sure it produces what you expect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's play with numbers weee\n",
    "8*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "Variables enable us to store a value and come back to it later. They are defined with `name = value`. *Assignment is not the same thing as equality,* as in mathematics.\n",
    "\n",
    "### Assigning variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "><b>Task:</b> Create two variables: <code>a</code> & <code>b</code>. Then, use an expression that combines <code>a</code> and <code>b</code>, and assign this to <code>c</code>. In the end, <code>c</code> should be equal to <b>6</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's save a few integers and then manipulate them.\n",
    "a = \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note</b>: Most code cells will not give you an output unless you ask for it. You can use `print( )` to output a variable or string. However, cells that *only* contain one variable will print its value.\n",
    "\n",
    "Usefully, you can run your cells out of order. This is useful for testing and debugging.\n",
    "\n",
    "><b>Task</b>: Change your equation for <code>c</code> above and then use <code>print(c)</code> to check its value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types of Variables\n",
    "Variables can be different types. Python lets you change the type of variables (the function is in parentheses below), however, *you cannot combine types*.\n",
    "\n",
    "* Integers (`int`) \n",
    "* String (`str`): letters, numbers, symbols, spaces\n",
    "* Float (`float`): any number with a decimal point (floating point number)\n",
    "\n",
    "You can check what type your variable is by using `type(variable)`.\n",
    "\n",
    "<b>Note</b>: If you ever need help using a function (e.g., `type`) in Jupyter Notebook, you can enter the function followed by a question mark or `help(function)`. For example, `type?` or `help(type)`. You can also check <a href=\"https://www.geeksforgeeks.org/python-type-function/\">the documentation</a>.\n",
    "\n",
    "<b>Hint:</b> Jupyter will only show you the output of the last line of code that you run. Thankfully, you can wrap commands in other commands. For example, we could write `print(type(a))`, if we want to see the output of `type(a)`.\n",
    "\n",
    "><b>Task:</b> In the cell below, check the type of your variable <code>c</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the type of c here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different operators in Python will produce different types of variables. \n",
    "\n",
    "><b>Task:</b> Compare the results of 12/2 and 12//2 by assigning the results of these operations to two different variables. Then, use the <code>int</code> and <code>float</code> functions to transform these variables into an integer and a float called: <code>result_int</code> and <code>result_float</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"plots\"></a>\n",
    "## Part IV: Generate a few plots\n",
    "\n",
    "### Step 1. Import packages \n",
    "We can take advantage of pre-packaged code for many common functions in Python. But first, we need to tell Python to import it. This is a really common step for most Python code. \n",
    "\n",
    "><b>Task</b>: Make sure our needed packages are installed in our coding environment by running the code below. If packages are needed, they'll be installed for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will ensure that Numpy and Matplotlib are installed.\n",
    "try:\n",
    "    import numpy\n",
    "    print('numpy already installed')\n",
    "except ImportError as e:\n",
    "    !pip install numpy\n",
    "try:\n",
    "    import matplotlib\n",
    "    print('matplotlib already installed')\n",
    "except ImportError as e:\n",
    "    !pip install matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we'll import a package called \"numpy\" and nickname it \"np\" and \"matplotlib.pyplot\" and nickname it \"plt.\"\n",
    "\n",
    "><b>Task:</b> Add <code>as np</code> after <code>import numpy</code> to instruct Python to import the numpy package but nickname it np. When you see <code>np</code> in our script, it's actually calling scripts from the numpy package.\n",
    "\n",
    "After you import it, Python will print a message. Having printed messages like these is a really nice way to check that your cell actually ran."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add your code here\n",
    "import numpy \n",
    "import matplotlib.pyplot as plt\n",
    "print('Imported packages')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: Create some random data to plot\n",
    "We'll use a function \"random.rand\" to create a random list of numbers. You decide on how long this list of numbers should be (anything between 5 to 100 is fine) by adding a value next to \"list_length\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Replace the ... to assign your chosen value to list_length below.\n",
    "list_length = ...\n",
    "\n",
    "random_list = np.random.rand(list_length,1) # Create a vector that is list_length long\n",
    "\n",
    "print('Created a random list')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "><b>Task</b>: Let's make sure Python did what we wanted it to do -- save our random list as a variable called <code>random_list</code>. Check by typing the variable name into the next cell, and running it. If that worked, you should see an array of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3: Plot your data\n",
    "Let's pretend this is data from an awesome experiment we ran. We need to plot the data. Remember that we imported <code>matplotlib.pyplot</code> as <code>plt</code>. We can now use the `plt.plot()` function to plot our random list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# \"plot\" is matploblib pyplot's basic plotting function\n",
    "# Below, we're asking it to plot the random_list we just created\n",
    "plt.plot(random_list)\n",
    "\n",
    "# this is where you can add additional changes to your plot\n",
    "\n",
    "# plt.show() will show our plot below this code cell\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "><b>Tasks:</b>\n",
    "> 1. Add axes to your plots by adding <code>plt.xlabel('yourxlabelhere')</code> and <code>plt.ylabel('yourylabel')</code>. Add those above <i>before</i> <code>plt.show()</code>.\n",
    "> 2. Add some markers to your line! Do this by adding an additional argument to <code>plt.plot(random_list)</code>, so that it says <code>plt.plot(random_list, marker =\"o\")</code>. <a href=\"https://matplotlib.org/api/markers_api.html\">You can add various markers of your choosing!</a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4: Add some more data\n",
    "\n",
    "Let's create another list based on our first list, and then create a scatterplot of the data.\n",
    "\n",
    "><b>Task</b>: In the box below, create a list named <code>random_list_2</code> that is a list where each value is **equal to all of the values in your first list times two**. You can do this with the same operators as above. For example, if we wanted to divide all of the values in `random_list`, we would use `random_list/2`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "><b>Task</b>: In the box below, make a scatterplot of your data using the matplotlib's scatter function. You should plot `random_list` on the x axis, and `random_list_2` on the y axis. Be sure to label your axes as well. You can find documentation on the scatter function <a href=\"https://matplotlib.org/api/_as_gen/matplotlib.pyplot.scatter.html\">here</a> or <a href=\"https://matplotlib.org/gallery/lines_bars_and_markers/scatter_symbol.html#sphx-glr-gallery-lines-bars-and-markers-scatter-symbol-py\">here (for more fun)</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 5: Celebrate\n",
    "That's the Jupyter Notebook tutorial! You're ready to tackle more complex notebooks. Close this window to go back to your Jupyter Notebook landing page."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import HTML\n",
    "HTML('<img src=\"https://media.tenor.com/images/99cff34bdcb675975b2b0cc661f2e4ce/tenor.gif\">')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resources\n",
    "For additional Jupyter Notebook information and practice, see [this tutorial](https://www.dataquest.io/blog/jupyter-notebook-tutorial/) from DataQuest. \n",
    "\n",
    "## About this Notebook\n",
    "This notebook was created by [Ashley Juavinett](https://github.com/ajuavinett) for classes at UC San Diego."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}