content/01. Introducing notebooks and the RoboLab environment/01.2 Exploring the notebook environment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 The interactive read-writable notebook environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this short activity, you will have an opportunity to practice using the Jupyter notebook interface. You won’t run any robot simulator programs until a later notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Working with notebook files interactively\n",
    "\n",
    "*If you are reading this document in a live Jupyter notebook environment, you will be able to interact with it directly.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, you can correct the splelinG mistake in this sentence by editing it directly. Double click on this paragraph to put this markdown cell into `Edit` mode, and the cell will become editable. Correct the spelling mistake, then \"run\" the markdown cell to redisplay it as formatted text in one of the following two ways:\n",
    "\n",
    "- *either* click on the `Run` button in the toolbar,;\n",
    "- *or* use a keyboard shortcut: `shift-enter` (that is, the shift key and the enter key at the same time)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To look up keyboard shortcuts, you can use the `Esc-h` keyboard shortcut (press the escape key and then, quickly after, the `h` key, or the escape key and the `h` at the same time): in the \"Edit mode\" area, look for \"run selected cell\". Alternatively, from the notebook *Help* menu, select the *Keyboard shortcuts* option. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Previewing formatted markdown\n",
    "\n",
    "Markdown text is a simple *mark-up* language in which you can write styled text using simple (hopefully intuitive) text elements. For example, to *emphasise* a word using italics, write it as follows: \\*emphasis\\*.\n",
    "\n",
    "You may notice my \"starred\" text is not itself italicised. If you double click on this markdown cell to see its editable view, you will see I have \"escaped\" the `*` characters around the word \\*emphasis\\* with a backslash character — `\\` — as if to say: *do not process this*. Note that if you have a space between a `*` and a letter at the start of a word, then the styling is similarly not applied; likewise, to \"close\" the styling, you need to place the second `*` right next to the final character in the emphasised text.\n",
    "\n",
    "*When you have finished looking at the editable text, hit `shift-enter` to return the cell to the rendered view.*\n",
    "\n",
    "That may all sound complicated, but hopefully it will become natural to you as you gain more experience of using the Jupyter environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "activity": true
   },
   "source": [
    "### Activity — Markdown as a natural, informal notation\n",
    "\n",
    "You may find that you already use similar stylist techniques to markdown syntax in an informal way when writing  handwritten notes or emails. You may even find that some email environments or text editors actually treating your text markup as markdown anyway."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "student": true
   },
   "source": [
    "*Double click on this cell to put it into `Edit` mode and record your observations here about where you have unconsciously used markdown style notation to emphasise or structure. When you have completed your comments, run this cell using the toolbar run button or `Shift-Return` keyboard shortcut to return it to the rendered view.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "activity": true,
    "heading_collapsed": true
   },
   "source": [
    "#### My Observations\n",
    "\n",
    "*Click the arrow in the sidebar or run this cell to reveal my answer.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "activity": true,
    "hidden": true
   },
   "source": [
    "If I make a list of items, I often prefix each list item, on a separate line, using a `-` sign.\n",
    "\n",
    "I have also noted that my Microsoft Outlook and Slack clients emphasise text if I wrap it in `*` marks. The Slack client also styles text wrapped using backticks (`` ` ``) in a monospace, code style font.\n",
    "\n",
    "As well as generating headings by prefixing a line with one or more `#` signs, markdown also supports level 1 heading generation by placing one or more `=` characters on the line underneath the heading text and level 2 headings by using two or more `-` characters. Underling a heading with one or two lines is a common technique when creating handwritten or simple text documents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Level 1 heading\n",
    "=\n",
    "\n",
    "## Level 2 heading\n",
    "\n",
    "\n",
    "Level 2 heading\n",
    "--\n",
    "\n",
    "Level 1 heading\n",
    "==="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Markdown examples\n",
    "\n",
    "This cell contains several examples of other forms of mark up. Double click on the cell to make it editable so you can see how the styling was generated.\n",
    "\n",
    "Double click on this cell to see how markdown is used to create particular styling effects.\n",
    "\n",
    "We can *italicise text* by wrapping it with single asterisk `*...*` or `_..._` underscore elements.\n",
    "\n",
    "Use a backslash character to disable the text processing effect, eg if you which to italicise a *\\** character.\n",
    "\n",
    "Strong (__bold__) emphasis can be introduced by wrapping text doubling up the number of * or _ elements.\n",
    "\n",
    "Unnumbered list items:\n",
    "\n",
    "- are prefixed by a `-` or single `*` character, followed by a space;\n",
    "* are clearer in their text for if you precede the first list item with a blank line\n",
    "  - sublists are indented, and are identified by prefixing the - or * marker by two spaces.\n",
    "  \n",
    "Numbered lists:\n",
    "\n",
    "1. are identified by prefixing the line with `1.` followed by a space.\n",
    "1. some flavours of markdown may offer the ability to use alternative numbering schemes (letters, or Roman numerals, for example).\n",
    "\n",
    "\n",
    "Headings are identified by starting the header line with one or more `#` characters, followed by a space and then the title or (sub) heading. The number of `#` characters identifies the level of heading required.\n",
    "\n",
    "You can also identify a heading by placing two or more equals signs (`==`) on the line immediately below it, or a subheading by placing two or more dashes (`--`) at the start of the following line.\n",
    "\n",
    "Dividing lines can also be added: just start a line with three or more dashes (`---`) prefixed by an empty line.\n",
    "\n",
    "---\n",
    "\n",
    "Inline `code` can be identified by wrapping the code item within backticks: \\`...\\`. \n",
    "\n",
    "Blocks of code can identified by marking out an area using three or more backticks to start and end the block:\n",
    "\n",
    "```\n",
    "# comment\n",
    "def hello(msg):\n",
    "    print(msg)\n",
    "\n",
    "hello(\"my friend\")\n",
    "```\n",
    "\n",
    "Syntax highlighting for a particular language can be enabled by declaring the language required immediately after the opening set of backticks (although rendering backticks in backticks can be tricky!). For example, starting a code block with ```` ```python ```` will cause it to be rendered using Python language syntax highlighting:\n",
    "\n",
    "\n",
    "```python\n",
    "# comment\n",
    "def hello(msg):\n",
    "    print(msg)\n",
    "\n",
    "hello(\"my friend\")\n",
    "```\n",
    "\n",
    "You can also add links you your markdown text, using constructions of the form: `[my link text](https://example.com)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Taking ownership of your notebooks\n",
    "\n",
    "One of the difficulties in working with electronic texts is that they can often be hard to annotate. Interactive notebook style interfaces offer a different way of working, in that you can annotate or edit the text directly.\n",
    "\n",
    "If you are using this notebook via the module VCE, you may already have noticed that some cells have a coloured background that is rendered using the preinstalled [`empinken`](https://github.com/innovationOUtside/nb_extension_empinken) extension.\n",
    "\n",
    "Three buttons are provided that toggle the colour of selected code or markdown cells:\n",
    "\n",
    "- activity cells (blue);\n",
    "- student annotation cells (yellow);\n",
    "- feedback and alert cells (pink).\n",
    "\n",
    "![Screenshot of empinken toolbar showing buttons used to highlight cell colours: ! button: pink tutor comment; three lines / document: blue activity cell; head and shoulders in black circle: yellow student comment cell](../images/empinken_buttons.png)\n",
    "\n",
    "Yellow cells are used as call to actions for you to make your own comments. If you create your own cells, you may wish to highlight them using the yellow (or pink) backgrounds so you can more easily return to them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Click this cell to select it then practice using the toggle buttons to change its background colour.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1 Using the notebook highlighter pen\n",
    "\n",
    "Another way of annotating the markdown text materials is to use the highlighter pen from notebook toolbar.\n",
    "\n",
    "![Notebook toolbar showing highlight pen buttons.](../images/00_01_highlighter.png)\n",
    "\n",
    "\n",
    "<span class=\"mark\">Simply select the text you want to highlight in its rendered view, and then click on the appropriate highlighter pen colour.</span>\n",
    "\n",
    "Another way is to just start clicking on the markdown cells, adding your own notes, commentary or reflection, or your own questions, explanations and examples, to the text.\n",
    "\n",
    "There are risks associated with this of course - like accidentally deleting a chunk of module materials, or changing a working example to a broken one. But there are also many advantages - like making the materials meaningful *to you*. And if you want to distinguish your content from the provided materials, you can always highlight them, or put them in a markdown cell of their own, with a heading that identifies the text in that cell as your own work. "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Alternatively, from the notebook toolbar, change your own markdown cells to cells of type `Raw NBConvert`. Although this cell type does not render the markdown styling — the text is presented in a \"raw\" teletype style text view —  if you used markdown annotations *they should still mark up your text in a __meaningful__ way*. And the text is visually distinguishable from the provided, styled, markdown materials."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2 Previewing style markup\n",
    "\n",
    "Although I find it second nature to write in markdown (I've been been writing in simple text formats for a long time!) you may find it takes some getting used to, and that you keep having to flip between the edit view and the rendered view to make sure you are creating the text effect you intended.\n",
    "\n",
    "To make it easier, if you enable the `livemdpreview` notebook extension [[direct link](/nbextensions/?nbextension=livemdpreview/livemdpreview)], you can preview how your rendered markdown looks in a preview window directly underneath a markdown cell you are editing.\n",
    "\n",
    "*You may need to save your notebook and reload it in your browser after enabling the extension to see the effect. It should be enabled by default for any notebooks you open after enabling the extension.*\n",
    "\n",
    "A checkbox option in the extension's configuration panel optionally allows you to display the preview alongside, rather then below, the markdown cell being edited. The preview disappears when you return the cell to its display mode."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.3 Popping out cells\n",
    "\n",
    "Sometimes you may want to refer back to a particular cell, cell output, or cell and it's output. The [`nb_cell_dialog`](https://github.com/innovationOUtside/nb_cell_dialog) extension that is pre-installed in the module VCE allows you to \"pop out\" cells into a floating dialog widget by clicking on appropriate toolbar buttons:\n",
    "\n",
    "- *rocket* button will pop-out markdown and cell output.\n",
    "- *terminal* (`>_`) button will pop out code cell and its output. Note: this is non-runnable.\n",
    "\n",
    "Close the dialog and the cell is put back where it came from (most of the time: I think there's an edge effect if you pop the last cell in the notebook using the terminal button).\n",
    "\n",
    "Run the following code cell to embed a video showing showing how to use the rocket toolbar button to pop-out markdown and cell output and terminal button to pop out code cell and its output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Video\n",
    "Video(\"../images/popout.mp4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.4 WYSIWYG \"text editor\" view\n",
    "If you really cannot get to grips with writing raw markdown, a WYSIWG editor is available.\n",
    "\n",
    "Enable the [`jupyter_wysiwyg`](/nbextensions/nbextension=jupyter_wysiwyg/index) extension from the `nbextensions` notebook configuration tab on the notebook server homepage. (You may find that access to the *WYSIWYG text editor* extension is disabled at first; at the top of the extensions configurator page, uncheck the *disable configuration for nbextensions without explicit compatibility* option.)\n",
    "\n",
    "Save and reload your notebook. When you double click on a markdown cell to edit it, you should now see two buttons have appeared on the left-hand side of the cell, one with a `Rich Text Editing` tooltip when you hover over it, the other with a `Run Cell` tooltip.\n",
    "\n",
    "The `Run Cell` button provides a convenient additional way of rendering a markdown cell that is currently in edit mode. You also need to use this button to render the cell if you have been editing it using the rich text WYSIWYG editor.\n",
    "\n",
    "The `Rich Text Editing` button provides a way of launching the rich text editor. This editor allows you to style your text, and immediately see the result, as you type. You can still see the raw mark-up text by rendering the cell and then double clicking on it to take it into the edit mode. However, you may find that the marked up text is not quite as clean as mark-up text: HTML tags are used to style the text and any previous markdown annotations will be converted to their HTML equivalents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Creating New Cells\n",
    "\n",
    "To create a new cell in a notebook, click on the `+` button in the notebook toolbar. A new cell will be created directly below the current selected cell.\n",
    "\n",
    "By default, a new cell is created as a code cell. To convert the cell to a *markdown* cell type, change the cell type using the cell type drop-down list in the notebook toolbar from `Code` to `Markdown`.\n",
    "\n",
    "A keyboard shortcut — `Esc-M` (that is, the escape key followed by the letter `m`) — also converts a selected cell in *Edit mode* to the *markdown* cell type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Code Cells\n",
    "\n",
    "Code cells can be used to enter — and *execute* — Python code.\n",
    "\n",
    "To run a code cell, which is to say, to execute the code contained in a code cell, click in the code cell to select it and then press the run (\"play\") button on the notebook toolbar. Alternatively, use a keyboard shortcut - `Shift-Return` — to run the selected cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a cell has successfully completed executing, the cell execution / run status indicator is coloured green. After running a code cell, a number in square brackets displays a cell execution index number. Each time a code cell is run, the overall index count goes up by one and is used to indicate the cell execution index (or \"cell run number\") for that cell.\n",
    "\n",
    "When a code cell is running, or waiting to run, it is highlighted with a light blue colour on the left hand side. A * character also indicates the status of the running cell.\n",
    "\n",
    "<img alt=\"Screenshot of notebook showing one completed cell execution with green run status indicator in the cell sidebar, along with one running cell and one yet to be run cell with a light blue run status indicator.\" src=\"../images/00_01_cell_run_status_running.png\" width=400 />\n",
    "\n",
    "If you run all the cells in a notebook, all the cells yet to be run, as well as the running cell, are highlighted with a blue run status indicator and the * cell run number.\n",
    "\n",
    "<img alt=\"Screenshot of notebook showing one completed cell execution with green run status indicator in the cell sidebar, along with one running cell and one yet to be run cell with a light blue run status indicator.\" src=\"../images/00_01_cell_run_status.png\" width=400 />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If an error is raised that causes a code cell not to execute correctly, the run status indicator is coloured pink and an error message is show beneath the the cell in the code cell display area.\n",
    "\n",
    "<img alt=\"Screenshot of notebook showing one completed cell execution with green run status indicator in the cell sidebar, along with one running cell and one yet to be run cell with a light blue run status indicator.\" src=\"../images/00_01_cell_run_error.png\" width=800/>\n",
    "\n",
    "Clicking on the arrow will at the end of the error message will reveal the full error message.\n",
    "\n",
    "<img alt=\"Screenshot of notebook showing a code cell execution error with expanded error message.\" src=\"../images/00_01_cell_run_error_message.png\" width=800 />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "activity": true
   },
   "source": [
    "### 2.4.1 Activity — Experimenting with the code cell run indicators\n",
    "\n",
    "Run the following cells in turn to see the code cell indicators in action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "activity": true
   },
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "activity": true
   },
   "outputs": [],
   "source": [
    "# Wait for a specified \"sleep\" duration in seconds\n",
    "time.sleep(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "activity": true
   },
   "outputs": [],
   "source": [
    "print(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "activity": true
   },
   "outputs": [],
   "source": [
    "# This statement is badly formed and should raise and error\n",
    "print(\"hello again\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.2 Cell execution status — audible alerts\n",
    "\n",
    "Audible feedback for successful and unsuccessful cell completion can also be enabled from the notebook *Cell execution Status* extension configuration panel ([direct link](http://localhost:8129/nbextensions/?nbextension=cell_execution_status/index)); you may need to uncheck the *disable configuration for nbextensions without explicit compatibility* checkbox to enable the configuration panel).\n",
    "\n",
    "![Screenshot showing the cell execution status configuration options, as listed in main text below this image.](../images/cell-execution_config.png)\n",
    "\n",
    "Audible controls include:\n",
    "\n",
    "- audible alert of successful cell execution completion status\n",
    "- audible alert of unsuccessful cell execution completion status\n",
    "- heartbeat on long running execution (with a specified heartbeat interval)\n",
    "- spoken alert of errored run cell index\n",
    "- spoken announcement that all cells completed (with a specified minimum number of concurrent cells required prior to an \"all cells completed\" announcement\n",
    "\n",
    "There is also an optional heartbeat pulse (default period 5s; configurable) that can be used to indicate the continuing run status of long running cells.\n",
    "\n",
    "*After changing the settings, you will need to reload the notebook in your browser for the changes to take effect.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "activity": true
   },
   "source": [
    "### 2.4.3 Activity — displaying code line numbers\n",
    "\n",
    "Sometimes it can be useful to display line numbers in a code cell to more easily reference or refer to a particular line of code. Line numbers can be toggled on and off within a particular code cell using the keyboard shortcut `Esc-L` (that is, *escape* and *l*).\n",
    "\n",
    "When a notebook is saved, the  line number toggled display settings are also saved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "activity": true
   },
   "outputs": [],
   "source": [
    "# Example of code cell line numbering\n",
    "\n",
    "# This is actually line 3..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "activity": true
   },
   "source": [
    "Click in the above code cell to select it and practice toggling the line numbers on and off."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.4 Code style\n",
    "\n",
    "To make code as readable as possible, the [Python PEP8 style guide](https://www.python.org/dev/peps/pep-0008/) provides guidance on how to lay out your code so that it is easier to read. Code style guidance includes things like:\n",
    "\n",
    " - use of white space within lines and between lines\n",
    " - naming conventions for function and variable names \n",
    " - maximum line lengths to maintain readability\n",
    " \n",
    "Throughout the notebooks, we have tried to use good practice, although PEP8 standards have not necessarily always been enforced. Various tools are available for warning about breaches of PEP8 style guidelines or even automatically formatting code so that it is style compliant, but these are disabled by default in these notebooks.\n",
    "\n",
    "*See [Notebook Code Linting](https://github.com/innovationOUtside/TM351_forum_examples/blob/master/Notebook%20Code%20Linting.ipynb) for more information about automatically linting code in Jupyter notebooks.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "activity": true
   },
   "source": [
    "### 2.4.5 Activity — creating new code cells\n",
    "\n",
    "Single click on this markdown cell to ensure that it has the focus and then create a new code cell by clicking on the `+` button in the notebook toolbar. A new cell will be created directly below the currently selected cell, whatever type of cell it is. By default, newly created cells are created as code cells. The cursor focus is automatically moved to the new cell, so once it is created you can immediately start typing code into it.\n",
    "\n",
    "*Click on the `+` button in the notebook toolbar to create a new code cell, entry `print('hello world')` and run the cell to execute the code and see the result.*\n",
    "\n",
    "Feel free to create and run your own notebook code cells to try out your own code examples. Remember, the notebooks *are yours*. So make full use of them..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Creating and saving your own code\n",
    "\n",
    "Throughout the practical activities associated with this block, you will have the opportunity to create and run your own programmes to run within notebook's Python environment as well as in the simulator.\n",
    "\n",
    "Saving a notebook will save your code and any currently displayed cell outputs (the notebooks also autosave regularly), so you can close the notebook, shutdown the associated notebook process, and then restart the notebook and return to it later. \n",
    "\n",
    "Although the current simulator view, any other displayed widgets, and the internal state of the simulator and the notebook's own Python environment, are *not* saved, rerunning the code cells that create them will generate them afresh."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.6 Embedding resources in the notebooks\n",
    "\n",
    "You may already have noticed that you can embed image resources in markdown cells. It is also worth noting that Jupyter notebooks can also embed a wide range of media types, including video and audio players.\n",
    "\n",
    "You can even emebed YouTube videos using just a YouTube video ID:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.lib.display import YouTubeVideo\n",
    "\n",
    "YouTubeVideo('mGgMZpGYiy8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.7 And finally...\n",
    "\n",
    "As well as using the provided notebooks, you are also encouraged to create and save your own notebooks containing your own code experiments. You should also feel free to use the simulator to try out your own self-created challenges and to satisfy your own curiosity about whether you can get the simulated robot to perform tasks of your own devising as well as the suggested activity tasks.\n",
    "\n",
    "One thing you might want to do is create your own summary cell at the end of each notebook to record your own summary notes about what you learned working through the notebook. Remember, you can create your own cells and then colour them using the appropriate toolbar button."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.8 Summary\n",
    "\n",
    "In this notebook you have learned out to use Jupyter notebooks as interactive read-writable documents within you can write markdown text that can be parsed into styled HTML code in markdown cells, as well as writing and executing executable Python code in code cells.\n",
    "\n",
    "Code cell execution state is indicated by a status indicator in the code cell margin.\n",
    "\n",
    "In the next notebook, you will be introduced to a simple notebook based robot simulation environment, `nbev3devsim`. Taken together, the interactive Jupyter notebook and the `nbev3devsim` simulator will make up the TM129 RoboLab environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "student": true
   },
   "source": [
    "*Consider editing this cell and writing your own summary notes and reflection about what you learned when working through this notebook, including notes on anyhting that you found particularly surprising or that you thing you might specifically need to refer to in future.*\n",
    "\n",
    "*Also consider creating such cells for yourself at the end of future notebooks.*"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "formats": "ipynb,.md//md"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}