Lab 1 - Introduction to Python and Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lab 1: Introduction to Python and Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Math in Python\n",
    "\n",
    "Computers were originally invented to do complicated math computations, and we can also do computations in Python.\n",
    "\n",
    "Try running the code below.  There are three ways to run code, and you can use whichever you prefer:\n",
    "1. Clicking on the arrow to the very left of the cell (this arrow will only appear when your mouse is near it).\n",
    "2. Click on the cell, and then click the Run button (an arrow head facing a vertical line) in the menu at the top. \n",
    "3. Click on the cell, and then press control + enter simultaneously.  (If you have just been typing in the cell, you don't need to click on it first.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "3 + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is the answer what you expect?  \n",
    "\n",
    "What do you think the * symbol does?  Try running the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\* is used for multiplication.  The addition (+), subtraction (-), and division (/) symbols are the usual ones. \n",
    "\n",
    "What is 216 divided by 8?  Write the code to compute this below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Variables\n",
    "\n",
    "A *variable* is a label or nickname that can be used to access something (a number, text, a link to a file, etc.) in the computer's memory.  A variable in programming work similarly to variable in math, but it can store or represent more than just numbers. \n",
    "\n",
    "To store the value 16 in the variable `x`, type `x = 16` below and run the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We say we *assign* the value 16 to the variable `x`.  To see what value is stored in (assigned to) the variable `x`, type `x` below and run the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now use the variable `x`, for example, in a math equation.  Run the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x/4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is the answer what you expected?  \n",
    "\n",
    "Notice that the value of `x` does not change:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to save the result of `x/4`, we need to assign it to a new variable, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "answer = x/4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like nothing happened, but try displaying the value in `answer` below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Functions\n",
    "\n",
    "What does the following code do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "x\n",
    "answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It only displays the value in the variable `answer`, because Jupyter notebook only displays the value of the last line of the cell.  To display the values of both `x` and `answer`, we need to use the function `print()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(x)\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *function* is a command that tells the computer to perform a specific action.  For example, the `print()` function tells the computer to display whatever in inside the parentheses on the screen.\n",
    "\n",
    "All functions (commands) are followed by parentheses, and additional information for the computer (called *parameters*) is put inside the parentheses.  In the example above, `x` and `answer` are the parameters.\n",
    "\n",
    "We can also display a word or phrase (called a *string*) instead of a variable.  Try running the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(\"Hello!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we used quotes to show that the phrase isn't a variable, and should be displayed exactly.  What do you expect to happen when you run the following code?  After making a guess, try it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(\"x\")\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try printing a variable that we haven't assigned (given) a value.  Type `print(y)` below and run the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get an error!  The last line `NameError: name 'y' is not defined` is the most important, and tells us that we have not defined a variable `y`.\n",
    "\n",
    "Can you define `y` to be 100 below?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should have typed `y=100` and ran the code.  We can check defined the variable by either typing `print(y)` or simply `y`.  Try both below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 Packages\n",
    "\n",
    "A package in Python is analogous to an app for a smartphone, in that the package adds new functionality to Python, just like an app adds new functionality to a smartphone.  Just like you need to open an app each time you want to use it, we need to import a package each time we want to use it.\n",
    "\n",
    "To import the Matplotlib package, type `import matplotlib.pyplot as plt` below and run the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like nothing happened, but we can now use functions from the Matplotlib package.\n",
    "\n",
    "To import the Pandas package, type `import pandas as pd` below and run the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like nothing happened, but we can now use Pandas functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 Plotting: line plots\n",
    "\n",
    "Now we are going to make a *line plot* of the historical population of New York city and its five boroughs. \n",
    "\n",
    "### 1.5.1 Uploading files to Jupyter Hub\n",
    "\n",
    "First we want to upload our data file to Jupyter Hub.  Download the file `nycHistPop.csv` from Blackboard, noting which directory it is saved in.  Then click on the web brower tab \"Home\", which shows your files in Jupyter Hub.  Upload `nycHistPop.csv` by clicking the Upload button on the top left.  Once the file is uploaded, return to this page."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5.2 Comma Separated Value (CSV) files\n",
    "\n",
    "Open the file `nycHistPop.csv` using TextEditor (Mac) or Notepad (Windows).  What do you notice about the file?\n",
    "\n",
    "A *comma separated value (CSV)* file store data from a table as a text file. Each row in the file corresponds to a row in the table, and the column values are separated by commas, which explains the name. \n",
    "\n",
    "### 1.5.3 Dataframes\n",
    "\n",
    "We will next tell Python to open the file `nycHistPop.csv` and store it as a *dataframe* in the variable `pop`.  A *dataframe* is a similar to a table in Excel.  Each column corresponds to some statistical variable (ex. year, Manhattan population, Bronx population) and each row corresponds to an observation or piece of data (ex. the populations in each borough in a specific year).\n",
    "\n",
    "To create the dataframe, type:\n",
    "`pop = pd.read_csv(\"nycHistPop.csv\",skiprows = 5)` \n",
    "below and run the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happened?\n",
    "\n",
    "Even though it looks like nothing happened, we have defined a variable `pop` that should contain the contents of `nycHistPop.csv`.  To see this, type `pop` below and run the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happened?  \n",
    "\n",
    "The variable `pop` now contains all the rows of `nycHistPop.csv` (except the first 5, which we skipped with the parameter `skiprows=5`).  Also, all the data is arranged in a table, called a *dataframe*.\n",
    "\n",
    "How many people lived in the Bronx in 1800?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5.4 Line plots\n",
    "\n",
    "To plot the data, type `pop.plot(x = “Year”)` and run the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which borough currently has the largest population?  Which borough had the largest population in 1900?\n",
    "\n",
    "#### Challenges\n",
    "* What happens if you leave off the `x = \"Year\"` ? Why?\n",
    "* What happens if you use the parameters `x = \"Year\", y = \"Bronx\"` ?\n",
    "* What percentage of the total New York population in 1898 was in Manhattan?  Do any calculations in the Jupyter notebook.\n",
    "\n",
    "You can create as many code cells as you need by clicking on *Insert* in the menu, and then selecting *Insert Cell Below*. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}