0_jupyter_notebook_helloworld.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hello World!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Jupyter Notebooks](#Jupyter-Notebooks)\n",
    "    - [The Kernel](#The-Kernel)\n",
    "    - [Cells](#Cells)\n",
    "    - [Cell Execution](#Cell-Execution)\n",
    "    - [Basic Markdown Syntax](#Basic-Markdown-Syntax)\n",
    "        - [Headers](#Headers)\n",
    "        - [Emphasis](#Emphasis)\n",
    "        - [Ordered Lists](#Ordered-Lists)\n",
    "        - [Unordered Lists](#Unordered-Lists)\n",
    "        - [Complex Lists](#Complex-Lists)\n",
    "        - [Links](#Links)\n",
    "        - [Table of Contents](#Table-of-Contents)\n",
    "    - [Code Cells](#Code-Cells)\n",
    "        - [Writing Python Code](#Writing-Python-Code)\n",
    "        - [Python Console](#Python-Console)\n",
    "    - [Navigating the Jupyter Environment](#Navigating-the-Jupyter-Environment)\n",
    "        - [The Launcher](#The-Launcher)\n",
    "        - [Navigating Folders](#Navigating-Folders)\n",
    "        - [Saving Notebook Status](#Saving-Notebook-Status)\n",
    "        - [Exporting Notebooks](#Exporting-Notebooks)\n",
    "        - [Managing Active Notebooks](#Managing-Active-Notebooks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter Notebooks are an interactive computational environment for creating and sharing reproducible computational workflows and analyses. The name \"Jupyter\" is a reference to the three original programming languages and (Julia, Python, and R) supported by the Jupyter Notebook project. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Kernel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The kernel is an instance of a programming language running in a Jupyter Notebook. It is responsible for executing the code in the notebook. Look at the top right corner of the notebook interface. Since we are using Python, you should see something like \"Python 3\". If you are not connected to a kernel, you will see \"No Kernel\" instead. When you see \"No Kernel\", all you have to do is click it and you will be shown a list of available kernels to select from. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A cell is a container for text to be displayed in the notebook or code to be executed by the kernel. As such there are two types of cells:\n",
    "\n",
    "1. **Markdown cells** - these contain text that is displayed in the notebook. We can format the text using Markdown syntax ([ref 1](https://www.ibm.com/docs/en/watson-studio-local/1.2.3?topic=notebooks-markdown-jupyter-cheatsheet), [ref 2](https://daringfireball.net/projects/markdown/syntax))\n",
    "2. **Code Cells** - these contain the code that is executed by the kernel\n",
    "\n",
    "A new cell can be added to the notebook with the \"+\" button the top left of the notebook tab. This adds a new cell below the currently selected cell. The cell type (code or markdown) of the currently selected cell is displayed at the top of the tab as well and can be changed from there as well. You can also use the \"y\" key (**code**) and \"m\" (**markdown**) to set the type of the selected cell. Note that these shortcuts only work when the the cursor is not in the cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cell Execution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "A selected cell can be executed using the play button at the top of the tab or more conviniently with \"Shift + Enter\" key combination. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Markdown Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Headers \n",
    "\n",
    "The # symbol preceding text is used for denoting headers in Markdown. The number of # indicated the header level. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Header 1\n",
    "\n",
    "## Header 2\n",
    "\n",
    "### Header 3\n",
    "\n",
    "#### Header 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Emphasis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wrapping text with the * symbol is used for emphasizing text in Markdown. One * for *italicizing*, two for **bold** text, and three for ***bold and italic***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ordered Lists "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. First item in the list\n",
    "2. Second item in the list\n",
    "3. Third item in the list\n",
    "    1. First sub item \n",
    "    2. Second sub item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Unordered Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- An Item \n",
    "- Another Item\n",
    "- Yet Another Item\n",
    "    - An item within an item\n",
    "    - Another item within an item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Complex Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. First item in the list\n",
    "2. Second item in the list\n",
    "3. Third item in the list\n",
    "   - Unordered item within an item\n",
    "   - Another unordered item within an item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- An Item \n",
    "- Another Item\n",
    "- Yet Another Item\n",
    "    1. First item within an item\n",
    "    2. Second item within an item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Links"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "URLs and email addresses in markdown cells are automatically detected and stylized by the notebook. A link with a text label can be added using the format \\[Label\\]\\(Link\\). For example, here's the link to the [Week 1 Lab GitHub Repository](https://github.com/UM-CSS/CSSLabs-NLP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Table of Contents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the markdown links format to also link to sections denoted by headers to manually create a table of contents. Note the special construction of the section links in the TOC below (no spaces between # and header text and other spaces are replaced by \"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Jupyter Notebooks](#Jupyter-Notebooks)\n",
    "    - [The Kernel](#The-Kernel)\n",
    "    - [Cells](#Cells)\n",
    "    - [Cell Execution](#Cell-Execution)\n",
    "    - [Basic Markdown Syntax](#Basic-Markdown-Syntax)\n",
    "    - and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter now has a built in document outline and TOC. But it doesn't get added to the document when exporting the notebook to other file formats (Ex: pdf, html, latex etc.). So this is worth learning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Jupyter, a code cell can be recognized by the square brackets to the left of the cell. An unexecuted code cell has **[ ]:**, while an executed code cell has **[integer]:**. The integer within the square brackets in a code cell denotes the order of execution. At any given moment, the code cell with the highest number is the one that has been executed last. Sometimes code cells take time to finish executing. A code cell that is still executing or is waiting to execute will have **[\\*]:** next to it.\n",
    "\n",
    "<font color='red'>Caution: </font> Since Jupyter is an interactive environment, you can execute code cells in any order. Further a code cell can be executed any number of times. It is very common to end up with an inconsistent or unexpected notebook state due to losing track of the order in which cells were executed. In general, we recommended the following;\n",
    "\n",
    "1. Execute code cells in order\n",
    "2. When a change is made to a code cell at some intermediate point in the notebook, execute the entire notebook from the first code cell. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Writing Python Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write some very basic Python code in the next few cells starting with the **print** function. **print** is used to display text and variables (a container for a value) in an output cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the first output\n"
     ]
    }
   ],
   "source": [
    "# print simple text\n",
    "print(\"This is the first output\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that you can use # symbol to add a text comment to the code cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the 2nd output\n"
     ]
    }
   ],
   "source": [
    "# print some text given as separate values\n",
    "print(\"This is the \",2,\"nd output\", sep=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **sep** argument tells Python how to separate the  multiple values (separated by comma) given as input. The default **sep** is a **whitespace**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the 3rd output\n"
     ]
    }
   ],
   "source": [
    "## print a text with a the value of a python variable\n",
    "output_number = 3\n",
    "print(\"This is the \", output_number, \"rd output\", sep=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usually, we want to write more complex Python code to perform reusable chunks of computation. For this, we use Python **functions**. In the next code cell, we have written a Python function to count the numbers of different letters in a given string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_letters(input): # a function is defined by using the format def function_name(input1, input2...):\n",
    "    counts = dict() # define a key-value pair dictionary variable\n",
    "    for token in input: # iterate through each position in the string\n",
    "        if token.isalpha(): # is the character a letter\n",
    "            low_char = token.lower() # convert character to lowercase\n",
    "            if low_char in counts: # if we have already encountered this letter\n",
    "                counts[low_char] = counts[low_char] + 1 # increment the count for the letter by 1\n",
    "            else: # if this is the first time the letter is encountered\n",
    "                counts[low_char] = 1 # set the count for the letter to 1\n",
    "    return counts # return the key-value dictionary as output\n",
    "                "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run our function on some string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'t': 9,\n",
       " 'h': 1,\n",
       " 'e': 18,\n",
       " 'u': 4,\n",
       " 'n': 10,\n",
       " 'i': 8,\n",
       " 'v': 2,\n",
       " 'r': 9,\n",
       " 's': 12,\n",
       " 'y': 1,\n",
       " 'c': 4,\n",
       " 'o': 9,\n",
       " 'f': 3,\n",
       " 'l': 6,\n",
       " 'g': 5,\n",
       " 'a': 9,\n",
       " 'd': 8,\n",
       " 'p': 3,\n",
       " 'm': 2}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_string=\"The university consists of nineteen colleges and offers degree programs at undergraduate, graduate and postdoctoral levels in some 250 disciplines\"\n",
    "count_letters(input_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how the output from the function is printed automatically. Only the final output or print statement is displayed in the output cell. If the code cell generates multiple things we want to view, then some of them can be assigned to **variables** which are containers for values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "counts = count_letters(input_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'t': 9, 'h': 1, 'e': 18, 'u': 4, 'n': 10, 'i': 8, 'v': 2, 'r': 9, 's': 12, 'y': 1, 'c': 4, 'o': 9, 'f': 3, 'l': 6, 'g': 5, 'a': 9, 'd': 8, 'p': 3, 'm': 2}\n"
     ]
    }
   ],
   "source": [
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python Console"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some times, it becomes cumbersome to create (and later delete) multiple new code cells to look at different variables. Instead, you can use a Python console attached to the notebook. You can open a Python console by right clicking anywhere on the notebook (except a selected cell) and selecting **New Console for the Notebook**. \n",
    "\n",
    "<font color='red'>Caution: </font> Any variables that you create or any changes to variables or functions that you make on the console affect the notebook status. In general, we recommend using the console only to quickly view values of variables. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Navigating the Jupyter Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The Launcher"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Jupyter Environment starts up with one default tab called the **Launcher**. As we saw at the beginning of the lab, this can be used to create new **notebook**, **markdown** file etc.,  open a Python **console** or a **terminal** on the server where our environment is hosted. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Navigating Folders"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **folder symbol** in the toolbar in the left corner of the Jupyter environment, opens a view that shows your folder structure on the server. You can navigate this structure the same way you would navigate files and folders on your personal computer. \n",
    "\n",
    "1. Create a new a file or notebook: Use the \"+\" at the top left of the folder view. This opens a new launcher.\n",
    "2. Create a new folder: Use the **folder** symbol with a \"+\" sign. An untitled folder will be created immediately at the current location in the folder structure\n",
    "3. Upload a file from your computer: The **upward arrow** symbol will open a file dialog window  which allow you to upload a file from your personal computer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Saving Notebook Status "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a notebook has unsaved changes  there will be a **grey filled-in circle** icon next to its name in the tab. Changes made to a notebook can be saved using the **floppy disk** button at the top left of the notebook tab or using the shortcut **Ctrl + s**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exporting Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A notebook can be exported into more accessible forms such as **pdf** and **html** that don't require a Jupyter environment to read. To export the notebook select **File menu** at the top left and then choose **Export Notebook as**. \n",
    "\n",
    "<font color='red'>Caution: </font> Note that exporting will convert the notebook and will not execute any unexecuted code cells or execute the notebook from scratch. Make sure the notebook is in the correct display status before exporting. \n",
    "\n",
    "**Note**: The labs ask you to upload the your completed notebooks as either **pdf** or **html**. Exporting to **pdf** is known to sometimes fail with errors. If that happens, just export to **html** for the submission.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <font color='red'>Managing Active Notebooks</font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "You can open a notebook by double-clicking it on the folder view. When the notebook is opened, it is immediately activated by connecting to a kernel. A Jupyter environment can have multiple simultaneously active notebooks. Active notebooks have a little **green circle icon** next to them on the folder view.  \n",
    "\n",
    "Each open notebook requires a seperate Kernel which takes up resources on the server similar to tabs on a Web browser. It is good practice to shut down any notebooks that we are currently not using, as the resources of the server are shared between everyone. \n",
    "\n",
    "There are different ways to shutdown notebooks.\n",
    "\n",
    "1. Right click on the notebook file on the folder view and select **Shut Down Kernel**\n",
    "\n",
    "2. Select the **Stop icon** in the toolbar in the left corner of the Jupyter environment. This opens up a view showing open tabs, kernels, and terminals. Even if the corresponding notebook is not open as a tab, the open kernels maintain the status of the notebook.  You can close individual notebooks by hovering over their name and selecting **X** or close all open kernels by using **Shut Down All**. \n",
    "\n",
    "<font color='red'>When you are done with your work, make sure to close all notebooks and terminals using the second option above and log out of the environment with **File > Log out**</font>\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "60532daad443e33e09ce9fcd4cce7d77fe1057d14279904662ad14b5180a7d6d"
  },
  "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.8.8"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}