hist3368-week2-intro-to-jupyter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For citation information, please see the \"Source Information\" section listed in the associated README file: https://github.com/stephbuon/digital-history/tree/master/hist3368-week1-intro-to-jupyter"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hist 3368 - Intro to Jupyter Notebook and Python Crash Course\n",
    "\n",
    "*Based off tutorials by [Lauren Klein](https://github.com/laurenfklein/emory-qtm340/tree/master/notebooks), [Alison Parish](https://github.com/aparrish/dmep-python-intro) and [Jinho Choi](https://github.com/emory-courses/data-science)*\n",
    "\n",
    "Jupyter Notebook is a browser-based platform for programming in Python, which allows you to intersperse executable code with chunks of text like this. It lets you (mostly) avoid the command line, and results in a file that is easy to read and easy to share with others. \n",
    "\n",
    "We'll be using Jupyter Notebooks for in-class exercises and for many of the homework assignments. \n",
    "\n",
    "#### Here we go! \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is a Cell?\n",
    "\n",
    "A Jupyter Notebook consists of a number of \"cells,\" stacked on the page from top to bottom. \n",
    "\n",
    "Cells can have text or code in them.   The text cells are called \"Markdown.\"  The cells with code are called \"Code.\"  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run a Cell\n",
    "\n",
    "\n",
    "Jupyter comes with several commands for \"running\" a cell, or sending its contents as instructions to the super computer.\n",
    "\n",
    "First, you must 'select' a cell:\n",
    "\n",
    "* Click on the cell \n",
    "* or use your arrow keys to position your cursor inside the cell.\n",
    "\n",
    "To \"run\" a cell: \n",
    "\n",
    "* Click the `PLAY` icon in the menu bar directly above, or:\n",
    "* From the top menu, choose `RUN` > `Run Selected Cell`\n",
    "* `Ctrl+Enter` runs the current cell\n",
    "* `Alt+Enter` runs the current cell and then creates a new cell\n",
    "* `Shift+Enter` runs the current cell and moves your cursor to the following cell.\n",
    "\n",
    "Try all of the above commands on this cell and the cell below until you feel comfortable with how they work.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "137216.00572603307"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "135983 + 298387.3857 / 242"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Editing a Cell\n",
    "\n",
    "To edit a cell, click anywhere on the cell.  Next, hit 'Enter' or 'Return'.  `Enter` will start editing whichever cell is currently selected.   \n",
    "\n",
    "Try clicking on this cell. \n",
    "\n",
    "To quit editing a cell, hit `Esc`.  Use :) to make a row of smiley-faces at the bottom of this cell.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Change a Cell's Type\n",
    "\n",
    "\n",
    "You can change a cell's type using the \"Cell\" menu at the top of the page:\n",
    "\n",
    "* Click on this cell to select it.\n",
    "* At the menu at the top of this page, you will see the word 'Markdown.'  Pull down this menu.  \n",
    "* Select `Code` for Python code or `Markdown` for text."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "## Your first cell\n",
    "\n",
    "**Let's make a text cell!**\n",
    "\n",
    "To make a new text cell below this one, do this:\n",
    "* Choose `+` from the menu at the top of this page (not the JupyterLab webpage, but the page for hist3368-week1). \n",
    "* In the blank\n",
    "* Use the menu at the top of this page where it says 'Code' to change the *type* of the cell you just made to `Markdown`\n",
    "* Type some stuff and press `Ctrl+Enter` (or `Ctrl+Return` on some keyboards) \n",
    "\n",
    "Jupyter Notebook will \"render\" the text and display it on the page in rendered format. You can hit `Enter` or click in the cell to edit its contents again. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keyboard shortcuts\n",
    "\n",
    "Very often, you will want to add a cell without using your mouse.  Keyboard shortcuts are a way of speeding up the process of writing code.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "After clicking on any cell or moving your cursor there with the arrow keys, hit `Esc` to access the keyboard shortcuts.  \n",
    "\n",
    "* `m` converts the selected cell to a Markdown cell\n",
    "* `b` inserts a new cell below the selected one\n",
    "* `x` \"cuts\" the selected cell; `v` pastes a previously cut cell below the selected cell\n",
    "* `h` brings up a help screen with many more shortcuts.\n",
    "* `dd` deletes the cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try it:\n",
    "\n",
    "* Create an empty cell below this one.  \n",
    "\n",
    "* Next, write in the cell this command: *print('hello world')*  .  \"Run\" the cell (using shift+enter/return).\n",
    "\n",
    "* Add another cell above that one.  Type your name.   \"Run\" the cell (using shift+enter/return).\n",
    "\n",
    "* Next, convert the cell with your name to markdown.   \"Run\" the cell (using shift+enter/return).\n",
    "\n",
    "* Next, delete the cell with your name.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Format your Markdown\n",
    "\n",
    "You can format the text of a cell using a set of conventions called Markdown. Markdown is a simple language for marking up text with basic text formatting information (such as bold, italics, hyperlinks, tables, etc.). \n",
    "\n",
    "Use asterisks (*) around a word to make text **bold**.\n",
    "\n",
    "Use underlines (_) around a word to make text _italic_.\n",
    "\n",
    "Use one asterisk and space (* ) to create a bullet-pointed list.\n",
    "\n",
    "Use hashtags and a space (## ) at the beginning of the line to turn text into a header.\n",
    "\n",
    "[Here is a Markdown tutorial](http://markdowntutorial.com/), although I prefer to just consult a cheat sheet like [this one](https://www.markdownguide.org/cheat-sheet/).\n",
    "\n",
    "Try it!  \n",
    "\n",
    "* Create an empty cell below this one using `Esc+b`\n",
    "* Write the first line of your favorite song\n",
    "* Make one word bold\n",
    "* Make one word italic\n",
    "* Use four hashtags to turn it into a minor heading "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Make a text cell with some formatting using Markdown\n",
    "\n",
    "Here is your first exercise. Insert a new cell just below this one, and use the [Markdown cheat sheet](https://www.markdownguide.org/cheat-sheet/) to make some text **bold**, some text *italics*, and some:\n",
    "\n",
    "- text\n",
    "- in\n",
    "- a \n",
    "- list\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code cells\n",
    "\n",
    "Code cells-- which are actually the default type of cell in Jupyter-- use the same set of commands (`Ctl-Enter`, `Alt-Enter`, `Shift-Enter`, etc) to run chunks of Python code rather than just render text.\n",
    "\n",
    "Let's not beat around the bush! Click on the cell just below, and then press `Shift-Enter` to run your first chunk of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a code cell.\n",
      "\n",
      "Any Python code you type in this cell will be run when you press the 'Run' button\n",
      "up there, or when you press any of the keyboard shortcuts you just learned.\n",
      "\n",
      "If the code evaluates to something, or if it produces output, that output will be\n",
      "shown beneath the cell after you run it.\n",
      "\n",
      "Let's keep on going. Press Shift-Enter to see what this cell produces and keep going\n",
      "with our exercise.\n"
     ]
    }
   ],
   "source": [
    "print(\"This is a code cell.\")\n",
    "print(\"\")\n",
    "print(\"Any Python code you type in this cell will be run when you press the 'Run' button\")\n",
    "print(\"up there, or when you press any of the keyboard shortcuts you just learned.\")\n",
    "print(\"\")\n",
    "print(\"If the code evaluates to something, or if it produces output, that output will be\")\n",
    "print(\"shown beneath the cell after you run it.\")\n",
    "print(\"\")\n",
    "print(\"Let's keep on going. Press Shift-Enter to see what this cell produces and keep going\")\n",
    "print(\"with our exercise.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sidenote: You just learned how the print function works in Python 3!**\n",
    "\n",
    "[Obligatory meme](https://twitter.com/cszhu/status/1163476712044150790)\n",
    "\n",
    "[Here](https://docs.python.org/3.3/whatsnew/3.0.html) are a few more examples of how to print things. \n",
    "\n",
    "[Here](https://realpython.com/python-print/) is more about `print()` than you likely ever wanted to know."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Meeting Python\n",
    "\n",
    "Jupyter is the coding environment.  Python is the language.\n",
    "\n",
    "Today, we will meet four important parts of the Python language:\n",
    "    \n",
    "    * Errors\n",
    "    * Warnings\n",
    "    * Variables\n",
    "    * Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "In general, I'll introduce concepts as we encounter them.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Errors \n",
    "\n",
    "If your code generates an error, it will be displayed in addition to any output already produced. \n",
    "\n",
    "Let's commit a cardinal sin: dividing by zero.\n",
    "\n",
    "Run the cells below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is some printing.\n",
      "And now here is an error:\n"
     ]
    },
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-42-4f26b3ef7434>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"And now here is an error:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;36m1\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "print(\"Here is some printing.\")\n",
    "print(\"And now here is an error:\")\n",
    "\n",
    "1 / 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should have learned in grade-school math that you cannot divide one by zero.  Python is perplexed as to why you would even try!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-43-d2b1ab3bcadd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m:\u001b[0m    \u001b[0;31m# this will not work!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "for i in 10:    # this will not work!\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, we use a \"for\" loop to call the numbers from zero to 10.  Here's the issue: Python knows how to repeat a command using the \"for\" conditional.  But it doesn't know where to start counting.  \n",
    "\n",
    "A slight tweak to the code will make it work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 10):\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in this class, we don't require you to memorize all the rules of Python grammar that will allow you to write the code accurately without looking something up.  But we do want you to learn the skills required for dealing with errors.\n",
    "\n",
    "If you encountered the error above, you would be well served to :\n",
    "* notice the pink Error code, \"TypeError,\" in the pink ticket above\n",
    "* follow the green error in the error ticket above, which suggest that the problem is with the line \"for i in 10\"\n",
    "\n",
    "From there, you can usually google the specific line that's causing the trouble and come up with a better solution.  \n",
    "\n",
    "Right now, try googling \"python for i in 10\".  What does Google tell you?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Warnings\n",
    "\n",
    "Many times when you see pink, what you are looking at is not an error but a \"warning.\"  Warnings have many sources; they can be generated to flag you when you're using old software that needs to be updated.  However, the code will usually run even with warnings.  \n",
    "\n",
    "If you get a pink ticket, you should read it.  Is it an error, or a warning?\n",
    "\n",
    "If it's a warning, what is the computer trying to tell you?  Does it want you to update something?  Will it stop the code from working if you ignore it?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "One of the most important parts of code is the \"variable.\" Variables are like sticky lables that can be peeled off one container and stuck on another.  When we want the contents of the container, all we have to do is look for the nametag that we assigned.  You can move the labels around many times.  Python will remember the last line of code that assigned the variable to an object.\n",
    "\n",
    "In Python, you use `=` to assign variables. \n",
    "\n",
    "Let's assign some variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"armadillo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "armadillo\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = \"armadillo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "armadillo\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that for a word -- a 'string' in Python -- we wrapped the word in quotation marks (\"\") to tell Python to treat it as an object, not as a command."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens when we don't wrap a word in quotation marks before assigning a variable?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'humperdink' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-100-2977c7800d84>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhumperdink\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'humperdink' is not defined"
     ]
    }
   ],
   "source": [
    "x = humperdink"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are just labels for an all-purpose container.  \n",
    "\n",
    "You can put anything inside the container.  Any variable can contain not just strings or numbers, but also \"lists\" of strings and numbers.  \n",
    "\n",
    "In Python, you make a list by wrapping the contents in square brackets ([])."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [\"armadillo\", \"faucet\", \"hamburger\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = [5, 3, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['armadillo', 'faucet', 'hamburger'] [5, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also move the labels around after assigning them once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variable names can be absolutely anything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "armadillo = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(armadillo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "gadzooks = 249812.34934"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "249811.34934"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gadzooks - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "marilyn_monroe = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_favorite_animal_is_a_llama = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "this_is_the_right_answer = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(this_is_the_right_answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"hot sauce\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hot sauce\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we've stored variables, we can do things with them in the code cells that follow.  \n",
    "\n",
    "For instance, we can use built-in functions, like the mathematical operator '+', or built-in ordering devices, like 'not', which gives the opposite of a boolean variable like True or False.\n",
    "\n",
    "What is happening in each item?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [2.5, 5, 20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.5, 5, 20]\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = True "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"hot sauce\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = \"armadillo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hot saucearmadillo\n"
     ]
    }
   ],
   "source": [
    "print (x+y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Order matters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, notice that Python doesn't think linearly about the Jupyter app.  If you \"run\" a line out of sequence, Jupyter doesn't care which line is in what order.  \n",
    "\n",
    "* Use shift+return or shift+enter to \"run\" the line above where we assign x to the value \"True.\"  \n",
    "* Next, skip to the next line of markup and run the line of code that begins, \"if x:\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "y = .5\n",
    "z = True # note another difference b/t R and Python: Boolean (T/F) values are not all caps "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then run the next line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you did it!\n"
     ]
    }
   ],
   "source": [
    "if x:\n",
    "    print(\"you did it!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Run the line above.  Does it give you a word of encouragement?\n",
    "\n",
    "If nothing happened, read the instructions above carefully and try again.  \n",
    "\n",
    "The order in which you run lines of code matters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Any variables you define or modules you import in one code cell will be available in subsequent code cells. \n",
    "\n",
    "A function is any command that tells Python what to do with an object, for instance a variable.\n",
    "\n",
    "Here is a very basic function: \n",
    "\n",
    "    print()\n",
    "   \n",
    "What do you think it does? \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i am a function for printing strings of text\n"
     ]
    }
   ],
   "source": [
    "print('i am a function for printing strings of text')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Will 'print' also work with other kinds of variables?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.5, 5, 20]\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**: Tell the computer to print the phrase, '*hello world*.'  Remember that strings require quotation marks.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Figuring out what a new function does"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Throughout this course, we will be meeting new functions that are specifically designed to do things that are useful for working with text.  You will have to figure out how to use the new functions.\n",
    "\n",
    "For instance, in the lines below, can you spot the new function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "elephant\n"
     ]
    }
   ],
   "source": [
    "import random  # we're importing some extra software here\n",
    "stuff = [\"cheddar\", \"daguerrotype\", \"elephant\", \"flea market\"]\n",
    "\n",
    "print(random.choice(stuff))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**: figure out what the function 'random.choice()' works.  Run the line below several times. Do you always get the same answer?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "elephant\n"
     ]
    }
   ],
   "source": [
    "print(random.choice(stuff)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Write some code and then run it\n",
    "\n",
    "Using the previous two code cells as a guide...\n",
    "- Reassign the \"stuff\" variable with four different words\n",
    "- Use the \"choice\" function, as above, to randomly print one of those four words "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A bit more basic maintenance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving your work\n",
    "\n",
    "Hit `Cmd-S` at any time to save your notebook. Jupyter Notebook also automatically saves occasionally. \n",
    "\n",
    "Notebooks you save will be available on your local server whenever you log in again, from wherever you saved them. \n",
    "\n",
    "You can also \"download\" your notebook in various formats via `File > Download as`. You can download your notebook as a static HTML file (for, e.g., uploading to a web site), or as a `.ipynb` file, which you can share with other people who have Jupyter Notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Permissions Digression\n",
    "\n",
    "Do you have permission to access our class folder on M2? Load a file from our folder to find out: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['You have permission!\\n']\n"
     ]
    }
   ],
   "source": [
    "with open('/scratch/group/history/hist_3368-jguldi/permissions_check.txt') as f:\n",
    "    print([line for line in f])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you don't have permission, please email Richard England directly to let him know. His email is: rengland at smu dot edu."
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}