week03/Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "developing-design",
   "metadata": {},
   "source": [
    "# Welcome to A Very Quick Tour of Jupyter\n",
    "\n",
    "First, congratulations!  You've successfully navigated to a Jupyter Notebook and opened it. Jupyter is a convenient and productive way to **keep notes and code together**. Think of it as being like a regular old paper Lab Notebook, except this notebook can have runable code in it that can be **run directly from the notebook**.\n",
    "\n",
    "Notice that a notebook is made up of a series of cells that start at the top and go down. In a sense, it's laid out a bit like a one-column spreadsheet.\n",
    "\n",
    "Let's start our very first explorations in Jupyter, beginning in the next cell. It may not be obvious yet that it's a cell, but soon that will change. For now, just keep reading."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aquatic-passport",
   "metadata": {},
   "source": [
    "## The cannonical \"Hello World\" example\n",
    "\n",
    "There isn't actually any law that requires the first programming example in a language to be the \"Hello World\" program, but it sure feels that way.\n",
    "\n",
    "Anyway, writing a program that just prints out \"Hello World\" is really easy in Python. It's just one line of code: call the \"print\" function with an argument that has the string \"Hello, World\" in it. That line runs and the words are printed on the screen. Super simple. Look in the next cell down to see this one line \"program\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "senior-birthday",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "linear-belief",
   "metadata": {},
   "source": [
    "Look at the line above. That's our print statement and its one argument. Over a little bit to the left of it we see, in dark blue, the word \"In\" and a pair of brackets. \"In\" tells us that we're looking at the input part of a cell - the place where we can type stuff. The brackets don't have anything in them, but that will change soon.\n",
    "\n",
    "Let's run that line of code. Looking at the cell, we see the print statement. Click on that print statement so the blinking cursor is in that cell. Now go to the \"Cell\" menu and select \"Run Cells\". We only selected the one cell, so it'll only run that one.\n",
    "\n",
    "Did you see that?  Our Jupyter Notebook just ran that line of Python! The output from the print function appears right below the input part of the cell. The words \"Hello World\" appeared.\n",
    "\n",
    "Granted, Hello World is a pretty unspectacular piece of code, but at least the Computer Programming Introduction Cops won't arrest me now. Let's do something slightly more interesting now. Take a look at the next cell. Then scroll down to the cell after that, where it says \"Basics of running a cell\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "worldwide-depression",
   "metadata": {},
   "outputs": [],
   "source": [
    "drink_can_ounces = 12\n",
    "total_milliliters = drink_can_ounces * 29.5735\n",
    "print(total_milliliters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "potential-terrace",
   "metadata": {},
   "source": [
    "## Basics of Running a Cell\n",
    "\n",
    "Let's run the cell right above and see how many milliliters of soda water are in the twelve-ounce can I'm looking at. Click in that cell, and then this time press and hold the Shift key down and hit Enter. We'll call this \"Shift+Enter\" for convenience.\n",
    "\n",
    "A couple of things happened. First, the code executed. A variable was set equal to 12, then it was multiplied by 29.5735 to convert those ounces to milliliters. Finally, the last line prints out the results of that conversion.\n",
    "The second thing that happened was more subtle. Look at the dark blue text to the left of it, where it says \"In\" and has the brackets. Inside those brackets there is now a number (probably a \"2\", but the important part is that there's a number).\n",
    "\n",
    "Make a mental note what that number is.\n",
    "\n",
    "Click on that cell again and hit Shift+Enter once more. The contents of that cell runs once more and it prints out 354.882 again. And this time, the blue number in brackets off to the left went up by one.\n",
    "\n",
    "Jupyter keeps track of the total number of times any of the cells in a notebook have run. When a cell is run (also called \"executed\"), the total execution count goes up by one and is printed inside that cell's brackets.\n",
    "\n",
    "Why is this important? One of the handy things about Jupyter is that you can runs cells in any order, not just top-to-bottom. By looking at the numbers in brackets, you can tell what order the cells were run in. This can be handy when you're jumping around."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "packed-seating",
   "metadata": {},
   "source": [
    "## Kinds of Cells\n",
    "\n",
    "By now you may have noticed two distinct kinds of cells in a notebook. Cells like this one with text in them are called \"Markdown\" cells. Cells with code in them are called \"Code\" cells. There are other kinds of cells (we added an extension that lets us put video in a cell, for instance) but Code and Markdown are the two you'll practically always use.\n",
    "\n",
    "In the Ancient Times, when the earth's crust was still cooling and publications were printed on paper, an editor would go through a manuscript, fix any errors, and then put in some little marks and notes for the typesetter. These symbols would tell the person doing the typesetting that some of this text should be in bold, and some of this in italics, and would maybe have a scribbled note saying to indent the following paragraph differently. The process of the editor making all these notations was called \"marking up\" the manuscript.\n",
    "\n",
    "Once we started using computers for this kind of thing, the term \"marking up\" was shortened to \"markup\", and dozens of different \"markup languages\" were invented that would be embedded into text files. These \"markup files\" were then processed (\"run off\") and the processed result could be printed.\n",
    "\n",
    "It's hard to overstate how nice this was, compared to typewriters and typesetting machines anyway.\n",
    "\n",
    "You're probably familiar with at least one markup language - Hypertext Markup Language, aka \"HTML\". This is a language that expresses how web pages are laid out.\n",
    "\n",
    "Jupyter uses another markup language, and this one is called Markdown. Other things use Markdown, also. Reddit supports Markdown (alongside what they call the \"Fancy Pants Editor\") and github uses \"github flavored Markdown\".\n",
    "\n",
    "Did you notice how this cell has a heading that says \"Kinds of Cells\" and that it's in a larger font than the rest of it?  When I typed that line, I started it with a pair of \"#\" symbols... like this:\n",
    "\n",
    "```\n",
    "## Kinds of Cells\n",
    "```\n",
    "\n",
    "When you \"run\" a cell that has Markdown text in it, Jupyter processes the Markdown instructions in it and produces nicely-formatted output.\n",
    "\n",
    "Let's do that for ourselves!\n",
    "\n",
    "Click somewhere in this cell to make it the \"current\" cell that we're working with. Now add a new cell right below here. On the \"Insert\" menu select \"Insert Cell Below\" and, a lot like a spreadsheet, it will create a new cell for us right below this one.  Newly created cells default to being Code cells. Let's change that new one to a Markdown cell. Go to the Cell menu, look in the \"Cell Type\" submenu, and select \"Markdown\". Jupyter now knows the cell will contain Markdown-formatted text instead of executable code.\n",
    "\n",
    "In that new cell, enter the following Markdown text:\n",
    "\n",
    "```\n",
    "# This is a Level 1 Heading\n",
    "\n",
    "## This is a Level 2 heading.\n",
    "\n",
    "This sentence has a **bold** word and an _italicized_ one.\n",
    "```\n",
    "\n",
    "It's important to have a space between the \"#\" symbols and the first word of your heading.\n",
    "\n",
    "As you enter text and Markdown commands, Jupyter will give you sort of a \"preview\" of what to expect. Once you're done entering the text, hit Shift+Enter.  Presto!  That Markdown text has been neatly formatted and looks rather nice.\n",
    "\n",
    "And a note to scientists and mathematicians: LaTeX is another markup language. Markdown is a much, much simpler one. If you need to, there are converters to take Markdown and turn it into LaTeX. You can copy Markdown right out of your Jupyter notebook, convert it, and paste it into your journal articles.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "rotary-fluid",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "happy-second",
   "metadata": {},
   "source": [
    "Writing code in a cell is just as easy as Markdown text. Make this the current cell (click on it) and add another cell below this one. It will default to being a code cell. Add the following code:\n",
    "\n",
    "```\n",
    "x = 4\n",
    "y = 6\n",
    "z = 2*x + y\n",
    "print(z)\n",
    "```\n",
    "\n",
    "When you have that typed in, hit Shift+Enter to execute it. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beneficial-summer",
   "metadata": {},
   "source": [
    "Running that code will cause it to print \"14\".\n",
    "\n",
    "## Next Steps\n",
    "\n",
    "Good job! You've learned how to open Jupyter notebooks, how to run code that's contained in them, and how to add your own Code and Markdown cells. You're well on your way to being a proficient and productive Jupyter user.  Coming up, we'll look at some more Jupyter features that you'll need to do your daily work with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "international-premises",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}