Lab 1.1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Edited: 9th September 2023*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CMM201 &mdash; Lab 1.1\n",
    "\n",
    "In this lab we will learn about Python, Anaconda, and Jupyter. We will also discuss different types of cells in notebooks, and managing your notebook files for the module.\n",
    "\n",
    "This lab contains some important information you need to know when you're working with Jupyter and Python."
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Python\n",
    "\n",
    "**Python** is a programming language initially released in 1991 by Guido van Rossum. It is one of the most popular programming languages in general, but especially for data science and for new programmers. "
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Python Versions\n",
    "\n",
    "In this module we will be using **Python 3**, which started in 2008, and replaces Python 2 which officially ended support in 2020.\n",
    "\n",
    "Specifically, we recommend using **Python 3.11**, as this is the latest stable version. Versions 3.8, 3.9, 3.10, and 3.11 are considered currently supported versions, and version 3.12 is expected to be released in October 2023. If you're running a slightly different version, it shouldn't negatively impact on CMM201 as we typically do not rely on recent language changes in this introductory programming module."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Anaconda\n",
    "\n",
    "There are different ways to install Python, and manage installation of Python package, which add additional features. Some operating systems come pre-installed with Python *(although sometimes this is the outdated Python 2)*, and you can manually install Python by downloading from the Python website. However, we recommend **Anaconda**.\n",
    "\n",
    "Anaconda is a collections of tools including Python, and a graphical user interface **Anaconda Navigator** for managing environments and packages, and launching tools. At the time of writing, Anaconda comes with Python 3.11, but also allows you to install and use multiple different versions of Python on the same computer. Some people use different versions of Python on different projects for compatability reasons."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Jupyter\n",
    "\n",
    "Python code is typically found in one of two file types, **source files** (`.py` files) which contain only executable code, and **notebook files** (`.ipynb` files) which are more interactive and contain executable code, outputs, markdown, raw text, and the ability to run extensions with more functionality such as slide shows.\n",
    "\n",
    "In this module we will always use notebooks since these are the most common in data analytics. However, all the Python you will learn can also be used in standard Python source files. There are many coding environments to choose from which can edit notebooks, two of which are installed with Anaconda:\n",
    "\n",
    "1. Jupyter Notebook\n",
    "2. JupyterLab\n",
    "\n",
    "**Jupyter Notebook** (formerly called \"IPython\") was released in 2011 by Project Jupyter. **JupyterLab**, with the first stable release on 2018, is the \"next generation\" version of Jupyter Notebook. Unfortunately some popular third-party extensions for Jupyter Notebook have not been ported to JupyterLab yet, so many data scientists continue to use Jupyter Notebook.\n",
    "\n",
    "There are other options for editors which fully support notebooks such as **Visual Studio Code**, **PyCharm Professional**, and **DataSpell**, and you could use any of those for this module too! Typically, these editors will support a wider set of features such as code completion using a language server, support for version control and refactoring tools. Note that some of the instructions in the labs relating to user interface such as text in menus and specific buttons will be different in different editors, and the layout of some of these most fully-featured editors can be overwhelming to new programmers compared to the simplicity of Jupyter Notebook and JupyterLab.\n",
    "\n",
    "There is also **Google Colaboratory**, which is like Jupyter Notebook or JupyterLab, but with Python hosted on Google servers. This makes it easier to share notebooks with others, and you can pay to run your code on more powerful hardware, which makes it popular for AI researchers. For this module, the power of your local computer should be sufficient.\n",
    "\n",
    "It is important to understand that the file type created is the same no matter which application you use to edit it! Try not to confuse the software called \"Jupyter Notebook\" (upper-case \"N\") with the notebook file format, which may sometimes confusingly be called \"a Jupyter notebook\" (lower-case \"n\") because of the popularity of Jupyter Notebook as the default editor."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Important! &mdash; Accessibility\n",
    "\n",
    "When programming, you must be able to see the difference between symbols which look similar from a distance, such as:\n",
    "\n",
    "- `-` (minus) and `=` (equals)\n",
    "- `.` (period) and `,` (comma)\n",
    "- `O` (upper-case o) and `0` (zero)\n",
    "- `1` (one), `I` (upper-case i), and `l` (lower-case L)\n",
    "\n",
    "If these symbols look too similar for you to tell apart, you may need to make adjustments. Programming is a very precise activity in which one character difference will cause your code not to run correctly. Replacing one symbol with a similar looking one might be good enough for an essay, but it's not good enough for Python code!\n",
    "\n",
    "Since we are looking at Jupyter Notebook or JupyterLab in the web browser you can zoom in on the text.\n",
    "\n",
    "On Windows:\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;hold `Ctrl` and press the plus or minus keys\n",
    "\n",
    "On macOS:\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;hold `command ⌘` and press the plus or minus keys\n",
    "\n",
    "Further customisation can be done, including the use of screen zoom available in Windows and macOS through accessibility, changing colours through JupyterLab's dark mode, and adjusting typefaces."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Code Cells (and Output Cells)\n",
    "\n",
    "In a notebook, there are three types of cells you can create:\n",
    "\n",
    "1. code cells;\n",
    "2. Markdown cells; and\n",
    "3. raw text cells (called \"Raw\" in JupyterLab and \"Raw NBConvert\" in Jupyter Notebook)\n",
    "\n",
    "First we will focus on code cells. A **code cell** is where you type your Python code to be run. Sometimes you may see these called \"input cells\", but since this might be confused with user input, which they are not, we will try to call them \"code cells\" as much as possible.\n",
    "\n",
    "The cell below is a code cell. You should see that JupyterLab displays `[ ]` on the left of the code cell, or Jupyter Notebook will display `In [ ]`.\n",
    "\n",
    "Click on the code cell below, where you see we have written the text `1 + 1`, then click on the \"Run\" button on the toolbar (it looks like a play button ▶)."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A new cell is created. The new cell is an **output cell** which corresponds to the code cell you ran.\n",
    "\n",
    "The output cell contain the text `2`, which is the result of the calculation `1 + 1`. So we have managed to use Python as a simple calculator.\n",
    "\n",
    "Notice that the `[ ]` has changed to a `[1]` to indicate that this is the 1st code cell which has been run. The output cell has the same number `[1]` next to it, to show that it is the corresponding output cell.\n",
    "\n",
    "If you click on the same code cell again or any other code cell, and run it, the code will run, and the number will advance to `[2]`. Every code cell you run in the notebook will get the next number up. By looking at the numbers next to the code cells, you can tell in what order they were last run. This is useful when you have many code cells in your notebook.\n",
    "\n",
    "What happens when you type something which is not valid Python code and try to run it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "This is not Python code!\n",
    "Expect to see an error when you run this!  :-("
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see a cell appears (if you're in JupyterLab, this will have a red background) stating there is a `SyntaxError`, and showing which line of code the error occurred on. Since Python is interpreted, there is not a clear distinction between compile-time errors and run-time errors. So we will just call these \"errors\", or \"exceptions\".\n",
    "\n",
    "The particular error you got was a **syntax error** which means that the text input was not valid Python code.\n",
    "\n",
    "There are many other errors you will encounter, for example, this will give a **zero division error** which means we tried to divide a number by zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 / 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell below which says `x` will give a **name error**, because we are trying to access a variable which does not exist. We will learn about variables in Unit 1.2, so don't worry too much about the meaning of this for now. This is just to show you another type of error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is very important to become familiar with errors in Python!\n",
    "\n",
    "As we go through the module, you will probably encounter many such errors by accident and have to **debug** your code, which mean you try to figure out what's wrong and fix the bugs. Making mistakes is always a part of learning anything! However, there are also times when we want our code to cause these errors to be raised on purpose, which we will see much later when we get into the topic on handling exceptions in Unit 1.5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markdown Cells\n",
    "\n",
    "The cell below is a *Markdown* cell. Double-click on the cell to edit it, you'll see it contains formatting markers. With the cell selected, and run it, like you did with the code cell, and you'll see it displays formatted text.\n",
    "\n",
    "↓ double-click this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to **CMM201**! This is a \"*Markdown*\" cell. In markdown cells we can use formatting such as *italics*, **bold**, and `monospace`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "↑ double-click this\n",
    "\n",
    "Notice that before running the cell, it contained come formatting markers like `*`.\n",
    "\n",
    "These are used in a format called \"Markdown\". **Markdown documents** (`.md` files) are popular format for simple formatting. You may know some other applications which use Markdown, such as Notion.\n",
    "\n",
    "However, we don't need a separate file for Markdown if we are using a notebook. We can include Markdown cells inside our notebooks! This of the main reasons for using notebooks. They allow us to include Markdown cells right next to our code cells instead of having to keep them in separate Markdown documents.\n",
    "\n",
    "These lab sheets are written using many Markdown cells.\n",
    "\n",
    "If you double-click on a markdown cell by accident, showing the Markdown, don't panic, just click the \"run\" button to change back to rendered Markdown."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Raw Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell below is a **raw cell** (sometimes we call these \"text cells\").\n",
    "\n",
    "Try running it!"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "This is a raw cell!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nothing happened! (other than the editor advancing to the next cell)\n",
    "\n",
    "Raw cells are rarely used, but you may use them to add some unformatted block text.\n",
    "\n",
    "If you accidentally change one of your code cells to raw cells, or markdown cells, just change it back with the cell type selection drop-down in the menu bar.\n",
    "\n",
    "In CMM201 we may provide a blank raw cell occasionally in the lab sheets below a question. You may want to write an answer to the question in the raw text cell, or just think about the question. \n",
    "\n",
    "Attempting to answer these questions is recommended, as it will help you check that you understand the material.\n",
    "\n",
    "**(a)** What is the difference between Python, Anaconda, and Jupyter?"
   ]
  },
  {
   "cell_type": "raw",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Note that questions are assigned a letter starting **(a)**, **(b)**, **(c)**, etc., so you can look up the provided solution in the solutions notebook (also available on the CMM201 CampusMoodle page)."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Creating Cells\n",
    "\n",
    "*Single click* on the cell which contains this text you are reading now, to select it. If the markdown source shows, that means you double-clicked by accident.\n",
    "\n",
    "Then click on the \"Insert\" button on the toolbar (it looks like a plus sign *next to the save icon*)\n",
    "\n",
    "It should create a new code cell below, in between the lines &#8595;\n",
    "\n",
    "---"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The insert button always creates a new code cell below the current cell.\n",
    "\n",
    "There is one other way you will typically create cells. If you are at the very end of a notebook and run the final cell, Jupyter Notebook or JupyterLab will helpfully insert a new code cell for you automatically, so that you don't need to click insert each time.\n",
    "\n",
    "Notice that the default type of cell which is inserted is a code cell. To change the type, ensure the cell is selected, and then use the dropdown in the toolbar."
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Rearranging Notebook Cells\n",
    "\n",
    "Cells (of any type: code, raw, markdown) can be easily rearranged.\n",
    "\n",
    "In JupyterLab:\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;Click and drag the area on the left side of a cell, and release to drop it in place.\n",
    "\n",
    "In Jupyter Notebook:\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;Click on the cell and click the up or down arrows on the toolbar.\n",
    "\n",
    "You can also, cut, copy, and paste whole cells using the three buttons on the toolbar with the scissors, two rectangles/documents, and clipboard icons.\n",
    "\n",
    "Rearrange the cells into the correct order, and remove the two extra cells."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Cell 1"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Delete Me"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Cell 4"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Cell 3"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Delete Me"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Cell 2"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Clearing the Kernel\n",
    "\n",
    "When you share a notebook with someone, the notebook will contain not only the code cells, markdown cells, and raw cells, but also the output cells. Since these output cells should be reproducible by anyone running your notebook, you don't need to save the output cells.\n",
    "\n",
    "To clear the outputs, you can do the following:\n",
    "\n",
    "In JupyterLab:\n",
    "\n",
    "    Kernel > Restart Kernal and Clear All Outputs...\n",
    "    \n",
    "In Jupyter Notebook:\n",
    "\n",
    "    Kernel > Restart & Clear Output\n",
    "\n",
    "There are some instances where you would want to leave the output there, for example if you want someone to be able to view the previous output without needed to run the notebook. But there are also times you will want to clear outputs like when saving your work to version control.\n",
    "\n",
    "We typically ask that you clear your outputs before submission of your coursework."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Saving Your Notebook\n",
    "\n",
    "To save, click the familiar \"save\" icon on the toolbar, or alternatively you can use the menu bar in Jupyter.\n",
    "\n",
    "In JupyterLab:\n",
    "\n",
    "    File > Save Notebook\n",
    "    \n",
    "In Jupyter Notebook:\n",
    "\n",
    "    File > Save and Checkpoint"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Renaming Notebooks\n",
    "\n",
    "In JupyterLab:\n",
    "\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Find the notebook in the left-hand panel, right-click it, and select \"Rename\".\n",
    "\n",
    "In Jupyter Notebook:\n",
    "\n",
    "    File > Rename..."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Finding Where Your Notebooks are Stored\n",
    "\n",
    "Hopefully if you're reading this, you've already found the correct place on your computer to download this lab to.\n",
    "\n",
    "In JupyterLab, the panel on the left, while the \"File Browser\" tab is open, shows the contents of one of the folders on your computer's local storage.\n",
    "\n",
    "In Jupyter Notebook, the first screen you see before selecting a notebook file is the contents of one of the folders on your computer's local storage.\n",
    "\n",
    "Even though you are working through a web browser, everything is stored on your computer locally. By default, this is your user home directory in Windows or macOS, but can be changed.\n",
    "\n",
    "Your home directory probably has a lot of files and subfolders with many other files you use on your computer. To keep things organised, it is a good idea to create a subdirectory to keep your CMM201 work in, and naming it something like \"CMM201\".\n",
    "\n",
    "Create a folder either through Windows Explorer, or macOS Finder, or by clicking the folder with a plus sign on the left panel of JupyterLab or by clicking \"New\" then \"Folder...\" in the top right of the file list screen in Jupyter Notebook.\n",
    "\n",
    "You need to remember what folder is being displayed. When it comes to the coursework submission, you'll save your work (don't forget to save!!!), and then locate the file to be able to upload it to CampusMoodle's submission dropbox system.\n",
    "\n",
    "**(b)** Where is this notebook file stored on your local computer right now?"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "raw",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Important! &mdash; Don't Use Your Browser's Save Option!\n",
    "\n",
    "Sometimes students will mistakenly try to save their notebook by selecting the \"Save As...\" or \"Save Page As...\" options in their web browser. These options have nothing to do with Jupyter or Python. They are build into your web browser and save an HTML file which contains part of the UI you're looking at and is not your notebook, because your web browser does not understand what you are trying to do.\n",
    "\n",
    "You must *not* do this in attempt to export your coursework for submission. The resulting file will *not* contain your notebook, and is not a valid coursework submission and if you submit a file saved in this way will count as a non-submission and fail the coursework!\n",
    "\n",
    "Locate the correct file in your local filing system. If you have difficulty, please speak to either the module coordinator or on of the module assistants."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Creating New Notebooks\n",
    "\n",
    "In the labs, you will edit a notebook that has been created for you.\n",
    "\n",
    "In the coursework, and any other work you do on your own outside of labs and coursework, you will need to start with a new, blank notebook.\n",
    "\n",
    "To create a blank notebook, click the plus icon in the left panel (not the plus icon next to the save icon).\n",
    "\n",
    "Then click **Python 3** under \"Notebook\" (not under \"Console\"). You will get a blank notebook called \"Untitled.ipynb\", which you may wish to rename."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Shutting Down JupyterLab / Jupyter Notebook\n",
    "\n",
    "If you just close the browser, Jupyter will still be running in the background until you manually terminate the process or reboot.\n",
    "\n",
    "In JupyterLab:\n",
    "\n",
    "    File > Shutdown\n",
    "\n",
    "In Jupyter Notebook:\n",
    "\n",
    "    File > Close and Halt\n",
    "    \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;Then select \"Quit\" from the top-right of the file listing page and confirm, then close your browser window, or browser tab.\n",
    "\n",
    "The next time you want to start using JupyterLab or Jupyter Notebook, start it again from Anaconda Navigator."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Quiz\n",
    "\n",
    "In the first 5 units, there are formative quizzes on CampusMoodle.\n",
    "\n",
    "You will find a quiz labelled \"Unit 1.1 Quiz\" under this unit's section.\n",
    "\n",
    "You may attempt the quiz as many times as you wish, and it does not affect your final grade, so this is just to give you some quick feedback to check your understanding.\n",
    "\n",
    "Quizzes cover material from both the lecture and the lab. We recommend reviewing the material again if you don't get 100% or at least close to it."
   ],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}