LIS768_Lab2_2023.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 2: Jupyter Notebook and some Python conventions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is Jupyter Notebook?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter Notebook is a *literate computing environment*, which means that it is tool that allows you to write narrative and live code in the same place. \n",
    "\n",
    "Jupyter Notebook is a *browser-based application*, which means that it uses your computer's default browser for its interface, but it is installed locally on your computer. In other words, you're not working online. Some of the language used in the application might make it seem like your work is online somewhere ('download','logout'), but if you followed the installation instructions I provided, you're working only on your computer...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic features of Jupyter Notebook\n",
    "#### Notebooks\n",
    "In our context, the word \"notebook\" is used in two ways. First, it's part of the name of the software that we're using. Second, and more important for our purposes, it's the name of the file or document you create using the software. This document is a notebook. \n",
    "\n",
    "The file extension for Jupyter notebook documents is .ipynb. I know, it's long. And, I never say the letters in the right order. It's derived from an earlier name for this tool IPython (ipy) + the word notebook (nb). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cells\n",
    "\n",
    "Notebooks are made up of a series of cells, or blocks, in which you write your document. Cells can contain formatted text or live code. For our purposes, we need to know about 2 types of cell: *Markdown cells* (like this one) and *code cells*, like the one below. \n",
    "\n",
    "⭐ **Click on this cell (just once) and look for the change in the dropdown menu at the top of the screen. Do the same for the cell below.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This is a code cell. This Notebook is set for Python 3, so we can write Python here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating cells\n",
    "This notebook comes pre-loaded with a bunch of cells I've written up for you. But, before we get any further, I want you to practice creating cells and changing their type.\n",
    "\n",
    "**⭐ Let's create 2 new cells right here in the notebook.**\n",
    "- Step 1: Click on this cell--just once.\n",
    "- Step 2: Press the `+` button in the toolbar at the top of the screen.\n",
    "- Step 3: Change the dropdown setting to \"Markdown\".\n",
    "- Step 4: Type something, anything! You'll notice that the formatting is a little off--that's because you haven't *run* your cell yet. (If you want, press Shift + Enter or Shift + Return to run your cell).\n",
    "\n",
    "Now, let's make a new code block while we're here. Follow the same steps, but select \"Code\" from the dropdown. We won't write any code in there just yet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Running cells\n",
    "All cells in a Jupyter Notebook must be \"run\" before they'll do what they're designed to do. Markdown cells will be unformatted (like this one) until you run the cell. Running the cell will interpret the Markdown and display your formatting. Markdown cells default to a run state when the document is saved. So, you'll need to double click to see the Markdown formatting and the effect of running the cell.\n",
    "\n",
    "⭐ **Step 1: Double click on this cell, then click the Run button above OR press Shift + Return on your keyboard.**\n",
    "\n",
    "Running code cells does just that--it runs the code you've written in the cell. If you think of your code as a set of instructions for the computer to follow, writing a code cell is writing down those instructions. Running the code cell is telling your computer to do those things now.\n",
    "\n",
    "⭐ **Step 2: Run the code cell below.**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"You ran this cell!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you've run the cell above, you'll notice that a number appears inside the brackets. That number tells you the order the cells were run in. In other words, the first time a cell is run in the notebook, `In [ ]` becomes `In [1]`. Each time you run a cell, the value in the brackets will update. If the cell is still running, you'll see an asterisk instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The kernel \n",
    "Not this kind 🌽 of kernel. The *kernel* in a Jupyter notebook is what's called a \"computational engine\". It's the part of the notebook that actually runs the code. For our purposes, you don't need to know a ton about the kernel in order to work in Jupyter Notebook, but we'll cover a few things that tend to come up from time to time.\n",
    "\n",
    "#### The kernel uses memory\n",
    "Just like any other program you open, Jupyter notebook (the kernel specifically) uses memory. Sometimes it uses quite a lot. (Same goes for your browser). Closing and halting a notebook when you're finished with it frees that memory back up. We will practice this at the end of this session.\n",
    "\n",
    "#### Restarting the kernel\n",
    "Aside from closing the kernel, you may also need to restart it from time to time. If your notebook is frozen or doing weird things, you may need to restart. You can do that by clicking on \"Kernel\" in the top navigation bar and selecting one of the restart options:\n",
    "- **Restart:**\n",
    "Restarts the kernel and clears any variables that are stored in memory (more on that in a bit). Outputs from your code remain on the screen. So, you may not notice much change, but your variables are reset and any running code has been interrupted. \n",
    "- **Restart & Clear output:** Restarts the kernel, clears variables, AND clears the output from your code.\n",
    "- **Restart & Run all**: Restarts the kernel, clears the variables, and runs all the cells in the notebook in order.\n",
    "\n",
    "⭐ **Go ahead and restart the kernel all three methods--what do you notice?**\n",
    "\n",
    "#### Takeaways\n",
    "- 🗝️ The kernel makes the code work.\n",
    "- 🗝️ The kernel uses memory. \n",
    "- 🗝️ You must close and halt the notebook to free up the memory on your computer.\n",
    "- 🗝️ If the notebook is frozen or behaving weirdly, restarting the kernel might fix it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Guided lab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For today, most of our lab will be guided. I've broken the following sections up into slides with commentary and explanation. You are welcome to work ahead, if you prefer. \n",
    "\n",
    "**⭐ If you're following along, Each time you see a \"Try it!\" box on a slide, try running the cells and responding to the prompts (if any).**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Getting started\n",
    "We'll build toward an understanding of what each line in the following cells does. For now, run the first cell below and watch as it works through each line.\n",
    "\n",
    "##### 🔸 Line by line ######"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import sleep\n",
    "\n",
    "def firstFunction():\n",
    "    print(\"I'm the first function!\")\n",
    "    sleep(1)\n",
    "    print(\"While I print these things to the screen, the interpreter won't do anything else until I'm done.\")\n",
    "    sleep(1)\n",
    "    print(\"And now I'm done!\")\n",
    "    \n",
    "def secondFunction():\n",
    "    print(\"I'm the second function!\")\n",
    "    sleep(1)\n",
    "    print(\"I printed this to the screen. And now I'm done, too. The interpreter can move on.\")\n",
    "    \n",
    "firstFunction()\n",
    "sleep(2)\n",
    "print(\"\")\n",
    "secondFunction()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell above ran line by line. \n",
    "\n",
    "##### 🔸 Cell by cell #####\n",
    "In this environment, your code will also run one cell at a time. No matter what you do, it will not run another cell if one's already going. \n",
    "\n",
    "**⭐ Try to run the next couple of cells in order.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll probably have noticed a blank box under the name = input() cell. You may also have noticed that the empty brackets to the left of the cells you ran now contain an asterisk, like this `[*]`. That means that cell is waiting for input--your computer can't move on till you've given it something.\n",
    "\n",
    "⭐ Let's help it out! Type your name into the blank box above and hit Enter, wait for a number to appear in the brackets, then run the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hi, \" + name + \"! Look, I remembered you!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 🔸 Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statement = \"Megan is a morning person.\"\n",
    "#statement += \"..when she has to be.\"\n",
    "\n",
    "print(statement)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next cell, remove the # and run the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#statement += \"..when she has to be.\"\n",
    "\n",
    "print(statement)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Silly jokes aside, comments provide another tool for explaining your code to someone else (a friend, collaborator, teacher, *future you*...). \n",
    "\n",
    "Here's that chunk of code from earlier. It likely doesn't completely make sense (it shouldn't yet, but we'll get there). But the comments should make it a little easier to see piece by piece what's happening. It's a bit overly commented to make a point. You can run it again, if you like--it will do the same thing as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#In the line below, we're grabbing a bit of code from Python's standard library. \n",
    "from time import sleep\n",
    "\n",
    "#In this line, we're defining a function using the keyword \"def\"--defining a function is like writing a list of instructions.\n",
    "#Your computer won't *do* anything about them yet, but it will remember them for later.\n",
    "def firstFunction():\n",
    "    #The first instruction is to print a sentence to the screen.\n",
    "    print(\"I'm the first function!\")\n",
    "    #Now we're asking the computer to wait a second before doing the next thing.\n",
    "    sleep(1)\n",
    "    #Asking the computer to print another sentence\n",
    "    print(\"While I print these things to the screen, the interpreter won't do anything else until I'm done.\")\n",
    "    #Waiting one more second\n",
    "    sleep(1)\n",
    "    #And printing one last thing\n",
    "    print(\"And now I'm done!\")\n",
    "    \n",
    "#This is the start of a second function.    \n",
    "def secondFunction():\n",
    "    #Asking the computer to print to screen.\n",
    "    print(\"I'm the second function!\")\n",
    "    #Waiting another second\n",
    "    sleep(1)\n",
    "     #Asking the computer to print to screen.\n",
    "    print(\"I printed this to the screen. And now I'm done, too. The interpreter can move on.\")\n",
    "\n",
    "#In the line below, we will call the first function.\n",
    "#In other words, we're telling the computer follow the instructions we wrote above.\n",
    "firstFunction()\n",
    "#This one's familiar by now--we're asking the computer to pause for 2 seconds this time.\n",
    "sleep(2)\n",
    "#Here we're asking the computer to print a blank line, just to space the output a little nicer.\n",
    "print(\"\")\n",
    "#In this line, we're calling the second function we defined above.\n",
    "secondFunction()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 🔸 White space matters!\n",
    "\n",
    "Whitespace is used to indicate relationships between pieces of code. Run the boxes below to see what happens.\n",
    "\n",
    "This..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "if x == 1:\n",
    "    print(\"x equals 1\")\n",
    "else:\n",
    "    print(\"x doesn't equal 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...isn't the same as this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if x == 2:\n",
    "print(“x equals 1”)\n",
    "else:\n",
    "print(\"x doesn't equal 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, it throws an error because Python doesn't know what you're asking of it. It relies on indentation to indicate relationships between lines of your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 🔸 Punctuation matters, too!\n",
    "Some punctuation marks are treated as pairs--if you use one, you have to use both. If the interpreter sees a quotation mark, parenthesis, bracket, or brace, it will look around for a second one and won't do anything else if it can't find it. Put another way, if you \"open\" one of these sets, you have to \"close\" it with the other character in the pair. \n",
    "\n",
    "**⭐ Run the cell below to send your interpreter on a goose chase! 🦢**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Sorry, friend, you're gonna look for that closing quote for a minute...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The error message you got above, \"EOL while scanning string literal,\" is one you're likely to run into a lot. EOL stands for \"end of line\" and it means that the interpreter got to the end of your line of code and didn't see what it expected to see. In this case, it's a closing quotation mark. But, you'll see it if you forget to close other punctuation marks, or forget a colon where there should be one, or something else like that. It's a clue that the syntax in your code is off. \n",
    "\n",
    "**⭐ Let's give that interpreter some peace. Create a new cell below. Copy and paste the code above, add the missing quotation mark, and run it again.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 🔸 Escape characters\n",
    "\n",
    "If you're wondering about the slashes in the example above, those are the \"escape\" characters I mentioned. Quotes tell Python where a particular type of data (called a string) begins and ends. So, I needed to tell Python \"Hey, I'm using that quote in a different way!\" by including the slash. \n",
    "\n",
    "**⭐ Run the cell below to see the escape character do its thing!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"If you open any of these, you must close them: {},[],\\\", and \\'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**⭐ Run the next block to see what happens if I don't escape the quotes.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"If you open any of these, you must close them: {},[],\",'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Reflecting in/on Markdown\n",
    "\n",
    "For homework, I asked you to write Markdown file with little to no context. Today you've seen Markdown in action, in the context of a Jupyter Notebook.\n",
    "\n",
    "**⭐ Let's look at the Markdown you wrote for homework.**\n",
    "1. Create a new cell below. \n",
    "2. Set it to Markdown. \n",
    "3. Copy and paste everything from your readme.md file. \n",
    "4. Run your cell!\n",
    "5. Spend a few minutes adding to or editing your Markdown text, if you'd like."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have time, take a few moments to process what you've tried and learned so far.\n",
    "\n",
    "Is it similar to anything you were already familiar with? What do you think you might be able to do for your analytics project using this tool? Or, what do you want to know more about?\n",
    "\n",
    "**⭐ Create a new cell below. Set it to Markdown. Then, write up your thoughts. Use as much Markdown as you can!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EOL! \n",
    "(End of.... Lab...) Sorry, couldn't resist. When you're done, save your notebook and submit it to Canvas."
   ]
  }
 ],
 "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
}