Lesson 1 - Introduction to Jupyter Notebook and programming in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# _Lesson 1_: Introduction to Jupyter Notebook and programming in Python\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <b>Learning outcomes:</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Download and install Anaconda with Jupyter Notebook.</li>\n",
    "        <li>Open your first Jupyter Notebook document.</li>\n",
    "        <li>Learn version control and code management with Git and GitHub.</li>\n",
    "        <li>Write your first line of code.</li>\n",
    "        <li>Learn and apply the core Python variables, types and operators.</li>\n",
    "        <li>Employ variables, types and operators in loops and conditions to perform simple tasks.</li>\n",
    "        <li>Capture and respond efficiently to exceptions.</li>\n",
    "        <li>Use sets to extract unique data from lists.</li>\n",
    "        <li>Develop and use reusable code by encapsulating tasks in functions.</li>\n",
    "        <li>Package functions into flexible and extensible classes.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.1 Installing Python and Jupyter Notebook with Anaconda\n",
    "\n",
    "![Jupyter overview](images/jupyter-overview.jpg)\n",
    "\n",
    "Anaconda is a suite of popular data science packages for Python and includes Jupyter Notebook which is an interactive notebook allowing you to create and share documents containing live code. This is a Jupyter Notebook and you'll be able to follow along learn as you go.\n",
    "\n",
    "Our first objective is to install Anaconda and create a Jupyter Notebook so that you can start this tutorial. If you want to try it in a browser (including their own tutorial), then [follow this link](https://jupyter.org/try).\n",
    "\n",
    "To install Anaconda, and all the Python packages so that you can work on your own computer:\n",
    "\n",
    "- Go to the [download page on Anaconda](https://www.anaconda.com/download/);\n",
    "\n",
    "![Download Anaconda](images/anaconda-1.jpg)\n",
    "\n",
    "- Definitely choose the **Python 3.x version** for installation. Select the appropriate package for your computer (Windows, MacOS, or Linux). If you're on Windows, you'll also need to decide on 64-bit or 32-bit. Most computers now support 64-bit but, if you're unsure, pick the 32-bit version.\n",
    "\n",
    "- After downloading, run the software and install all the defaults.\n",
    "\n",
    "- You'll see you have the option to launch Anaconda, or Jupyter Notebook. For now, we'll go straight into Jupyter Notebook.\n",
    "\n",
    "- The first page that opens in the Jupyter Notebook folder (or tree) view. Here you can see a list of files. Jupyter Notebooks end with the extension \".ipynb\"\n",
    "\n",
    "![Jupyter Notebook tree view](images/jupyter-01.png)\n",
    "\n",
    "- Create a new notebook by clicking on \"New\" and select \"Python 3\" as the kernel you wish to run.\n",
    "\n",
    "![Jupyter Notebook create new](images/jupyter-02.png)\n",
    "\n",
    "- This is a new notebook and is what you should see:\n",
    "\n",
    "![Jupyter Notebook](images/jupyter-04.png)\n",
    "\n",
    "- You can get a tour of the notebook interface from `Help -> User Interface Tour`, or you can learn some shortcuts from `Help -> Keyboard shortcuts`.\n",
    "\n",
    "![Jupyter Notebook shortcuts](images/jupyter-03.png)\n",
    "\n",
    "You will need to launch Jupyter Notebooks every time you want to work on these tutorials. Remember to save your `.ipynb` files where you can easily find them. You can also download all of the notebooks from this repository and, if you're running them in Jupyter Notebook, you can run the code here, or click on the text to see how the MarkDown version of HTML is written to code this text.\n",
    "\n",
    "In the next section, you'll learn how to clone this repository.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>References:</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li><a href=\"https://www.anaconda.com/\">Anaconda</a></li>\n",
    "        <li><a href=\"https://jupyter.org/\">Project Jupyter</a></li>\n",
    "        <li><a href=\"https://docs.conda.io/projects/conda/en/4.6.0/_downloads/52a95608c49671267e40c689e0bc00ca/conda-cheatsheet.pdf\">Conda Cheatsheet</a></li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Version control and code management with Git and GitHub\n",
    "\n",
    "The following tutorial is adapted from [GitHub's 'Hello World' tutorial](https://guides.github.com/activities/hello-world/) and their [Git Handbook](https://guides.github.com/introduction/git-handbook/). GitHub is a particular implementation of Git. It happens to be where these lessons are hosted, but you are welcome to use any other service, such as [GitLab](https://about.gitlab.com/), [Bitbucket](https://bitbucket.org/) or even the venerable [SourceForge](https://sourceforge.net/).\n",
    "\n",
    "[Git](https://git-scm.com/) is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. Version control systems track the history of changes as people and teams collaborate on projects together. As the project evolves, teams can run tests, fix bugs, and contribute new code with the confidence that any version can be recovered at any time. \n",
    "\n",
    "Developers can review project history to find out:\n",
    "\n",
    "- Which changes were made?\n",
    "- Who made the changes?\n",
    "- When were the changes made?\n",
    "- Why were changes needed?\n",
    "\n",
    "Git itself runs from the command line (that is, in a terminal window, and outside of the more familiar graphical interface you use to interact with your computer's operating system). There are many commands to learn, but we'll only run through the most basic subset you need for now. Git has a [Basics Video Series](https://git-scm.com/video/get-going) you can follow to learn more.\n",
    "\n",
    "A _repository_, or Git project, encompasses the entire collection of files and folders associated with a project, along with each file’s revision history. The file history appears as snapshots in time called _commits_, and the commits exist as a linked-list relationship, and can be organized into multiple lines of development called _branches_. Because Git is a distributed version control system, repositories are self-contained units and anyone who owns a copy of the repository can access the entire codebase and its history. Using the command line or other ease-of-use interfaces, a git repository also allows for: interaction with the history, cloning, creating branches, committing, merging, comparing changes across versions of code, and more.\n",
    "\n",
    "Working in repositories keeps development projects organized and protected. Developers are encouraged to fix bugs, or create fresh features, without fear of derailing mainline development efforts. Git facilitates this through the use of topic branches: lightweight pointers to commits in history that can be easily created and deprecated when no longer needed.\n",
    "\n",
    "Through platforms like GitHub, Git also provides more opportunities for project transparency and collaboration. Public repositories help teams work together to build the best possible final product.\n",
    "\n",
    "This lesson, for example, exists in a public, open-source GitHub repository with Git version control.\n",
    "\n",
    "[GitHub](https://github.com) is a Git hosting repository that provides developers with tools to ship better code through command line features, issues (threaded discussions), pull requests, and code review. You can learn more about [GitHub's _flow_ here](https://guides.github.com/introduction/flow/).\n",
    "\n",
    "To complete the next part of this tutorial, you will need a [GitHub.com account](http://github.com/) and internet access. You don’t need to know how to code, use the command line, or install Git.\n",
    "\n",
    "![Create a GitHub Account](images/01-02-01-github-create-account.jpg)\n",
    "\n",
    "### Create a Tutorial Repository\n",
    "\n",
    "A _repository_ is usually used to organize a single project. Repositories can contain folders and files, images, videos, spreadsheets, and data sets – anything your project needs. We recommend including a README, or a file with information about your project. GitHub makes it easy to add one at the same time you create your new repository. It also offers other common options such as a license file.\n",
    "\n",
    "Your `hello-world` repository can be a place where you store ideas, resources, or even share and discuss things with others. You can call it anything you like, but you will need a repository for this lesson and subsequent tutorials, so you may as well use this as an opportunity to get started. Maybe call it `data-wrangling-course`.\n",
    "\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <b>For free GitHub accounts, everything you do is public. Don't store important personal information, or express behaviours, that may embarrass you or risk your safety.</b>\n",
    "</div>\n",
    "\n",
    "To create a new repository, you need to be logged in to your GitHub account. Then: \n",
    "\n",
    "- In the upper right corner, next to your avatar or identicon, click __+__ and then select __New repository__.\n",
    "- Name your repository `data-wrangling-course` (or whatever you prefer).\n",
    "- Write a short description.\n",
    "- Select __Initialize this repository with a README__.\n",
    "\n",
    "![Create new repo](images/github-create-new-repo.png)\n",
    "\n",
    "- Click __Create repository__.\n",
    "\n",
    "### Create a Branch\n",
    "\n",
    "_Branching_ is the way to work on different versions of a repository at one time.\n",
    "\n",
    "By default your repository has one branch named `master` which is considered to be the definitive branch. We use branches to experiment and make edits before committing them to `master`.\n",
    "\n",
    "When you create a branch off the `master` branch, you’re making a copy, or snapshot, of `master` as it was at that point in time. If someone else made changes to the master branch while you were working on your branch, you could pull in those updates.\n",
    "\n",
    "This diagram shows:\n",
    "\n",
    "- The `master` branch\n",
    "- A new branch called `feature` (because we're doing 'feature work' on this branch)\n",
    "- The journey that `feature` takes before it's merged into `master`\n",
    "\n",
    "![Branching](images/github-branching.png)\n",
    "\n",
    "Have you ever saved different versions of a file? Something like:\n",
    "\n",
    "- `story.txt`\n",
    "- `story-joe-edit.txt`\n",
    "- `story-joe-edit-reviewed.txt`\n",
    "\n",
    "Branches accomplish similar goals in GitHub repositories.\n",
    "\n",
    "At GitHub, developers, writers, and designers use branches for keeping bug fixes and feature work separate from master (production) branch. When a change is ready, they merge their branch into master.\n",
    "\n",
    "To create a new branch:\n",
    "\n",
    "- Go to your new repository `data-wrangling-course`.\n",
    "- Click the drop down at the top of the file list that says __branch: master__.\n",
    "- Type a branch name, `readme-edits`, into the new branch text box.\n",
    "- Select the blue __Create branch__ box or hit _Enter_ on your keyboard.\n",
    "\n",
    "![New branch](images/github-readme-edits.gif)\n",
    "\n",
    "Now you have two branches, `master` and `readme-edits`. They look exactly the same, but not for long! Next we’ll add our changes to the new branch.\n",
    "\n",
    "### Make and commit changes\n",
    "\n",
    "Now, you’re on the code view for your `readme-edits` branch, which is a copy of `master`. Let’s make some edits.\n",
    "\n",
    "On GitHub, saved changes are called _commits_. Each commit has an associated _commit message_, which is a description explaining why a particular change was made. Commit messages capture the history of your changes, so other contributors can understand what you’ve done and why.\n",
    "\n",
    "Make and commit changes:\n",
    "\n",
    "- Click the `README.md` file.\n",
    "- Click the pencil icon in the upper right corner of the file view to edit.\n",
    "- In the editor, write a bit about yourself.\n",
    "- Write a commit message that describes your changes.\n",
    "- Click __Commit changes__ button.\n",
    "\n",
    "![Commit](images/github-commit.png)\n",
    "\n",
    "These changes will be made to just the `README` file on your `readme-edits` branch, so now this branch contains content that’s different from `master`.\n",
    "\n",
    "### Open a Pull Request\n",
    "\n",
    "Now that you have changes in a branch off of `master`, you can open a _pull request_.\n",
    "\n",
    "Pull Requests are the heart of collaboration on GitHub. When you open a _pull request_, you’re proposing your changes and requesting that someone review and pull in your contribution and merge them into their branch. Pull requests show _diffs_, or differences, of the content from both branches. The changes, additions, and subtractions are shown in green and red.\n",
    "\n",
    "As soon as you make a commit, you can open a pull request and start a discussion, even before the code is finished.\n",
    "\n",
    "By using GitHub’s @mention system in your pull request message, you can ask for feedback from specific people or teams, whether they’re down the hall or 10 time zones away.\n",
    "\n",
    "You can even open pull requests in your own repository and merge them yourself. It’s a great way to learn the GitHub flow before working on larger projects.\n",
    "\n",
    "__Open a Pull Request for changes to the README:__\n",
    "\n",
    "| __Step__ | __Screenshot__                   |\n",
    "|:------------|:-------------------------|\n",
    "| Click the  __Pull Request__ tab, then from the Pull Request page, click the green __New pull request__ button.  | ![Pull Request tab](images/github-pr-tab.gif) |\n",
    "| In the __Example Comparisons__ box, select the branch you made, `readme-edits`, to compare with `master` (the original). | ![Pick Branch](images/github-pick-branch.png) |\n",
    "| Look over your changes in the diffs on the Compare page, make sure they’re what you want to submit. | ![Diff](images/github-diff.png) |\n",
    "| When you’re satisfied that these are the changes you want to submit, click the big green __Create Pull Request__ button. | ![Create Pull Request](images/github-create-pr.png) |\n",
    "| Give your pull request a title and write a brief description of your changes. | ![Pull Request Form](images/github-pr-form.png) |\n",
    "\n",
    "When you’re done with your message, click __Create pull request!__\n",
    "\n",
    "### Merge your Pull Request\n",
    "\n",
    "In this final step, it’s time to bring your changes together – merging your readme-edits branch into the master branch.\n",
    "\n",
    "- Click the green __Merge pull request__ button to merge the changes into master.\n",
    "- Click __Confirm merge__.\n",
    "- Go ahead and delete the branch, since its changes have been incorporated, with the __Delete branch__ button in the purple box.\n",
    "\n",
    "![Merge](images/github-merge-button.png)\n",
    "\n",
    "![Delete](images/github-delete-button.png)\n",
    "\n",
    "And that completes the GitHub tutorial. This is what you've done:\n",
    "\n",
    "- Created an open source repository\n",
    "- Started and managed a new branch\n",
    "- Changed a file and committed those changes to GitHub\n",
    "- Opened and merged a Pull Request\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    <p><b>Exercise:</b></p>\n",
    "    <p><a href=\"https://desktop.github.com/\">GitHub has a Desktop App</a> which you can use to manage your repositories and code directly from your computer. It has an easy-to-use UI for you and will make cloning, editing, pushing and pulling changes to your repositories much easier.</p>\n",
    "    <p>For this exercise:</p>\n",
    "    <ul>\n",
    "        <li><a href=\"https://help.github.com/en/desktop/getting-started-with-github-desktop\">Review <b>GitHub's desktop app</b> tutorial on your own.</a></li>\n",
    "        <li><a href=\"https://desktop.github.com/\">Install the app.</a></li>\n",
    "        <li>You don't have to, but you might find it easier to also <a href=\"https://notepad-plus-plus.org/downloads/\">install <b>Notepad++</b></a> to edit code and text.</li>\n",
    "        <li>Redo this GitHub tutorial, but directly via the app and on your own desktop. You can edit your `README` file in Notepad++, then save it and push your changes to your repository using the app.</li>\n",
    "        <li>You should create a code directory to save all your code projects. Being very neat and organised about code directories is critical to managing your repositories. Get into the habit now.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "In the next section, you'll start learning to code in Python.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Tutorials and References:</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li><a href=\"https://guides.github.com/activities/hello-world/\">GitHub's 'Hello World' tutorial</a></li>\n",
    "        <li><a href=\"https://git-scm.com/video/get-going/\">Git Basics Get Going</a></li>\n",
    "        <li><a href=\"http://guides.github.com/\">GitHub Guides</a></li>\n",
    "        <li><a href=\"http://youtube.com/githubguides\">GitHub YouTube channel</a></li>\n",
    "        <li><a href=\"https://desktop.github.com/\">GitHub Desktop App</a></li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Python basics\n",
    "\n",
    "Python is an interpreted language with a very simple syntax. The first step in learning any new language is producing \"Hello, World!\".\n",
    "\n",
    "You will have opened a new notebook in __Jupyter Notebook__:\n",
    "\n",
    "![Jupyter Notebook](images/jupyter-04.png)\n",
    "\n",
    "You should save this notebook in a folder dedicated to your tutorials for this course. Give it a name, like `Python coding tutorial 1`, or whatever works for you. You might end up with a directory tree that looks like this:\n",
    "\n",
    "    documents/github-code/data-wrangling-course/\n",
    "\n",
    "Note two things:\n",
    "\n",
    "- The dropdown menu item that says `code`\n",
    "- The layout of the text entry box below that (which starts with `In []:`)\n",
    "\n",
    "This specifies that this block is to be used for code. You can also use it for structured text blocks like this one by selecting `markdown` from the menu list. This tutorial won't teach `markdown`, but you can learn more [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).\n",
    "\n",
    "The tutorial which follows is similar to [Learn Python's](https://www.learnpython.org/), although here you will run the examples on your own computer.\n",
    "\n",
    "### Hello, World!\n",
    "\n",
    "For now, let's start with \"Hello, World!\".\n",
    "\n",
    "Type the below text into the code block in your notebook and hit `Ctrl-Enter` to execute the code:\n",
    "\n",
    "    print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You just ran your first program. See how Jupyter performs code highlighting for you, changing the colours of the text depending on the nature of the syntax used. `print` is a protected term and gets highlighted in green.\n",
    "\n",
    "This also demonstrates how useful Jupyter Notebook can be. You can treat this just like a document, saving the file, and storing the outputs of your program in the notebook. You could even email this to someone else and, if they have Jupyter Notebook, they could run the notebook and see what you have done. If you save your work in GitHub, you can share links with others on this course and get help or advice if you get stuck.\n",
    "\n",
    "From here on out, we'll simply move through the Python coding tutorial and learn syntax and methods for coding.\n",
    "\n",
    "### Indentation\n",
    "\n",
    "Python uses indentation to indicate parts of the code that needs to be executed together. Both tabs and spaces (usually four per level) are supported, and my preference is for tabs. This is the subject of mass debate, but don't worry about it. Whatever you decide to do is fine, but **do not - under any circumstances - mix tab indentation with space indentation.**\n",
    "\n",
    "In this exercise you'll assign a value to a variable, check to see if a comparison is true, and then - based on the result - print.\n",
    "\n",
    "First, spot the little `+` symbol on the menu bar just after the `save` symbol. Click that and you'll get a new box to type the following code into. When you're done, press `Ctrl-Enter` or the `Run` button."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is 1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "if x == 1:\n",
    "    # Indented ... and notice how Jupyter Notebook automatically indented for you\n",
    "    print(\"x is 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any non-protected text term can be a variable. Your `x` could just have easily been your name. Usually we name variables as descriptively as possible so that we can read algorithms like text (i.e. the code describes itself).\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>To assign a variable with a specific value, use <code>=</code></li>\n",
    "        <li>To test whether a variable has a specific value, use the boolean operators:</li>\n",
    "        <ul>\n",
    "            <li>equal: <code>==</code></li>\n",
    "            <li>not equal: <code>!=</code></li>\n",
    "            <li>greater-than: <code>&gt;</code></li>\n",
    "            <li>less-than: <code>&lt;</code></li>\n",
    "        </ul>\n",
    "        <li>You can also add helpful comments to your code with the <code>#</code> symbol. Any line starting with a <code>#</code> is not executed. I find it very useful to make detailed notes about my thinking since, often, when you come back to code later you can't remember why you did what you did, or what your code is even supposed to do.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "\n",
    "### Variables and Types\n",
    "\n",
    "Python is not \"statically-typed\". This means you do not have to declare all your variables before you can use them. You can create new variables whenever you want. Python is also \"object-oriented\", which means that every variable is an object. That will become more important the more experienced you get.\n",
    "\n",
    "Lets go through the core types of variables:\n",
    "\n",
    "#### Numbers\n",
    "\n",
    "Python supports two types of numbers: integers and floats. Integers are whole numbers (e.g. 7), while floats are fractional (e.g. 7.321). You can also convert integers to floats, and vice versa, but you need to be aware of the risks of doing so.\n",
    "\n",
    "Follow along with the code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "myint = 7\n",
    "print(myint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.0\n",
      "7.0\n"
     ]
    }
   ],
   "source": [
    "myfloat = 7.0\n",
    "print(myfloat)\n",
    "# Or you could convert the integer you already have\n",
    "myfloat = float(myint)\n",
    "# Note how the term `float` is green. It's a protected term.\n",
    "print(myfloat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# Now see what happens when you convert a float to an int\n",
    "myint = int(7.3)\n",
    "print(myint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how you lost precision when you converted a `float` to an `int`? Always be careful, since that could be the difference between a door which fits its frame, and one which is far too small.\n",
    "\n",
    "#### Strings\n",
    "\n",
    "Strings are the Python term for text. You can define these in either single or double quotes. I'll be using double quotes (since you often use a single quote inside text phrases).\n",
    "\n",
    "Try these examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Let's talk about apostrophes...\n"
     ]
    }
   ],
   "source": [
    "mystring = \"Hello, World!\"\n",
    "print(mystring)\n",
    "# and demonstrating how to use an apostrophe in a string\n",
    "mystring = \"Let's talk about apostrophes...\"\n",
    "print(mystring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also apply simple operators to your variables, or assign multiple variables simultaneously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Hello, World!\n",
      "3 4\n"
     ]
    }
   ],
   "source": [
    "one = 1\n",
    "two = 2\n",
    "three = one + two\n",
    "print(three)\n",
    "\n",
    "hello = \"Hello,\"\n",
    "world = \"World!\"\n",
    "helloworld = hello + \" \" + world\n",
    "print(helloworld)\n",
    "\n",
    "a, b = 3, 4\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, though, that mixing variable types causes problems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-a2961e4891f2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mone\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mtwo\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mhello\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "print(one + two + hello)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python will throw an error when you make a mistake like this and the error will give you as much detail as it can about what just happened. This is extremely useful when you're attempting to \"debug\" your code.\n",
    "\n",
    "In this case, you're told: `TypeError: unsupported operand type(s) for +: 'int' and 'str'`\n",
    "\n",
    "And the context should make it clear that you tried to combine two integer variables with a string.\n",
    "\n",
    "You can also combine strings with placeholders for variables:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Add variables to a string with F-strings, e.g. <code>F\"Variable {x}\"</code> will replace the <code>{x}</code> in the string with the value in the variable <code>x</code></li>\n",
    "        <li>Floating point numbers can get out of hand (imagine including a number with 30 decimal places in a string), and you can format this with <code>F\"Variable {x:10.4f}\"</code> where <code>10</code> is the amount of space allocated to the float (useful if you need to align a column of numbers; you can also leave this out to include all significant digits) and the <code>.4f</code> is the number of decimals after the point. Vary these as you need.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unformated variable: 33.33333333333333%\n",
      "Formatted variable: 33.333%\n",
      "Space formatted variable:       33.3%\n"
     ]
    }
   ],
   "source": [
    "variable = 1/3 * 100\n",
    "print(F\"Unformated variable: {variable}%\")\n",
    "print(F\"Formatted variable: {variable:.3f}%\")\n",
    "print(F\"Space formatted variable: {variable:10.1f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists\n",
    "\n",
    "`Lists` are an ordered list of any type of variable. You can combine as many variables as you like, and they could even be of multiple types. Ordinarily, unless you have a specific reason to do so, lists will contain variables of one type.\n",
    "\n",
    "You can also iterate over a list (use each item in a list in sequence).\n",
    "\n",
    "A list is placed between square brackets: `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "[2, 3]\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "mylist = []\n",
    "mylist.append(1)\n",
    "mylist.append(2)\n",
    "mylist.append(3)\n",
    "# Each item in a list can be addressed directly. \n",
    "# The first address in a Python list starts at 0\n",
    "print(mylist[0])\n",
    "# The last item in a Python list can be addressed as -1. \n",
    "# This is helpful when you don't know how long a list is likely to be.\n",
    "print(mylist[-1])\n",
    "# You can also select subsets of the data in a list like this\n",
    "print(mylist[1:3])\n",
    "\n",
    "# You can also loop through a list using a `for` statement.\n",
    "# Note that `x` is a new variable which takes on the value of each item in the list in order.\n",
    "for x in mylist:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you try access an item in a list that isn't there, you'll get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-46c3ae90a572>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmylist\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "print(mylist[10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's put this together with a slightly more complex example. But first, some new syntax:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Check what type of variable you have with <code>isinstance</code>, e.g. <code>isinstance(x, float)</code> will be <code>True</code> if x is a float</li>\n",
    "        <li>You've already seen <code>for</code>, but you can get the loop count by wrapping your list in the term <code>enumerate</code>, e.g. <code>for count, x in enumerate(mylist)</code> will give you a count for each item in the list</li>\n",
    "        <li>Sorting a list into numerical or alphabetical order can be done with <code>sort</code></li>\n",
    "        <li>Getting the number of items in a list is as simple as asking <code>len(list)</code></li>\n",
    "        <li>If you want to count the number of times a particular variable occurs in a list, use <code>list.count(x)</code> (where <code>x</code> is the variable you're interested in)</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "Try this for yourself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of names in list: 10\n",
      "Cleaned-up number of names in list: 4\n",
      "1. Eric\n",
      "2. Jessica\n",
      "3. John\n",
      "4. Lois\n"
     ]
    }
   ],
   "source": [
    "# Let's imagine we have a list of unordered names that somehow got some random numbers included.\n",
    "# For this exercise, we want to print the alphabetised list of names without the numbers.\n",
    "# This is not the best way of doing the exercise, but it will illustrate a whole bunch of techniques.\n",
    "names = [\"John\", 3234, 2342, 3323, \"Eric\", 234, \"Jessica\", 734978234, \"Lois\", 2384]\n",
    "print(F\"Number of names in list: {len(names)}\")\n",
    "# First, let's get rid of all the weird integers.\n",
    "new_names = []\n",
    "for n in names:\n",
    "    if isinstance(n, str):\n",
    "        # Checking if n is a string\n",
    "        # And note how we're now indented twice into this new component\n",
    "        new_names.append(n)\n",
    "# We should now have only names in the new list. Let's sort them.\n",
    "new_names.sort()\n",
    "print(F\"Cleaned-up number of names in list: {len(new_names)}\")\n",
    "# Lastly, let's print them.\n",
    "for i, n in enumerate(new_names):\n",
    "    # Using both i and n in a formated string\n",
    "    # Adding 1 to i because lists start at 0\n",
    "    print(F\"{i+1}. {n}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries\n",
    "\n",
    "Dictionaries are one of the most useful and versatile data types in Python. They're similar to arrays, but consist of `key:value pairs`. Each value stored in a dictionary is accessed by its key, and the value can be any sort of object (string, number, list, etc.).\n",
    "\n",
    "This allows you to create structured records. Dictionaries are placed within `{}`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'John': {'Phone': '012 794 794', 'Email': 'john@email.com'}, 'Jill': {'Phone': '012 345 345', 'Email': 'jill@email.com'}, 'Joss': {'Phone': '012 321 321', 'Email': 'joss@email.com'}}\n"
     ]
    }
   ],
   "source": [
    "phonebook = {}\n",
    "phonebook[\"John\"] = {\"Phone\": \"012 794 794\",\n",
    "                     \"Email\": \"john@email.com\"}\n",
    "phonebook[\"Jill\"] = {\"Phone\": \"012 345 345\",\n",
    "                     \"Email\": \"jill@email.com\"}\n",
    "phonebook[\"Joss\"] = {\"Phone\": \"012 321 321\",\n",
    "                     \"Email\": \"joss@email.com\"}\n",
    "print(phonebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that you can nest dictionaries and lists. The above shows you how you can add values to an existing dictionary, or create dictionaries with values.\n",
    "\n",
    "You can iterate over a dictionary just like a list, using the dot term `.items()`. In Python 3, the dictionary maintains the order in which data were added, but older versions of Python don't."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John's phone number is 012 794 794, and their email is john@email.com\n",
      "Jill's phone number is 012 345 345, and their email is jill@email.com\n",
      "Joss's phone number is 012 321 321, and their email is joss@email.com\n"
     ]
    }
   ],
   "source": [
    "for name, record in phonebook.items():\n",
    "    print(F\"{name}'s phone number is {record['Phone']}, and their email is {record['Email']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You add new records as shown above, and you remove records with `del` or `pop`. They each have a different effect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jill's phone number is 012 345 345, and their email is jill@email.com\n",
      "Joss's phone number is 012 321 321, and their email is joss@email.com\n",
      "{'Phone': '012 345 345', 'Email': 'jill@email.com'}\n",
      "Joss's phone number is 012 321 321, and their email is joss@email.com\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'John'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-24fe1d3ad744>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[1;31m# If you try and delete a record that isn't in the dictionary, you get an error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m \u001b[1;32mdel\u001b[0m \u001b[0mphonebook\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"John\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'John'"
     ]
    }
   ],
   "source": [
    "# First `del`\n",
    "del phonebook[\"John\"]\n",
    "for name, record in phonebook.items():\n",
    "    print(\"{}'s phone number is {}, and their email is {}\".format(name, record[\"Phone\"], record[\"Email\"]))\n",
    "\n",
    "# Pop returns the record, and deletes it\n",
    "jill_record = phonebook.pop(\"Jill\")\n",
    "print(jill_record)\n",
    "for name, record in phonebook.items():\n",
    "    # You can see that only Joss is still left in the system\n",
    "    print(\"{}'s phone number is {}, and their email is {}\".format(name, record[\"Phone\"], record[\"Email\"]))\n",
    "\n",
    "# If you try and delete a record that isn't in the dictionary, you get an error\n",
    "del phonebook[\"John\"] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing to get into the habit of doing, is to test variables before assuming they have characteristics you're looking for. You can test a dictionary to see if it has a record, and return some default answer if it doesn't have it.\n",
    "\n",
    "You do this with the `.get(\"key\", default)` term. `Default` can be anything, including another variable, or simply `True` or `False`. If you leave `default` blank (i.e. `.get(\"key\")`), then the result will automatically be `False` if there is no record."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No record found.\n"
     ]
    }
   ],
   "source": [
    "# False and True are special terms in Python that allow you to set tests\n",
    "jill_record = phonebook.get(\"Jill\", False)\n",
    "if jill_record: # i.e. if you got a record in the previous step\n",
    "    print(F\"Jill's phone number is {jill_record['Phone']}, and their email is {jill_record['Email']}\")\n",
    "else: # the alternative, if `if` returns False\n",
    "    print(\"No record found.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic operators\n",
    "\n",
    "Operators are the various algebraic symbols (such as `+`, `-`, `*`, `/`, `%`, etc.). Once you've learned the syntax, programming is mostly mathematics.\n",
    "\n",
    "#### Arithmetic operators\n",
    "\n",
    "As you would expect, you can use the various mathematical operators with numbers (both integers and floats)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n",
      "2\n",
      "49\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "number = 1 +2 * 3 / 4.0\n",
    "# Try to predict what the answer will be ... does Python follow order operations hierarchy?\n",
    "print(number)\n",
    "\n",
    "# The modulo (%) returns the integer remainder of a division\n",
    "remainder = 11 % 3\n",
    "print(remainder)\n",
    "\n",
    "# Two multiplications is equivalent to a power operation\n",
    "squared = 7 ** 2\n",
    "print(squared)\n",
    "cubed = 2 ** 3\n",
    "print(cubed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 2, 4, 6, 8]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "even_numbers = [2, 4, 6, 8]\n",
    "# One of my first teachers in school said, \"People are odd. Numbers are uneven.\"\n",
    "# He also said, \"Cecil John Rhodes always ate piles of unshelled peanuts in parliament in Cape Town.\"\n",
    "# \"You'd know he'd been in parliament by the huge pile of shells on the floor. He also never wore socks.\"\n",
    "# \"You'll never forget this.\" And I didn't. I have no idea if it's true.\n",
    "uneven_numbers = [1, 3, 5, 7]\n",
    "all_numbers = uneven_numbers + even_numbers\n",
    "# What do you think will happen?\n",
    "print(all_numbers)\n",
    "\n",
    "# You can also repeat sequences of lists\n",
    "print([1, 2 , 3] * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can put this together into a small project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_list contains 1 objects\n",
      "y_list contains 1 objects\n",
      "big_list contains 0 objects\n"
     ]
    }
   ],
   "source": [
    "x = object() # A generic Python object\n",
    "y = object()\n",
    "\n",
    "# Change this code to ensure that x_list and y_list each have 10 repeating objects\n",
    "# and concat_list is the concatenation of x_list and y_list\n",
    "x_list = [x]\n",
    "y_list = [y]\n",
    "concat_list = []\n",
    "\n",
    "print(F\"x_list contains {len(x_list)} objects\")\n",
    "print(F\"y_list contains {len(y_list)} objects\")\n",
    "print(F\"big_list contains {len(concat_list)} objects\")\n",
    "\n",
    "# Test your lists\n",
    "if x_list.count(x) == 10 and y_list.count(y) == 10:\n",
    "    print(\"Almost there...\")\n",
    "if concat_list.count(x) == 10 and concat_list.count(y) == 10:\n",
    "    print(\"Great!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String operators\n",
    "\n",
    "You can do a surprising amount with operators on strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello Hello Hello Hello Hello Hello Hello Hello Hello Hello \n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-24-b66f17ae47c7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;31m# But don't get carried away. Not everything will work.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m \u001b[0mnohellos\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"Hello \"\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnohellos\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "# You've already seen arithmetic concatenations of strings\n",
    "helloworld = \"Hello,\" + \" \" + \"World!\"\n",
    "print(helloworld)\n",
    "\n",
    "# You an also multiply strings to form a repeating sequence\n",
    "manyhellos = \"Hello \" * 10\n",
    "print(manyhellos)\n",
    "\n",
    "# But don't get carried away. Not everything will work.\n",
    "nohellos = \"Hello \" / 10\n",
    "print(nohellos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Something to keep in mind is that strings are lists of characters. This means you can perform a number of list operations on strings. And a few new operations.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Get the index for the first occurrence of a specific letter with <code>string.index(\"l\")</code> where <code>l</code> is the letter you're looking for</li>\n",
    "        <li>As in lists, count the number of occurrences of a specific letter with <code>string.count(\"l\")</code></li>\n",
    "        <li>Get slices of strings with <code>string[start:end]</code>, e.g. <code>string[3:7]</code>. If you're unsure of the end of a string, remember you can use negative numbers to count from the end, e.g. <code>string[:-3]</code> to get a slice from the first character to the third from the end</li>\n",
    "        <li>You can also \"step\" through a string with <code>string[start:stop:step]</code>, e.g. <code>string[2:6:2]</code> which will skip a character between the characters 2 and 5 (i.e. 6 is the boundary)</li>\n",
    "        <li>You can use a negative \"step\" to reverse the order of the characters, e.g. <code>string[::-1]</code></li>\n",
    "        <li>You can convert strings to upper- or lower-case with <code>string.upper()</code> and <code>string.lower()</code></li>\n",
    "        <li>Test whether a string starts or ends with a substring with:</li>\n",
    "        <ul>\n",
    "            <li><code>string.startswith(substring)</code> which returns <code>True</code> or <code>False</code></li>\n",
    "            <li><code>string.endswith(substring)</code> which returns <code>True</code> or <code>False</code></li>\n",
    "        </ul>\n",
    "        <li>Use <code>in</code> to test whether a string contains a substring, so <code>substring in string</code> will return <code>True</code> or <code>False</code></li>\n",
    "        <li>You can split a string into a genuine list with <code>.split(s)</code> where <code>s</code> is the specific character to use for splitting, e.g. <code>s = \",\"</code> or <code>s = \" \"</code>. You can see how this might be useful to split up text which contains numeric data.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String length: 13\n",
      "Index for first 'o': 4\n",
      "Count of 'o': 2\n",
      "Slicing between second and fifth characters: llo,\n",
      "Skipping between 3rd and 2nd-from-last characters: l,Wr\n",
      "Reverse text: !dlroW ,olleH\n",
      "Starts with 'Hello': True\n",
      "Ends with 'Hello': False\n",
      "Contains 'Goodbye': False\n",
      "Split the string: ['Hello,', 'World!']\n"
     ]
    }
   ],
   "source": [
    "a_string = \"Hello, World!\"\n",
    "print(F\"String length: {len(a_string)}\")\n",
    "# You can get an index of the first occurence of a specific letter\n",
    "# Remember that Python lists are based at 0; the first letter is index 0\n",
    "# Also note the use of single quotes inside the double quotes\n",
    "print(F\"Index for first 'o': {a_string.index('o')}\")\n",
    "print(F\"Count of 'o': {a_string.count('o')}\")\n",
    "print(F\"Slicing between second and fifth characters: {a_string[2:6]}\")\n",
    "print(F\"Skipping between 3rd and 2nd-from-last characters: {a_string[3:-2:2]}\")\n",
    "print(F\"Reverse text: {a_string[::-1]}\")\n",
    "print(F\"Starts with 'Hello': {a_string.startswith('Hello')}\")\n",
    "print(F\"Ends with 'Hello': {a_string.endswith('Hello')}\")\n",
    "print(F\"Contains 'Goodbye': {'Goodby' in a_string}\")\n",
    "print(F\"Split the string: {a_string.split(' ')}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditions\n",
    "\n",
    "In the section on [Indentation](#Indentation) you were introduced to the `if` statement and the set of `boolean` operators that allow you to test different variables against each other.\n",
    "\n",
    "To that list of boolean operators are added a new set of comparisons: `and`, `or` and `in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Simple boolean tests\n",
    "x = 2\n",
    "print(x == 2)\n",
    "print(x == 3)\n",
    "print(x < 3)\n",
    "\n",
    "# Using `and`\n",
    "name = \"John\"\n",
    "print(name == \"John\" and x == 2)\n",
    "\n",
    "# Using `or`\n",
    "print(name == \"John\" or name == \"Jill\")\n",
    "\n",
    "# Using `in` on lists\n",
    "print(name in [\"John\", \"Jill\", \"Jess\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These can be used to create nuanced comparisons using `if`. You can use a series of comparisons with `if`, `elif` and `else`.\n",
    "\n",
    "Remember that code must be indented correctly or you will get unexpected behaviour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x > 2\n",
      "x == 2\n"
     ]
    }
   ],
   "source": [
    "# Unexpected results\n",
    "x = 2\n",
    "if x > 2:\n",
    "    print(\"Testing x\")\n",
    "print(\"x > 2\")\n",
    "# Formated correctly\n",
    "if x == 2:\n",
    "    print(\"x == 2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x < 10 or y > 50\n"
     ]
    }
   ],
   "source": [
    "# Demonstrating more complex if tests\n",
    "x = 2\n",
    "y = 10\n",
    "if x > 2:\n",
    "    print(\"x > 2\")\n",
    "elif x == 2 and y > 50:\n",
    "    print(\"x == 2 and y > 50\")\n",
    "elif x < 10 or y > 50:\n",
    "    # But, remember, you don't know WHICH condition was True\n",
    "    print(\"x < 10 or y > 50\")\n",
    "else:\n",
    "    print(\"Nothing worked.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two special cases are `not` and `is`.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li><code>not</code> is used to get the opposite of a particular boolean test, e.g. <code>not(False)</code> returns <code>True</code></li>\n",
    "        <li><code>is</code> would seem, superficially, to be similar to <code>==</code>, but it tests for whether the actual objects are the same, not whether the values which the objects reflect are equal.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\n",
    "A quick demonstration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "John is John: True\n",
      "John is Jill: False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Using `not`\n",
    "name_list1 = [\"John\", \"Jill\"]\n",
    "name_list2 = [\"John\", \"Jill\"]\n",
    "print(not(name_list1 == name_list2))\n",
    "\n",
    "# Using `is`\n",
    "name2 = \"John\"\n",
    "for n in name_list1:\n",
    "    print(F\"{name2} is {n}: {name2 is n}\")\n",
    "print(name_list1 == name_list2)\n",
    "print(name_list1 is name_list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops\n",
    "\n",
    "Loops iterate over a given sequence, and - here - it is critical to ensure your indentation is correct or you'll get unexpected results for what is considered inside or outside the loop.\n",
    "\n",
    "There are two types of loop in Python:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>For loops, <code>for</code>, which loop through a list. There is also some new syntax to use in <code>for</code> loops:</li>\n",
    "        <ul>\n",
    "            <li>In <a href=\"#Lists\">Lists</a> you saw <code>enumerate</code>, which allows you to count the loop number</li>\n",
    "            <li>Range creates a list of integers to loop, <code>range(start, stop)</code> creates a list of integers between start and stop, or <code>range(num)</code> creates a zero-based list up to num, or <code>range(start, stop, step)</code> steps through a list in increments of step</li>\n",
    "        </ul>\n",
    "        <li>While loops, <code>while</code>, which execute while a particular condition is <code>True</code>. And some new syntax for <code>while</code>:</li>\n",
    "        <ul>\n",
    "            <li><code>while</code> is a conditional statement (it requires a test to return <code>True</code>), that means we can use <code>else</code> in a <code>while</code> loop (but not <code>for</code>)</li>\n",
    "        </ul>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Range 2\n",
      "2. Range 4\n",
      "3. Range 6\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "End of while loop reached\n"
     ]
    }
   ],
   "source": [
    "# For loops\n",
    "\n",
    "for i, x in enumerate(range(2, 8, 2)):\n",
    "    print(F\"{i+1}. Range {x}\")\n",
    "    \n",
    "# While loops\n",
    "count = 0\n",
    "while count < 5:\n",
    "    print(count)\n",
    "    count += 1 # A shorthand for count = count + 1\n",
    "else:\n",
    "    print(\"End of while loop reached\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pay close attention to the indentation in that `while` loop. What would happen if `count += 1` were outside the loop?\n",
    "\n",
    "What happens if you need to exit loops early, or miss a step?\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li><code>break</code> exits a <code>while</code> or <code>for</code> loop immediately</li>\n",
    "        <li><code>continue</code> skips the current loop and returns to the loop conditional</li>\n",
    "    </ul>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Break and while conditional\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "Continue\n",
      "0\n",
      "2\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Break and while conditional\n",
    "print(\"Break and while conditional\")\n",
    "count = 0\n",
    "while True:\n",
    "    # You may think this would run forever, but ...\n",
    "    print(count)\n",
    "    count += 1\n",
    "    if count >= 5:\n",
    "        break\n",
    "\n",
    "# Continue\n",
    "print(\"Continue\")\n",
    "for x in range(8):\n",
    "    # Check if x is uneven\n",
    "    if (x+1) % 2 == 0:\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehensions\n",
    "\n",
    "One of the common tasks in coding is to go through a list of items, edit or apply some form of algorithm, and return a new list.\n",
    "\n",
    "Writing long stretches of code to accomplish this is tedious and time-consuming. List comprehensions are an efficient and concise way of achieving exactly that.\n",
    "\n",
    "As an example, imagine we have a sentence where we want to count the length of each word but skip all the \"the\"s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 3, 5, 3, 11, 4, 2, 2, 7, 3, 1, 2, 4, 4, 10, 3, 1, 2, 4, 10]\n",
      "[3, 4, 3, 5, 3, 11, 4, 2, 2, 7, 3, 1, 2, 4, 4, 10, 3, 1, 2, 4, 10]\n"
     ]
    }
   ],
   "source": [
    "sentence = \"for the song and the sword are birthrights sold to an usurer, but I am the last lone highwayman and I am the last adventurer\"\n",
    "words = sentence.split()\n",
    "word_lengths = []\n",
    "for word in words:\n",
    "      if word != \"the\":\n",
    "            word_lengths.append(len(word))\n",
    "print(word_lengths)\n",
    "\n",
    "# The exact same thing can be achieved with a list comprehension\n",
    "word_lengths = [len(word) for word in sentence.split(\" \") if word != \"the\"]\n",
    "print(word_lengths)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exception handling\n",
    "\n",
    "For the rest of this section of the tutorial, we're going to focus on some more advanced syntax and methodology.\n",
    "\n",
    "In [Strings](#Strings) you say how the instruction to concatenate a string with an integer using the `+` operator resulted in an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-36-778236ccec55>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m\"hello\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "print(1 + \"hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, this is known as an `exception`. The particular exception here is a `TypeError`. Getting exceptions is critical to coding, because it permits you to fix syntax errors, catch glitches where you pass the wrong variables, or your code behaves in unexpected ways.\n",
    "\n",
    "However, once your code goes into production, errors that stop your program entirely are frustrating for the user. More often than not, there is no way to exclude errors and sometimes the only way to find something out is to try it and see if the function causes an error. \n",
    "\n",
    "Many of these errors are entirely expected. For example, if you need a user to enter an integer, you want to prevent them typing in text. Or - in this era of mass hacking - you want to prevent a user trying to including their own code in a text field.\n",
    "\n",
    "When this happens what you want is to way to try to execute your code and then catch any expected exceptions safely.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Test and catch exceptions with <code>try</code> and <code>except</code></li>\n",
    "        <li>Catch specific errors, rather than all errors, since you still need to know about anything unexpected ... otherwise you can spend hours trying to find a mistake which is being deliberately ignored by your program.</li>\n",
    "        <li>Chain exceptions with, e.g. <code>except (IndexError, TypeError):</code>. Here is a link to all the <a href=\"https://docs.python.org/3/library/exceptions.html\">common exceptions</a>.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "0\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# An `IndexError` is thrown when you try to address an index in a list that does not exist\n",
    "# In this example, let's catch that error and do something else\n",
    "\n",
    "def print_list(l):\n",
    "    \"\"\"\n",
    "    For a given list `l`, of unknown length, try to print out the first\n",
    "    10 items in the list.\n",
    "    \n",
    "    If the list is shorter than 10, fill in the remaining items with `0`.\n",
    "    \"\"\"\n",
    "    for i in range(10):\n",
    "        try:\n",
    "            print(l[i])\n",
    "        except IndexError: \n",
    "            print(0)\n",
    "\n",
    "print_list([1,2,3,4,5,6,7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also deliberately trigger an exception with `raise`. To go further, and write your own types of exceptions, consider [this explanation](https://stackoverflow.com/a/26938914)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Not Zero!",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-45-a5b85de8b30c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzero\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint_zero\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-45-a5b85de8b30c>\u001b[0m in \u001b[0;36mprint_zero\u001b[1;34m(zero)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mprint_zero\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzero\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mzero\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m         \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Not Zero!\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzero\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Not Zero!"
     ]
    }
   ],
   "source": [
    "def print_zero(zero):\n",
    "    if zero != 0:\n",
    "        raise ValueError(\"Not Zero!\")\n",
    "    print(zero)\n",
    "\n",
    "print_zero(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "\n",
    "Sets are lists with no duplicate entries. You could probably write a sorting algorithm, or dictionary, to achieve the same end, but sets are faster and more flexible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'wet', 'is', 'rain', 'the', 'and'}\n"
     ]
    }
   ],
   "source": [
    "# Extract all unique terms in this sentence\n",
    "\n",
    "print(set(\"the rain is wet and wet is the rain\".split()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Create a unique set of terms with <code>set</code></li>\n",
    "        <li>To get members of a set common to both of two sets, use <code>set1.intersection(set2)</code></li>\n",
    "        <li>Get the unique members of each of one set and another, use <code>set1.symmetric_difference(set2)</code></li>\n",
    "        <li>To get the unique members from the asking set (i.e. the one calling the dot function), use <code>set1.difference(set2)</code></li>\n",
    "        <li>To get all the members of each of two lists, use <code>set1.union(set2)</code></li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set One intersection: {'Eve', 'Dan', 'Heidi'}\n",
      "Set Two intersection: {'Eve', 'Dan', 'Heidi'}\n",
      "Set One symmetric difference: {'Alice', 'Carol', 'Grace', 'Bob'}\n",
      "Set Two symmetric difference: {'Alice', 'Carol', 'Grace', 'Bob'}\n",
      "Set One difference: {'Alice', 'Carol'}\n",
      "Set Two difference: {'Grace', 'Bob'}\n",
      "Set One union: {'Alice', 'Dan', 'Heidi', 'Bob', 'Eve', 'Carol', 'Grace'}\n",
      "Set Two union: {'Alice', 'Dan', 'Heidi', 'Bob', 'Eve', 'Carol', 'Grace'}\n"
     ]
    }
   ],
   "source": [
    "set_one = set([\"Alice\", \"Carol\", \"Dan\", \"Eve\", \"Heidi\"])\n",
    "set_two = set([\"Bob\", \"Dan\", \"Eve\", \"Grace\", \"Heidi\"])\n",
    "\n",
    "# Intersection\n",
    "print(F\"Set One intersection: {set_one.intersection(set_two)}\")\n",
    "print(F\"Set Two intersection: {set_two.intersection(set_one)}\")\n",
    "\n",
    "# Symmetric difference\n",
    "print(F\"Set One symmetric difference: {set_one.symmetric_difference(set_two)}\")\n",
    "print(F\"Set Two symmetric difference: {set_two.symmetric_difference(set_one)}\")\n",
    "\n",
    "# Difference\n",
    "print(F\"Set One difference: {set_one.difference(set_two)}\")\n",
    "print(F\"Set Two difference: {set_two.difference(set_one)}\")\n",
    "\n",
    "# Union\n",
    "print(F\"Set One union: {set_one.union(set_two)}\")\n",
    "print(F\"Set Two union: {set_two.union(set_one)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And that marks the end of this section of the tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 Intermediate Python\n",
    "\n",
    "The code from <a href=\"#2.1.3 Python basics\">Python basics</a> was limited to short snippets. Solving more complex problems means more complex code stretching over hundreds, to thousands, of lines, and - if you want to reuse that code - it's not convenient to copy and paste it multiple times. Worse, any error is magnified, and any changes become tedious to manage.\n",
    "\n",
    "It would be far better to write a discrete module to contain that task, get it absolutely perfect, and call it whenever you want the same problem solved or task executed.\n",
    "\n",
    "In software, this process of packaging up discrete functions into their own modular code is called \"abstraction\". A complete software system consists of a number of discrete modules all interacting to produce an integrated experience.\n",
    "\n",
    "In Python, these modules are called `functions` and a complete suite of functions grouped around a set of related tasks is called a `library` or `module`. Libraries permit you to inherit a wide variety of powerful software solutions developed and maintained by other people.\n",
    "\n",
    "Python is [open source](https://en.wikipedia.org/wiki/Open-source_software), which means that its source code is released under a licence which permits anyone to study, change, and distribute the software to anyone and for any purpose. Many of the most popular Python libraries are also open source. There are thousands of shared libraries for you to use, and - maybe, when you feel confident enough - to contribute to with your own code.\n",
    "\n",
    "### Functions\n",
    "\n",
    "Functions are callable modules of code, some with parameters or arguments (variables you can pass to the function), which performs a task and may return a value. They're a convenient way to package code into discrete blocks, making your overall program more readable, reusable, and saving time.\n",
    "\n",
    "You can also easily share your functions with others, saving them time as well. I snuck one in the section on __Exception handling__ earlier.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>You structure a function using <code>def</code>, like so:</li>\n",
    "        <code>def function_name(parameters):\n",
    "         code\n",
    "         return response</code>\n",
    "        <li><code>return</code> is optional, but allows you to return the results of any task performed by the function to the point where the function was called</li>\n",
    "        <li>To test whether an object is a function (i.e. callable), use <code>callable</code>, e.g. <code>callable(function)</code> will return <code>True</code></li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# A simple function with no arguments\n",
    "def say_hello():\n",
    "    print(\"Hello, World!\")\n",
    "\n",
    "# Calling it is as simple as this\n",
    "say_hello()\n",
    "\n",
    "# And you can test that it's a callable\n",
    "print(callable(say_hello))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An argument can be any variable, such as integers, strings, lists, dictionaries or even other functions. This is where you start realising the importance of leaving comments and explanations in your code because you need to ensure that anyone using a function knows what variables the function expects, and in what order.\n",
    "\n",
    "Functions can also perform calculations and return these to whatever called them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Jill! I hope you have a great day.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A function with two string arguments\n",
    "def say_hello_to_user(username, greeting):\n",
    "    # Returns a greeting to a username\n",
    "    print(F\"Hello, {username}! I hope you have a great {greeting}.\")\n",
    "\n",
    "# Call it\n",
    "say_hello_to_user(\"Jill\", \"day\")\n",
    "\n",
    "# Perform a calculation and return it\n",
    "def sum_two_numbers(x, y):\n",
    "    # Returns the sum of x + y\n",
    "    return x + y\n",
    "\n",
    "sum_two_numbers(5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that swapping `username` and `greeting` in the `say_hello_to_user` function would be confusing, but swapping the numbers in `sum_two_numbers` wouldn't cause a problem.\n",
    "\n",
    "Not only can you call functions from functions, but you can also create variables that are functions, or the result of functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "625\n"
     ]
    }
   ],
   "source": [
    "def number_powered(number, exponent):\n",
    "    # Returns number to the power of exponent\n",
    "    return number ** exponent\n",
    "\n",
    "# Jupyter keeps functions available that were called in other cells\n",
    "# This means `sum_two_numbers` is still available\n",
    "def sum_and_power(number1, number2, exponent):\n",
    "    # Returns two numbers summed, and then to an exponent\n",
    "    summed = sum_two_numbers(number1, number2)\n",
    "    return number_powered(summed, exponent)\n",
    "\n",
    "# Call `sum_and_power`\n",
    "print(sum_and_power(2, 3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With careful naming, and plenty of commentary, you can see how you can make your code extremely readable and self-explanatory.\n",
    "\n",
    "A better way of writing comments in functions is called `docstrings`. \n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Docstrings are written as structured text between three sets of inverted commas, e.g. <code>\"\"\" This is a docstring \"\"\"</code></li>\n",
    "        <li>You can access a function's docstring by calling <code>function.__doc__</code></li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    An example function which returns `True`.\n",
      "    \n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def docstring_example():\n",
    "    \"\"\"\n",
    "    An example function which returns `True`.\n",
    "    \"\"\"\n",
    "    return True\n",
    "\n",
    "# Printing the docstring\n",
    "print(docstring_example.__doc__)\n",
    "\n",
    "# Calling it\n",
    "print(docstring_example())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes and Objects\n",
    "\n",
    "A complete Python object is an encapsulation of both variables and functions into a single entity. Objects get their variables and functions from `classes`.\n",
    "\n",
    "Classes are where most of the action happens in Python and coding consists, largely, of producing and using classes to perform tasks. \n",
    "\n",
    "A very basic class would look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Look, a variable!\n",
      "I'm a class function!\n",
      "\n",
      "    A demonstration class.\n",
      "    \n",
      "\n",
      "        A demonstration class function.\n",
      "        \n"
     ]
    }
   ],
   "source": [
    "class myClass:\n",
    "    \"\"\"\n",
    "    A demonstration class.\n",
    "    \"\"\"\n",
    "    my_variable = \"Look, a variable!\"\n",
    "    \n",
    "    def my_function(self):\n",
    "        \"\"\"\n",
    "        A demonstration class function.\n",
    "        \"\"\"\n",
    "        return \"I'm a class function!\"\n",
    "\n",
    "# You call a class by creating a new class object\n",
    "new_class = myClass()\n",
    "\n",
    "# You can access class variables or functions with a dotted call, as follows\n",
    "print(new_class.my_variable)\n",
    "print(new_class.my_function())\n",
    "\n",
    "# Access the class docstrings\n",
    "print(myClass.__doc__)\n",
    "print(myClass.my_function.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's unpack the new syntax.\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>You instantiate a class by calling it as <code>class()</code>. If you only called <code>class</code>, without the brackets, you'd gain access to the object itself. This is useful as well, and means you can pass classes around as you would variables.</li>\n",
    "        <li>All variables and functions of a class are reached via the dotted call, <code>.function()</code> or <code>.variable</code>. You can even add new functions and variables to a class you created. Remember, though, these will not exist in new classes you create since you haven't changed the underlying code.</li>\n",
    "        <li>Functions within a class require a base argument that, by convention, is called <code>self</code>. There's a complex explanation as to why <code>self</code> is needed, but - briefly - think of it as the instance of the object itself. So, inside the class, <code>self.function</code> is the way the class calls its component functions.</li>\n",
    "        <li>You can also access the docstrings as you would before.</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi, Bob! Look, a variable!\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'myClass' object has no attribute 'my_variable2'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-544fecdbf014>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;31m# But, trying to access my_variable2 in new_class causes an error\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnew_class\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmy_variable2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'myClass' object has no attribute 'my_variable2'"
     ]
    }
   ],
   "source": [
    "# Add a new variable to a class instance\n",
    "new_class1 = myClass()\n",
    "new_class1.my_variable2 = \"Hi, Bob!\"\n",
    "print(new_class1.my_variable2, new_class1.my_variable)\n",
    "\n",
    "# But, trying to access my_variable2 in new_class causes an error\n",
    "print(new_class.my_variable2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes can initialise themselves with a set of available variables. This makes the `self` referencing more explicit, and also permits you to pass arguments to your class to set the initial values.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>Syntax</b>\n",
    "    <br>\n",
    "    <ul>\n",
    "        <li>Initialise a class with the special function <code>def __init__(self)</code></li>\n",
    "        <li>Pass arguments to your functions with <code>__init__(self, arguments)</code></li>\n",
    "        <li>We can also differentiate between arguments, and keyword arguments:</li>\n",
    "        <ul>\n",
    "            <li><b>arguments</b>: these are passed in the usual way, as a single term, e.g. <code>my_function(argument)</code>.</li>\n",
    "            <li><b>keyword arguments</b>: these are passed the way you would think of a dictionary, e.g. <code>my_function(keyword_argument = value)</code>. This is also a way to initialise an argument with a default. If you leave out the argument when it has a default it will apply without the function failing.</li>\n",
    "            <li>Functions often need to have numerous arguments and keyword arguments passed to them, and this can get messy. You can also think of a list of arguments like a list, and a list of keyword arguments like a dictionary. A tidier way to deal with this is to reference your arguments and keyword arguments like this, <code>my_function(*args, **kwargs)</code> where <code>*args</code> will be available to the function as an ordered list, and <code>**kwargs</code> as a dictionary.</li>\n",
    "        </ul>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World! None\n",
      "Hello, World! Bob\n",
      "Arg 1: Alice\n",
      "Arg 2: Bob\n",
      "Arg 3: Carol\n",
      "Arg 4: Dave\n",
      "Alice - Engineer\n",
      "Bob - Consultant\n",
      "Carol - Lawyer\n",
      "Dave - Doctor\n",
      "Hello, World!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A demonstration of all these new concepts\n",
    "\n",
    "class demoClass:\n",
    "    \"\"\"\n",
    "    A demonstration class with an __init__ function, and a function that takes args and kwargs.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, argument = None):\n",
    "        \"\"\"\n",
    "        A function that is called automatically when the demoClass is initialised.\n",
    "        \"\"\"\n",
    "        self.demo_variable = \"Hello, World!\"\n",
    "        self.initial_variable = argument\n",
    "        \n",
    "    def demo_class(self, *args, **kwargs):\n",
    "        \"\"\"\n",
    "        A demo class that loops through any args and kwargs provided and prints them.\n",
    "        \"\"\"\n",
    "        for i, a in enumerate(args):\n",
    "            print(\"Arg {}: {}\".format(i+1, a))\n",
    "        for k, v in kwargs.items():\n",
    "            print(\"{} - {}\".format(k, v))\n",
    "        if kwargs.get(self.initial_variable):\n",
    "            print(self.demo_variable)\n",
    "        return True\n",
    "\n",
    "demo1 = demoClass()\n",
    "demo2 = demoClass(\"Bob\")\n",
    "\n",
    "# What was initialised in each demo object?\n",
    "print(demo1.demo_variable, demo1.initial_variable)\n",
    "print(demo2.demo_variable, demo2.initial_variable)\n",
    "\n",
    "# A demo of passing arguments and keyword arguments\n",
    "args = [\"Alice\", \"Bob\", \"Carol\", \"Dave\"]\n",
    "kwargs = {\"Alice\": \"Engineer\",\n",
    "          \"Bob\": \"Consultant\",\n",
    "          \"Carol\": \"Lawyer\",\n",
    "          \"Dave\": \"Doctor\"\n",
    "         }\n",
    "demo2.demo_class(*args, **kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `*args` and `**kwargs` in your function calls while you're developing makes it easier to change your code without having to go back through every line of code that calls your function and bug-fix when you change the order or number of arguments you're calling. \n",
    "\n",
    "This reduces errors, improves readability, and makes for a more enjoyable and efficient coding experience."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 Lesson complete\n",
    "\n",
    "This marks the end of this introduction to Python. In the next part of this lesson we'll prepare our data programmatically instead of doing it manually in Excel."
   ]
  }
 ],
 "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.8.10"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}