NEU 171L Intro to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [NEU 171L] Introduction to Python\n",
    "\n",
    "*Estimated Time: 30 minutes*\n",
    "\n",
    "### Table of Contents:\n",
    "\n",
    "\n",
    "**Part I: Python**\n",
    " 1. [Data](#section_data)\n",
    " 2. [Expressions](#section_expr)\n",
    " 3. [Names](#section_names)\n",
    " 4. [Functions](#section_func)\n",
    " \n",
    "**Part II: Tables**\n",
    "1. [Sorting Dataframes](#section_sort)\n",
    "2. [Column / Row Selection](#section_filter)\n",
    "3. [Attributes](#section_attributes)\n",
    "\n",
    "**Part III: [Making Plots](#section_plots)**\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# The Jupyter  Notebook <a id='section_jupyter'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "Welcome to the Jupyter Notebook! `Notebooks` are documents that can contain text, code, visualizations, and more. \n",
    "\n",
    "A notebook is composed of rectangular sections called `cells`. There are 2 kinds of cells: markdown and code. A `markdown cell`, such as this one, contains text. A `code cell` contains code in Python, a programming language that we will be using for the remainder of this module. You can select any cell by clicking it once. After a cell is selected, you can navigate the notebook using the up and down arrow keys.\n",
    "\n",
    "To run a code cell once it's been selected:\n",
    "\n",
    "<ul>\n",
    "\n",
    "  <li>press Shift-Enter, or</li>\n",
    "  <li>click the Run button in the toolbar at the top of the screen.</li>\n",
    "\n",
    "</ul>  \n",
    "\n",
    "If a code cell is running, you will see an asterisk (\\*) appear in the square brackets to the left of the cell. Once the cell has finished running, a number will replace the asterisk and any output from the code will appear under the cell.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run this cell\n",
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "Code cells can be edited any time after they are highlighted. Try editing the next code cell to print your name.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# edit the code to print your name\n",
    "print(\"Hello: my name is Data Curriculum Staff\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving and Loading\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "Your notebook can record all of your text and code edits, as well as any graphs you generate or calculations you make. You can save the notebook in its current state by clicking Control-S, clicking the floppy disc icon in the toolbar at the top of the page, or by going to the File menu and selecting \"Save and Checkpoint\".\n",
    "\n",
    "The next time you open the notebook, it will look the same as when you last saved it.\n",
    "\n",
    "<br><br>\n",
    "<i><b>Note:</b></i> after loading a notebook you will see all the outputs (graphs, computations, etc) from your last session, but you won't be able to use any variables you assigned or functions you defined. You can get the functions and variables back by re-running the cells where they were defined- the easiest way is to highlight the cell where you left off work, then go to the Cell menu at the top of the screen and click \"Run all above\". You can also use this menu to run all cells in the notebook by clicking \"Run all\".</br></br>\n",
    "</div>\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "\n",
    "Before we begin, we'll need a few extra tools to conduct our analysis. Run the next cell to load some code packages that we'll use later.\n",
    "\n",
    "\n",
    "<br><br>\n",
    "<i><b>Note: </b></i>this cell MUST be run in order for most of the rest of the notebook to work.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dependencies: THIS CELL MUST BE RUN\n",
    "from datascience import *\n",
    "import numpy as np\n",
    "import math\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.style.use('fivethirtyeight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1. Python <a id='section_python'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "\n",
    "<code>Python</code> is  programming language- a way for us to communicate with the computer and give it instructions. \n",
    "\n",
    "Just like any language, Python has a <i>vocabulary</i> made up of words it can understand, and a <i>syntax</i> giving the rules for how to structure communication.\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Errors <a id=\"subsection error\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "\n",
    "<code>Python</code> is  programming language- a way for us to communicate with the computer and give it instructions. \n",
    "\n",
    "Just like any language, Python has a <i>vocabulary</i> made up of words it can understand, and a <i>syntax</i> giving the rules for how to structure communication.\n",
    "\n",
    "<p>Python is a language, and like natural human languages, it has rules. Whenever you write code, you will often accientally break some of these rules. When you run a code cell that doesn't follow every rule exactly, Python will produce an <code>error message</code>.</p>\n",
    "\n",
    "<p>Errors are <i>normal</i>; experienced programmers make many errors every day. Errors are also <i>not dangerous</i>; you will not break your computer by making an error (in fact, errors are a big part of how you learn a coding language). An error is nothing more than a message from the computer saying it doesn't understand you and asking you to rewrite your command.\n",
    "</p>\n",
    "\n",
    "<p>We have made an error in the next cell.  Run it and see what happens.\n",
    "</p>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"This line is missing something.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "The last line of the error output attempts to tell you what went wrong.  The <i>syntax</i> of a language is its structure, and this <code>SyntaxError</code> tells you that you have created an illegal structure.  \"<code>EOF</code>\" means \"end of file,\" so the message is saying Python expected you to write something more (in this case, a right parenthesis) before finishing the cell.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1.1: Data <a id='section_data'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "<b>Data:</b> is information- the \"stuff\" we manipulate to make and test hypotheses. \n",
    "\n",
    "Almost all data you will work with broadly falls into two types: numbers and text. <i>Numerical data</i> shows up green in code cells and can be positive, negative, or include a decimal.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numerical data\n",
    "\n",
    "4\n",
    "\n",
    "87623000983\n",
    "\n",
    "-667\n",
    "\n",
    "3.14159"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "Text data (also called <i>strings</i>) shows up red in code cells. Strings are enclosed in double or single quotes. Note that numbers can appear in strings.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Strings\n",
    "\"a\"\n",
    "\n",
    "\"Hi there!\"\n",
    "\n",
    "\"We hold these truths to be self-evident that all men are created equal.\"\n",
    "\n",
    "# this is a string, NOT numerical data\n",
    "\"3.14159\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \"> \n",
    "We can store different types of data into a container called an <code>array</code>. These arrays are contained within <code>[...]</code>. Set <code>my_array</code> to different types of data and run the cell.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_array = ...\n",
    "my_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1.2: Expressions <a id='section_expr'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "\n",
    "A bit of communication in Python is called an <code>expression</code>. It tells the computer what to do with the data we give it.\n",
    "\n",
    "<p>Here's an example of an expression.</p>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# an expression\n",
    "14 + 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; p</code>adding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "When you run the cell, the computer <code>evaluates</code> the expression and prints the result. Note that only the last line in a code cell will be printed, unless you explicitly tell the computer you want to print the result.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# more expressions. what gets printed and what doesn't?\n",
    "100 / 10\n",
    "\n",
    "print(4.3 + 10.98)\n",
    "\n",
    "33 - 9 * (40000 + 1)\n",
    "\n",
    "884"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "Many basic arithmetic operations are built in to Python, like multiplication <code> * </code>, addition <code> + </code>, subtraction <code> - </code>, and division <code> / </code>. There are many others, which you can find information about <a href=\"http://www.inferentialthinking.com/chapters/03/1/expressions.html\">here</a>.\n",
    "\n",
    "<p>The computer evaluates arithmetic according to the PEMDAS order of operations (just like you probably learned in middle school): anything in parentheses is done first, followed by exponents, then multiplication and division, and finally addition and subtraction.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# before you run this cell, can you say what it should print?\n",
    "4 - 2 * (1 + 6 / 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1.3: Names <a id='section_names'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "Sometimes, the values you work with can get cumbersome- maybe the expression that gives the value is very complicated, or maybe the value itself is long. In these cases it's useful to give the value a <i>name</i>.\n",
    "\n",
    "We can name values using what's called an <i>assignment</i> statement.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# assigns 442 to x\n",
    "x = 442"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "The assignment statement has three parts. On the left is the <i>name</i> (<code>x</code>). On the right is the <i>value</i> (442). The <i>equals sign</i> in the middle tells the computer to assign the value to the name.\n",
    "\n",
    "<p>You'll notice that when you run the cell with the assignment, it doesn't print anything. But, if we try to access <code>x</code> again in the future, it will have the value we assigned it.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print the value of x\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "You can also assign names to expressions. The computer will compute the expression and assign the name to the result of the computation.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 50 * 2 + 1\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "We can then use these name as if they were numbers.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x - 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1.4: Functions <a id='section_func'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "We've seen that values can have names (often called <code>variables</code>), but operations may also have names. A named operation is called a <code>function</code>. Python has some functions built into it.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a built-in function \n",
    "round"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "Functions get used in <i>call expressions</i>, where a function is named and given values to operate on inside a set of parentheses. The <code>round</code> function returns the number it was given, rounded to the nearest whole number.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a call expression using round\n",
    "round(1988.74699)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "        \n",
    "A function may also be called on more than one value (called <i>arguments</i>). For instance, the <b>min</b> function takes however many arguments you'd like and returns the smallest. Multiple arguments are separated by commas. (<i>max</i> works the same way, can you guess what it does?)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(9, -34, 0, 99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "Another example of this is the <code>sum</code> function. The diference of this function is that the items that you are summing must be in an <code>array</code> (mentioned in Part 1.1) and must all be numbers. In the cell below, set <code>my_other_array</code> to a list of numbers you'd like and then use <code>sum</code> to add them up. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_other_array = ...\n",
    "my_other_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum(my_other_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "\n",
    "<b>Practice:</b>\n",
    "<ul>\n",
    "  <li>The <code>abs</code> function takes one argument (just like <code>round</code>)</li>\n",
    "</ul> \n",
    "Try calling <code>abs</code> in the cell below. What does it do?\n",
    "\n",
    "Also try calling each function <i>incorrectly</i>, such as with the wrong number of arguments. What kinds of error messages do you see?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# replace the ... with calls to abs \n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Dot Notation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "        \n",
    "Python has a lot of <a href=\"https://docs.python.org/3/library/functions.html\">built-in functions</a> (that is, functions that are already named and defined in Python), but even more functions are stored in collections called <i>modules</i>. Earlier, we imported the <code>math</code> module so we could use it later. Once a module is imported, you can use its functions by typing the name of the module, then the name of the function you want from it, separated with a <code>.</code>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a call expression with the factorial function from the math module\n",
    "math.factorial(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Tables <a id='section_tables'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "The last section covered four basic concepts of python: data, expressions, names, and functions. In this next section, we'll see just how much we can do to examine and manipulate our data with only these minimal Python skills. We will be using data from the Allen Brain Mouse Connectivity Atlas.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "<code>Tables</code> are fundamental ways of organizing and displaying data. Run the next cell to load the data.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell\n",
    "primary_auditory = pd.read_csv('data/primary_auditory_area.csv')\n",
    "primary_auditory.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "        \n",
    "This DataFrame (or table) is organized into <code>columns</code>: one for each <i>category</i> of information collected:\n",
    "\n",
    "<p>You can also think about the table in terms of its <code>rows</code>. Each row represents all the information collected about a particular instance, which can be a person, location, action, or other unit. </p>\n",
    "\n",
    "<p>In the <code>primary_auditory</code> rows, the instance is a projection from one brain structure to another. The columns then encompass different characteristics of this projection.</p>\n",
    "\n",
    "<p>Using the function <code>.head()</code> give us only the first five rows by default. Can you see how many rows there are in total?</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Part 2.1: Sorting DataFrames <a id='section_sort'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Sorting values in a column using  `.sort_values`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "        \n",
    "The <code>.sort_values</code> function is used to sort the values in a column of a DataFrame. This function takes in two arguments, The <b>column label</b> <i>(in string form)</i> and <code>ascending</code> <i>(must equal True or False)</i>. In order to get values sorted from least to greatest, <code>ascending = True</code>. In order to get values sorted from greatest to least, <code>ascending = False</code>.\n",
    "\n",
    "<p>Let's sort the values in the column <code>projection_density</code> from <i>greatest to least</i> from the <code>primary_auditory</code> DataFrame.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primary_auditory.sort_values('projection_density', ascending = False).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "\n",
    "<b>Practice:</b>\n",
    "\n",
    "Try using <code>.sort_values</code> on <code>primary_auditory</code> in the cell below to arrange the volume from least to greatest. What is the <code>structure_id</code> of the experiment that had the least volume injected to it? If there is more than one with the same volume, just write down the top-most of the table. Assign this value to <code>least_volume</code>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "least_volume = ...\n",
    "least_volume"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Part 2.2: Column/Row Selection <a id='section_filter'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Selecting columns with `[ ... ]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "        \n",
    "The <b>[...]</b> is used to get a <code>Series</code> containing one column and an index. It takes in the name of a column in the form of a string.\n",
    "\n",
    "Let's select the <code>projection_density</code> from the <code>primary_auditory</code> DataFrame and assign it to <code>proj_density</code>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a new table with only selected columns\n",
    "proj_density = primary_auditory[...]\n",
    "proj_density"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Part 2.3: Attributes <a id='section_attributes'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "       \n",
    "Columns have <code>attributes</code> that give information about the them, like values contained within them. These attributes are accessed using the dot method. But, since an attribute doesn't perform an operation on the table, there are no parentheses (like there would be in a call expression).\n",
    "\n",
    "An attributes you'll use frequently is <code>values</code>, which will give us a list of the values in the column in the form of an <code>array</code> (mentioned in Part 1.1).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell\n",
    "proj_density.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "We can do several things with the values of the columns. Using the length function <code>len()</code>, we can find the number of values in our selected column. Run the cell below to see how many values are in <code>proj_density</code>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell\n",
    "len(proj_density.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "Something else we can do with this data is to obtain specific values. To obtain the first value, we use <code>proj_density[0]</code>. Since our data is organized from greatest to lowest values, this would give us the greatest projection density.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell\n",
    "proj_density.values[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 3: Making plots <a id='section_plots'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">  \n",
    "    \n",
    "### Step 1: 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": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "    \n",
    "### Step 2: 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": {},
   "outputs": [],
   "source": [
    "# \"plot\" is matploblib pyplot's basic plotting function\n",
    "# Below, we're asking it to make a line plot of 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": [
    "><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": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "\n",
    "### Step 3: Add some more data\n",
    "\n",
    "Let's create another random list and create a scatterplot of the data.\n",
    "\n",
    "><b>Task</b>: In the box below, create a list named <code>random_list_2</code> of the same length as your first list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "><b>Task</b>: In the box below, generate a scatterplot of your two lists. Hint: instead of using the command <code>plt.plot()</code> use <code>plt.scatter(...,...)</code> which graphs two variables. The x-axis variable goes first, then the y-axis variable. Since you are graphing random data, you can decide which list should be on the x-axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a scatter plot of your random data\n",
    "plt.scatter(...,...)\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": [
    "<div style=\"border-left: 3px solid #003262; padding: 1px; padding-left: 10px; background: #ffffff; \">\n",
    "\n",
    "### Step 4: Celebrate\n",
    "That's the Jupyter Notebook tutorial! You're ready to tackle more complex notebooks. "
   ]
  },
  {
   "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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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",
    "Parts 1 and 2 were developed by Elias Saravia & Daniel Lopez, students at UC Berkeley in the Data Science program.\n",
    "\n",
    "Part 3 was created by Ashley Juavinett for classes at UC San Diego."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}