J4A Notebook 1 - Jupyter Syntax and Other Things.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 0,
        "width": 4
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "Jupyter for Analysts - Notebook 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter syntax and other things"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 4,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<div class=\"row\">\n",
    "    <div class=\"col-md-5\"> \n",
    "    <br>\n",
    "    <br>\n",
    "    <br>What is a 'Jupyter notebook?' Good question! :)\n",
    "    <br>\n",
    "    <br>A Jupyter notebook is a place to share and use code to support your daily workflow or analyses needs. 'Running' a Jupyter notebook essentially means you are using the notebook to do some kind of analysis through code.\n",
    "    <br>\n",
    "    <br>So today.... you are officially going to 'run' this notebook! This notebook will explain some of the common Jupyter syntax you will hear as you use Jupyter notebooks, and show you simple examples with CODE (yes, CODE) in them!\n",
    "    <br>\n",
    "    <br> <b>Don't fret, you won't be touching any of the code here! :) </b>\n",
    "    </div>\n",
    "\n",
    "   <div class=\"col-md-7\">\n",
    "        <img src=\"J4A_Pics/jupyter_everywhere.jpg\">\n",
    "    </div>\n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 9,
        "hidden": false,
        "row": 12,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<h2> First Things First </h2>\n",
    "<p>How do I <b>'run'</b> this notebook?\n",
    "    <br>\n",
    "<br>Try this:\n",
    "<br> 1. Click on the code below: <b> print('welcome to a jupyter notebook!') </b>\n",
    "<br> 2. See the <b style='color:green'>GREEN </b> button above the code that says 'Run'? Click that!\n",
    "<br>\n",
    "    <img src='J4A_Pics/easy_button_run.png'>\n",
    "<br> Sometimes the green button does NOT show up. That's okay! If this is the case for you, follow these instructions:\n",
    "<br> - In the navigation bar, click the 'Run' button.\n",
    "    <img src=\"J4A_Pics/run_button.png\">\n",
    "<br>\n",
    "<br> It doesn't look like much, but you just ran a code 'cell' in a Jupyter notebook! \n",
    "<br>Can I be the first to say... WOOHOOO!!!!!!! :) \n",
    "    <hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Welcome to a Jupyter notebook!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 6,
        "hidden": false,
        "row": 21,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<h2> Now what? </h2>\n",
    "<p> How about you try running the <b>code</b> below!\n",
    "<br> 1. Click on the code\n",
    "<br> 2. Click that <b style='color:green'>green </b> 'Run' button again!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 16,
        "hidden": false,
        "row": 27,
        "width": 4
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import display,HTML \n",
    "print(\"You ran a cell filled with code!!\")\n",
    "HTML(\"\"\"<img alt=\"meme\" src=\"J4A_Pics/elf_you_did_it.png\">  \"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 5,
        "hidden": false,
        "row": 43,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<br> So far you can run these things called 'cells' in Jupyter notebooks. Lets dive into some more Jupyter syntax so you can understand the rest of the class better!\n",
    "<p>You will learn what a 'cell' is, what certain types of cells are, and some common Jupyter *things* you will run into while working through a Jupyter notebook!</p>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 4,
        "height": 4,
        "hidden": false,
        "row": 0,
        "width": 4
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<b>Notebook Syntax. What Jupyter notebook 'slang' do I need to know?</b>\n",
    "<p>Let's move on to some common Jupyter terminology you might hear (and some I already threw at you... like hellllo what is 'running the code' again?! Before you know it, you'll be talking just like a Jupyter-ite ;)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 8,
        "height": 4,
        "hidden": false,
        "row": 0,
        "width": 4
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<hr>\n",
    "<h3 style='color:#e65c00'> <strong> Cell </strong></h3>\n",
    "<br>\n",
    "A <strong> cell </strong> is a block of code or text. Jupyter notebooks are made up of cells! This gives coders and users an easier way to work through code and see results step by step.\n",
    "<br>\n",
    "<br>Because you work through a notebook cell by cell, you have to 'activate' each cell before you run it. (PS: You have already been 'activating' cells!) A cell is activated with you see a blue or a green bar along the left side of the cell. The picture below shows and actived cell with a blue bar. Simply put, activating a cell just shows you which cell you are 'in' so that you can run that cell and not another cell. Blue bars indicate that there is not code in the cell, and green bars mean there is code!\n",
    "<br>\n",
    "<img src=\"J4A_Pics/blue_bar.png\">\n",
    "<br>\n",
    "<br> There are two types of cells that you will see when using a Jupyter notebook: a <strong> markdown </strong> cell and a <strong> code </strong> cell. \n",
    "<br>\n",
    "<br> A <b>markdown cell</b> holds text (like the cell this paragraph is in), and a <b>code cell</b> holds code (like the code you ran to produce that funny panda picture!)\n",
    "<br>\n",
    "<br>You can tell which type of 'cell' you are in by looking at the navigation bar at the top of this screen. In the navigation bar there is a dropdown menu. <b>Markdown</b> will display if the cell you clicked in (activated) is a markdown cell. <b> Code </b> will display if the cell you activated has code inside of it.\n",
    "<img src=\"J4A_Pics/code_cell.png\">\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 4,
        "hidden": false,
        "row": 8,
        "width": 4
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<hr>\n",
    "<h3 style='color:#e65c00'> <strong> \"Run a cell\" </strong></h3>\n",
    "<br>\n",
    "Well, you are a pro at this by now! The term <strong> 'running a cell' </strong> simply means computing all the stuff in the cell.\n",
    "<br>\n",
    "<br> By now you know about two ways to 'Run' a cell. There is one other way to run a cell:\n",
    "<br> - In the menu, go to Cell > Run Cells. Try it yourself!\n",
    "<img src=\"J4A_Pics/run_cells.png\">\n",
    "<br>\n",
    "<br><b> Extra Extra! </b> In order to run a cell AND move to the next cell at the same time, press <strong>Shift + Enter</strong>. To run a cell and stay in that cell without moving to the next, press <strong>Ctrl + Enter</strong>. Try it and see for yourself! :) \n",
    "<br>\n",
    "<br>In order to move to a previous cell in the notebook, you need to click in the cell and run it as you normally would or use the up arrow.\n",
    "<br>\n",
    "<br> If you got the <b> extra extra </b>, you are realllllly beginning to act like a Jupyter-ite ;) \n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "hidden": true
       },
       "report_default": {
        "hidden": true
       }
      }
     }
    }
   },
   "source": [
    "<hr>\n",
    "<h3 style='color:#e65c00'> <strong> Is my cell running, or is it done running? </strong></h3>\n",
    "<br>\n",
    "Markdown cells do not actually compute anything because it is just text inside of them.\n",
    "<br>\n",
    "<br>A code cell does compute code. A code cell is running if there is <strong> In [ * ]: </strong> on the left side of the cell in the white space. If there is no asterisk like this <strong> In [ ]: </strong> then the cell has not been run. If there is a number inside the brackets, like <strong> In [12]: </strong> for example, then the cell has been run. This number is just a one-up number from the previous cell you ran.\n",
    "<br>\n",
    "<br>Here is an example of a code cell before it has been run:\n",
    "<img src='J4A_Pics/not_ran.png'>\n",
    "<br>Here is an example of a code cell that is still running:\n",
    "<img src='J4A_Pics/running_cell.png'>\n",
    "<br>Here is an example of a code cell that has already been run:\n",
    "<img src='J4A_Pics/ran_cell.png'>\n",
    "<br>\n",
    "<br> At he end of this lesson, you will have an exercise to run a cell of code. This code may take a little longer to run. This will give you a chance to see the empty brackets, the asterisk in the brackets while it's computing, and then the number in the brackets once it has computed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 17,
        "hidden": false,
        "row": 48,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<hr>\n",
    "<h3 style='color:#e65c00'> <strong> What about 'run all'? </strong></h3>\n",
    "<br>If you do not want to run a notebook cell by cell, that is OK (depending on the notebook)! There are a couple of options to run a notebook all at once: \n",
    "<br>\n",
    "<br> 1. In the nagivation bar, find Cell > Run All.\n",
    "<img src=\"J4A_Pics/run_all.png\">\n",
    "<br> 2. Click on a cell, and instead of the 'Run' button, click <b> 'Run All' </b>\n",
    "<img src=\"J4A_Pics/easy_button_runAll.png\">\n",
    "<br>\n",
    "<br>\n",
    "All of the cells in the notebook will run when you use one of the above options, so you do not have to go cell by cell!\n",
    "<h4> <i> Why wouldn't I 'Run All' for every notebook? </i> </h4>\n",
    "<br> Well,  one code of cell could do one thing for your data, and another cell could do another thing for your data. Some cells may ask you for input along the way in order to run the next cell. In the end, it really depends on the type of notebook you are using and how the data is being worked through.\n",
    "<br>\n",
    "<br> Go ahead and try to run this notebook again by hitting <b>'Run All'</b> by one of the ways we talked about before.\n",
    "<br>\n",
    "<br> PS: You can run a cell AGAIN after it has been run! :) So even though you are hitting 'Run All', feel free to continue to run this notebook cell by cell! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 13,
        "hidden": false,
        "row": 65,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<hr>\n",
    "<h3 style='color:#e65c00'> <strong> Comments </strong></h3>\n",
    "<br>\n",
    "Comments are a way to read and understand code easier. They are added to code to help explain what code does to other coders. Comments are not *computed* by the code. In other words, the computer/code does not compute a comment. It is merely there for humans to understand code better!\n",
    "<br>\n",
    "<br>\n",
    "<b> I thought we weren't reading code? </b> ---> You aren't! You are reading something <b>in</b> the code, but it is not code. Comments are meant for you to understand notebooks and code better. Sometimes developers of the notebooks you will use will not have a large paragraph explaining what the code does in a notebook. Instead, they will use comments to tell you. So, it is very important you know how to find and read comments for your workflows and analyses. \n",
    "<br>\n",
    "<br>\n",
    "In Python, comments are marked with # before them in a <strong>code</strong> cell, not a markdown cell. The way a comment is made is dependent on the language the notebook is in.\n",
    "<br>\n",
    "<br>\n",
    "This notebook uses Python so it uses a #. In the code below, you will see the text is faded and italicized. <strong>The faded and italicized text denotes a comment in EVERY language in Jupyter notebooks. So, it's easy for you to always know what pieces of a cell are a comment by what the text looks like!</strong> Not all comments are marked with a #. Other languages use varying symbols to mark the beginning/end of a comment.\n",
    "<br>\n",
    "<img src=\"J4A_Pics/comments.png\">\n",
    "<br>\n",
    "<br> Run the code below. You'll notice that the very *untrue* comment did not print, while the other print statement did.\n",
    "<br> <i> **Again, you don't have to understand what the code is doing here. Just note the difference between <strong>code</strong> and a <strong>comment</strong>!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 4,
        "height": 4,
        "hidden": false,
        "row": 8,
        "width": 4
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "outputs": [],
   "source": [
    "# print('Jupyter is so totally not cool')\n",
    "print('Jupyter notebooks are so cool!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 5,
        "hidden": false,
        "row": 78,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<hr>\n",
    "<h3 style='color:#e65c00'> <strong> Output </strong></h3>\n",
    "<br>\n",
    "A lot of the information you will utilize comes from the output from a cell. Run the code below. What happens? Can you spot the output?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = x + 2\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 5,
        "hidden": false,
        "row": 83,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "The output is the number 7, below the block of code. On the left side of the code, you can see the <b> Out[ ]: </b> for 'Output' with a number between the brackets. \n",
    "<br>\n",
    "<img src=\"J4A_Pics/output.png\">\n",
    "<br>\n",
    "<br> Output is what the code produces. In markdown cells, there is no output because there is no code. Nothing is acutally executed/computed. When there is code in cells executed, Jupyter produces output from that code for you!\n",
    "<br>\n",
    "<br> Please note: <b>NOT ALL CODE CELLS PRODUCE OUTPUT.</b> Sometimes cells of code don't *show* that they produced anything... but they probably did *something* to help the code in the next cell! So, if nothing is produced and you have no errors, just move on to the next cell :)\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 1: Run that cell!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 11,
        "hidden": false,
        "row": 88,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<br>The code below produces a simple graph. The data for the graph is also in the code. Can you spot the variables <i>x_data</i> and <i>y_data</i>? Both of those are set equal to a list of numbers (the data to produce the graph!).\n",
    "<br>\n",
    "<br>If you found them, you just read some code!!! ... just sayin :)\n",
    "<br>\n",
    "<br>When you spot <i>x_data</i> and <i>y_data</i>, go ahead and run the code! Can you spot the <b> asterisk [ * ] </b> on the left hand side of the cell?\n",
    "<br>\n",
    "<br><u> Two notes:</u>\n",
    "<br> 1. <i> Do NOT worry about the code below.</i> You do not have to understand it in anyway in order to produce the graph :)\n",
    "<br> 2. Sometimes it takes awhile for the code to run! <strong>Wait</strong> until you see the graph to run any more cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "##below is code, but it is also the data for the scatter plot\n",
    "x_data = [5, 7, 6, 4, 3, 1, 8, 9, 1, 3]                       # x-values for the graph\n",
    "y_data = [10, 15, 89, 67, 119, 93, 101, 120, 59, 20]          # y-values for your graph\n",
    "\n",
    "# code below creates the scatter plot\n",
    "plt.scatter( x_data,                                # x values ...\n",
    "             y_data )                               # ...and y values!\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 5,
        "hidden": false,
        "row": 99,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "Cool graph, right? Again, don't worry about the code you saw to produce the graph! This class is not about understanding the code at all!\n",
    "<br>\n",
    "<br> Take note that once the graph was produced, the <b> asterisk </b> was replaced with a number! This number indicates the order you ran code cells in. This is imporant if a cell further down in the notebook is run, but needed a previous cell to run first. To avoid this, run the cells in order - top to bottom! :)\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {
        "col": 0,
        "height": 6,
        "hidden": false,
        "row": 104,
        "width": 12
       },
       "report_default": {
        "hidden": false
       }
      }
     }
    }
   },
   "source": [
    "<div class='alert alert-block alert-info' align='center'>\n",
    "<br>Congratulations! You ran your first Jupyter notebook! :)\n",
    "<br>You can now talk like all those Jupyter-ites out there!\n",
    "<br>\n",
    "<br> 'Hey, you running that <strong>cell</strong> of code?'\n",
    "<br> 'Dude, you have to wait for that <strong>cell</strong> to finish running first. Don't you see the <strong>asterisk</strong>?'\n",
    "<br> 'Check out those nicely written <strong>comments</strong>!!!'\n",
    "<br>\n",
    "<br>Ok I'm done. But really, you are ready to move on to <a href=\"J4A Notebook 2 - Data Analysis.ipynb\"> Notebook 2 </a>  in the Jupyter for Analyst notebook series!\n",
    "<br>\n",
    "<br>\n",
    "<br> <a href='Jupyter 4 Analysts (J4A).ipynb'>Jupyter for Analysts Homepage</a>\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "extensions": {
   "jupyter_dashboards": {
    "activeView": "report_default",
    "version": 1,
    "views": {
     "grid_default": {
      "cellMargin": 10,
      "defaultCellHeight": 20,
      "maxColumns": 12,
      "name": "grid",
      "type": "grid"
     },
     "report_default": {
      "name": "report",
      "type": "report"
     }
    }
   }
  },
  "gallery": {
   "commit": "8d0d6eca-a11c-4cdc-bb15-718f1c9b2497",
   "filename": null,
   "git_commit_id": "25f65d4706ff335de9f212e7479bfc1a4258f18f",
   "link": "3622c2f6-85c4-4f12-8c5b-cd43b501d1b2",
   "staging_id": "191deff0-43ab-4671-b371-4ab1c002e9aa",
   "uuid": "3622c2f6-85c4-4f12-8c5b-cd43b501d1b2"
  },
  "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.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}