Intro_to_Python_2020.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Intro. to Python 2020.ipynb",
      "provenance": [],
      "private_outputs": true,
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "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.6.9"
    },
    "toc": {
      "base_numbering": 1,
      "nav_menu": {},
      "number_sections": false,
      "sideBar": true,
      "skip_h1_title": false,
      "title_cell": "Table of Contents",
      "title_sidebar": "Contents",
      "toc_cell": false,
      "toc_position": {
        "height": "calc(100% - 180px)",
        "left": "10px",
        "top": "150px",
        "width": "384px"
      },
      "toc_section_display": true,
      "toc_window_display": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/simonwiles/draft_workshops/blob/master/Intro_to_Python_2020.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CYA9pQGwEVC_"
      },
      "source": [
        "<center>\n",
        "  <h1>Digital Tools and Methods for the Humanities and Social Sciences</h1>\n",
        "  <img src=\"https://raw.githubusercontent.com/sul-cidr/Workshops/master/cidr-logo.no-text.240x140.png\" alt=\"Center for Interdisciplinary Digital Research @ Stanford\"/>\n",
        "</center>\n",
        "\n",
        "# Introduction to Python\n",
        "\n",
        "### Instructors\n",
        "- Simon Wiles (CIDR), <em>simon.wiles@stanford.edu</em>\n",
        "- Peter Broadwell (CIDR), <em>broadwell@stanford.edu</em>\n",
        "\n",
        "### Sign In\n",
        "Please sign in for this workshop at: https://signin.cidr.link/Introduction_to_Python/ -- when you've submitted the sign-in form, please keep your browser tab open on the evaluation form as a reminder to complete it when the workshop is over.\n",
        "\n",
        "\n",
        "### Goal\n",
        "By the end of our workshop today, we hope you'll have an understanding of basic syntax in Python for variables, functions, and control flow, and have some familiarity with some of the fundamental data structures you'll need to work with. With these in hand, you'll know enough to write simple scripts and begin to explore other features of the language.\n",
        "\n",
        "### Topics\n",
        "- Variables and Types (strings, lists, dictionaries)\n",
        "- Functions\n",
        "- Control Flow\n",
        "- Reading and Writing Text To/From a File \n",
        "\n",
        "\n",
        "### Evaluation survey\n",
        "At the end of the workshop, we would be very grateful if you can, please, spend 1 minute answering a few questions that will help us to continue our workshop series.\n",
        "- https://evaluations.cidr.link/Introduction_to_Python/\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZYn2uQ0DEVDB"
      },
      "source": [
        "## Why Python?\n",
        "\n",
        "* **Python is a great language for learning**\n",
        "  - Python is a relatively simple and highly readable language\n",
        "  - Python is a high-level interpreted language\n",
        "  - This makes it fairly easy to learn, and fun to code in\n",
        "  - Learning Python will make learning other languages easier\n",
        "  \n",
        "  \n",
        "* **Python is powerful and multi-purpose**\n",
        "  - Python can be used for almost anything, from writing simple scripts to automate tasks to building full-scale applications\n",
        "  - Python is “Batteries-Included” -- the Standard Library includes a huge range of modules that can be depended upon\n",
        "  - The broader Python community is huge and vibrant -- hundreds of thousands of third-party modules and tutorials cover almost all areas of computing\n",
        "    + In particular, for our purposes, Python is at the very center of the Data Science and Machine Learning ecosystems\n",
        "\n",
        "\n",
        "* **Python is cross-platform and free and open-source**\n",
        "  - Python is freely available and is maintained and governed by its community of users\n",
        "  - Because of this, and because of Python’s great versatility and popularity, it is available on more-or-less any computer system you are likely to come into contact with\n",
        "\n",
        "\n",
        "In short, an investment in learning Python is as safe a bet as you are likely to find, no matter where you are now or where you may want to go from here.\n",
        "\n",
        "---\n",
        "\n",
        "### [XKCD #353: Python](https://xkcd.com/353/)\n",
        "\n",
        "[![XKCD 353: Python](https://imgs.xkcd.com/comics/python.png)](https://xkcd.com/353/)\n",
        "\n",
        "> <small>Alt. Text: *I wrote 20 short programs in Python yesterday.  It was wonderful.  Perl, I'm leaving you.*</small>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Is0opsKEVDC"
      },
      "source": [
        "## Jupyter Notebooks and Google Colaboratory\n",
        "\n",
        "Jupyter notebooks are a way to write and run Python code in an interactive way. They're quickly becoming a standard way of putting together data, code, and written explanations or visualizations into a single document and sharing that. There are a lot of ways that you can run Jupyter notebooks, including just locally on your computer, but we've decided to use Google's Colaboratory notebook platform for this workshop.  Colaboratory is “a Google research project created to help disseminate machine learning education and research.”  If you would like to know more about Colaboratory in general, you can visit the [Welcome Notebook](https://colab.research.google.com/notebooks/welcome.ipynb).\n",
        "\n",
        "Using the Google Colaboratory platform allows us to focus on learning and writing Python in the workshop rather than on setting up Python, which can sometimes take a bit of extra work depending on platforms, operating systems, and other installed applications. If you'd like to install a Python distribution locally, though, we have some instructions (with gifs!) on installing Python through the Anaconda distribution, which will also help you handle virtual environments: https://github.com/sul-cidr/Workshops/wiki/Installing-and-Configuring-Anaconda-and-Jupyter-Notebooks\n",
        "\n",
        "If you run into problems, or would like to look into other ways of installing Python or handling virtual environments, feel free to send us an email (contact-cidr@stanford.edu) for an online consultation.\n",
        "\n",
        "It should be possible to follow along with this workshop using a regular Python console (\"terminal\", \"command-prompt\", etc.).  Please note however that we will not be able to support you with problems related to a local environment during this workshop, and we do recommend using the Colaboratory notebooks if you are at all unsure."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UDIVVraVEVDD"
      },
      "source": [
        "---\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tvNtTgjKEVDE"
      },
      "source": [
        "## Some Basic Language Features"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uFNNRgoOEVDF"
      },
      "source": [
        "### The `print()` function\n",
        "The most basic way for a Python program to generate output is via the `print()` function, which `print`s directly to the console or terminal environment in which the Python interpreted is executed.  In our Jupyter / Google Colab notebooks, this produces output beneath the code cell:\n",
        "\n",
        "```python\n",
        "print(\"Hello World!\")\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HKK06be1EVDG"
      },
      "source": [
        "# Your turn:\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lZRb4kyPEVDL"
      },
      "source": [
        "Jupyter code cells (and other Python console environments) will also automatically output the _return value_ of a cell (or other code block) -- in our context here that means the last statement in a code cell:\n",
        "```python\n",
        "\"Hello world!\"\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UER_8XWkEVDM"
      },
      "source": [
        "# Your turn:\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iP5a91hKEVDP"
      },
      "source": [
        "For more information about the print() statement, we can access Python's built-in documentation and the Colab envionment's autocomplete and intellisense functionality.\n",
        "```python\n",
        "print?\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i7itgBg_EVDP"
      },
      "source": [
        "# Your turn:\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7-N2NTKREVDT"
      },
      "source": [
        "### Comments\n",
        "Comments are an important part of any program.  In Python, comments begin with `#`:\n",
        "\n",
        "```python\n",
        "# This is a comment\n",
        "print(\"Hello world!\")\n",
        "```\n",
        "\n",
        "and they can also be used to annotate lines of code:\n",
        "```python\n",
        "print(\"Hello world!\")  # Comments are fine here too!\n",
        "```\n",
        "\n",
        "Use comments liberally, when you are learning and even when you think you know exactly what you're doing.  Your comments should allow readers of your code to understand _why_ your code does what it does.  Remember that a primary audience for your comments will be you yourself when you revisit your code in the future!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A5mQUZ9LEVDU"
      },
      "source": [
        "### Indentation and Blocks\n",
        "White (blank) space -- specifically space at the beginning of lines -- is meaningful in Python programs, and defines groups of statements which constitute _blocks_, which will become important when we discuss control flow and functions.  For now, note that indentation must be consistent in a Python file -- the convention is to use four spaces.  Mixing up indentation levels will result in errors:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bdx_5coREVDU"
      },
      "source": [
        "# Run this cell, and notice the error\n",
        "# Notice too that the whole cell fails to run, not just the line with the error\n",
        "print(\"this is fine\")\n",
        "  print(\"this is not\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OZUp_DiaEVDY"
      },
      "source": [
        "---\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6prM3cr1EVDZ"
      },
      "source": [
        "## Variables and Types\n",
        "\n",
        "In Python, all the \"bits of information\" of one sort or another in our programs can be referred to as _**value**s_.  Every _**value**_ has a _**type**_ (_**string**_, _**number**_, etc.), and _**variables**_ give us a way of naming and referring to those objects.\n",
        "\n",
        "\n",
        "Python has lots of native datatypes, but the most important ones are:\n",
        "\n",
        "* **Booleans** -- `True` or `False`\n",
        "* **Numbers** -- primarily integers and floats: `3`, `3.14`\n",
        "* **Strings** -- sequences of characters: `\"abc\"`\n",
        "* **Lists** -- ordered sequences of values: `[ \"no\", 1, \"expects\" ]`\n",
        "* **Tuples** -- like **list**s but immutable: `( \"Graham\", \"John\", \"Terry\", \"Michael\", \"Eric\", \"Terry\" )`\n",
        "* **Dictionaries** -- unordered collections of key-value pairs: `{ \"members\": 6, \"affiliates\": [ \"Douglas Adams\", \"Neil Innes\" ] }`\n",
        "* **Sets** -- unordered collections of unique values: `Set([ \"Graham\", \"John\", \"Terry\", \"Michael\", \"Eric\" ])`\n",
        "\n",
        "\n",
        "_**Assignment**_ is the operation of attaching an _**identifier**_ to a _**value**_, and in Python this is done with a single equals sign (`=`).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4pNkVSgyEVDZ"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n-1IRMLBEVDa"
      },
      "source": [
        "### Strings\n",
        "\n",
        "Strings are sequences of characters -- what we tend to call \"text\".\n",
        "\n",
        "```python\n",
        "# A simple string assignment\n",
        "greeting = \"Welcome to Introduction to Python!\"\n",
        "print(greeting)\n",
        "print(type(greeting))\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rvomq8imEVDa"
      },
      "source": [
        "# Your turn -- type the above code or a similar greeting of your own below:\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q-kK7GvSEVDd"
      },
      "source": [
        "Strings can be indicated by single (`'`) or double (`\"`) quotes -- it makes no difference at all, and is merely a convenience."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AvfMh_UEEVDe"
      },
      "source": [
        "fair_warning = 'We will be using examples from \"Monty Python\"...'\n",
        "print(fair_warning)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vTNEZvjrEVDg"
      },
      "source": [
        "\"Escaping\" (use of the backslash `\\` before a character) can be used also, typically if we want single and double quotes in a string:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hA8on8zyEVDh"
      },
      "source": [
        "fair_warning = \"We'll be using examples from \\\"Monty Python\\\"...\"\n",
        "print(fair_warning)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SKr_VUFQEVDk"
      },
      "source": [
        "# Strings may also be indicated by the use of triple quotes (''' or \"\"\" may be used).\n",
        "fair_warning = '''We'll be using examples from \"Monty Python\"...'''\n",
        "print(fair_warning)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G4mwdwhDEVDo"
      },
      "source": [
        "# This is especially useful if you'd like to have multi-line strings\n",
        "cheesemakers = '''\n",
        "Man: I think it was, \"Blessed are the cheesemakers\"!\n",
        "Gregory's wife: What's so special about the cheesemakers?\n",
        "Gregory: Well, obviously it's not meant to be taken literally. It refers to any manufacturer of dairy products.\n",
        "'''\n",
        "print(cheesemakers)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XJyXuNdXEVDr"
      },
      "source": [
        "# Strings in Python 3 are fully unicode-compliant\n",
        "monty_python_zh = '蒙提·派森的飛行馬戲團'\n",
        "print(monty_python_zh)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U8sWinLyEVDu"
      },
      "source": [
        "There are many ways to programmatically construct and create strings, but the only one we'll note here is joining strings together using the addition operator `+`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RruQwpBAEVDu"
      },
      "source": [
        "# we can join string literals\n",
        "\"Monty Python's\" + \" \" + \"Flying Circus\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V6FQHuY3EVDx"
      },
      "source": [
        "# we can also join combinations of literals and variables\n",
        "string_1 = \"Monty Python\"\n",
        "string_2 = \"Holy Grail\"\n",
        "\n",
        "joined = string_1 + \" and the \" + string_2\n",
        "\n",
        "print(joined)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IzAUjleWEVD3"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CPwkOMeSEVD7"
      },
      "source": [
        "#### String Methods\n",
        "\n",
        "**String**s in Python have some special behaviors attached to them (called **method**s) that perform common tasks.\n",
        "\n",
        "Let’s look a case-manipulation, for example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qBZF6gcHEVD8"
      },
      "source": [
        "# Upper- and lower-case are straightforward:\n",
        "print(\"Uppercase:   \", \"monty python's flying circus\".upper())\n",
        "print(\"Lowercase:   \", \"MONTY PYTHON'S FLYING CIRCUS\".lower())\n",
        "\n",
        "# Case-manipulation is unicode-aware\n",
        "#  (but don't make the mistake of thinking this solves all problems!).\n",
        "print(\"Uppercase:   \", \"norsk blå papegøye\".upper())  # \"Norwegian Blue parrot\" in Norwegian :)\n",
        "\n",
        "# Capitalization is mostly trivial...\n",
        "print(\"Capitalized: \", \"monty python's flying circus\".capitalize())\n",
        "\n",
        "# ...but it takes a naïve approach to title-case.\n",
        "print(\"Title Case:  \", \"monty python's flying circus\".title())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m5yKH8zAEVD_"
      },
      "source": [
        "Strings also provide the `.replace()` method, which behaves as expected:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "02WEtKTHEVEA"
      },
      "source": [
        "brian = \"Brian is the Messiah!\"\n",
        "print(brian)\n",
        "\n",
        "# He's not the Messiah...\n",
        "brian = brian.replace(\"the Messiah\", \"a very naughty boy\")\n",
        "print(brian)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hp5b8vv6EVEI"
      },
      "source": [
        "The `.strip()` and `.split()` methods are amongst the most commonly used, and are especially useful when dealing with data from external sources."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WMnTBNzOEVEJ"
      },
      "source": [
        "# .split() breaks a string into pieces, and returns those pieces as a list\n",
        "input_string = \"Monty Python and the Holy Grail\"\n",
        "input_string.split()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "twXpT2TdEVEN"
      },
      "source": [
        "# .split() takes an argument which specifies the sequence to split on\n",
        "knights_of_the_round_table = \"Sir Bedevere the Wise, Sir Lancelot the Brave, Sir Galahad the Pure, Sir Robin the Not-Quite-So-Brave-as-Sir-Lancelot, Sir Not-Appearing-in-this-Film\"\n",
        "knights_of_the_round_table.split(',')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bj2pX6cIEVEP"
      },
      "source": [
        "In some of the previous examples we have had some extraneous white-space in our strings.  For the `knights_of_the_round_table` we could remove this by splitting on `\", \"` (try it!), but in “the wild” we commonly need to clean-up the text that we read into our programs, and the `.strip()` method is a good first step:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m0LnpwaAEVEQ"
      },
      "source": [
        "# .strip() can be called on string literals as well as variables\n",
        "\"  ...and now for something completely different!  \".strip()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H3tceQesEVES"
      },
      "source": [
        "# .strip() can also take an argument which is a sequence of\n",
        "#  characters to strip from the ends of the input\n",
        "\"  ...and now for something completely different!  \".strip(\" .!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g-pefr4fEVEU"
      },
      "source": [
        "# in our excerpt from the script for the Life of Brian, we had some\n",
        "#  whitespace at the beginning and the end, in the form of (probably)\n",
        "#  extraneous new-line characters -- as can be seen when we .split()\n",
        "\n",
        "cheesemakers = '''\n",
        "Man: I think it was, \"Blessed are the cheesemakers\"!\n",
        "Gregory's wife: What's so special about the cheesemakers?\n",
        "Gregory: Well, obviously it's not meant to be taken literally. It refers to any manufacturer of dairy products.\n",
        "'''\n",
        "\n",
        "cheesemakers.split(\"\\n\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q6E7ylnYEVEW"
      },
      "source": [
        "# a reminder of what our value looks like when we don't print() it\n",
        "#  (notice the \\n symbols which represent the newline character)\n",
        "cheesemakers"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6O7YRImdEVEY"
      },
      "source": [
        "# first we can remove these leading and trailing new-line characters:\n",
        "print(cheesemakers.strip())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c8c7Of2xEVEb"
      },
      "source": [
        "# and because cheesemakers.strip() returns another string, we can chain\n",
        "#  these operations and do them both in one line:\n",
        "cheesemakers.strip().split(\"\\n\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EQOdgEDmEVEe"
      },
      "source": [
        "Strings have many other useful methods.  The full list is available in the [documentation](https://docs.python.org/3/library/stdtypes.html#string-methods), but it's often more convenient to use Google Colab’s autocompletion feature to see what’s available.  Hovering the mouse-cursor over an identifier will give some pop-up help, too, and if that's not sufficient we can access Python's built-in documentation (known as `docstrings`) by appending a question mark (`?`) and executing the cell."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DCMhCv0mEVEe"
      },
      "source": [
        "# for the autocompletion to work, a string must already be assigned to\n",
        "#  the variable identifier\n",
        "my_string = \"abc\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XV4shmrVEVEh"
      },
      "source": [
        "# now type \"mystring.\" below\n",
        "# select a method, and hover the mouse pointer over the method name for more information\n",
        "# you can also try affixing a \"?\" and running the cell\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HMfNQPIQEVEj"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VI4nkxrqEVEk"
      },
      "source": [
        "#### Indexing\n",
        "\n",
        "Indexing is one of the most important and recognizable features in Python.  It's very powerful, and Python programmers agree that it's very elegant and intuitive once you get the hang of it.  At the same time, it is often something that newcomers to Python find a little confusing.\n",
        "\n",
        "> Python sequences are \"zero-indexed\" -- meaning that the first member of a sequence is found at index 0.  It can be helpful to think of the indices as offsets from the beginning the sequence."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BZe_lNMQEVEl"
      },
      "source": [
        "# to access (\"to index\") a single character from a string, we use square-bracket notation.\n",
        "norwegian_blue = \"This parrot is no more! It has ceased to be!\"\n",
        "\n",
        "norwegian_blue[1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zDYhuGWLEVEn"
      },
      "source": [
        "# we can also index using negative numbers\n",
        "norwegian_blue[-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0_YUCedJEVEq"
      },
      "source": [
        "Slicing is the practice of using indexing notation to return a 'slice' of a sequence.  The basic pattern is `identifier[start:end:step]`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lYuH5lfNEVEr"
      },
      "source": [
        "# from the 6th character (at index 5) to the 11th (at index 10)\n",
        "norwegian_blue[5:11]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UWt83YpFEVEt"
      },
      "source": [
        "The `start` and `end` values can be omitted, and the beginning or end of the string are implied, respectively:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "giZWLUqJEVEu"
      },
      "source": [
        "alphabet = 'abcdefghijklmnopqrstuvwxyz'\n",
        "\n",
        "print(alphabet[:10])               # from the beginning to the 10th character\n",
        "print(alphabet[0:10])              # equivalent\n",
        "\n",
        "print(alphabet[10:])               # from the 10th character to the end\n",
        "print(alphabet[10:len(alphabet)])  # equivalent\n",
        "\n",
        "print(alphabet[:-10])              # from the beginning up to 10 characters from the end\n",
        "print(alphabet[0:-10])             # equivalent"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qmdLzQrSEVEw"
      },
      "source": [
        "# indexing and slicing becomes more powerful when using variable indices\n",
        "slice_length = 10\n",
        "print(\"slice:     \", alphabet[:slice_length])  # the first `slice_length` characters\n",
        "print(\"remainder: \", alphabet[slice_length:])  # the remainder (regardless how long that is)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IulaFHesEVEy"
      },
      "source": [
        "> Try changing the value of `slice_length` above and running the cell again.  Try out-of-bounds values, and negative values, and see how it behaves."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jr5xYr7sEVEz"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AuCjmEPgEVEz"
      },
      "source": [
        "#### String Formatting\n",
        "\n",
        "There's lots more to learn about strings that we don't have time to cover here.  Probably the most important thing that's not covered here is string formatting using the `.format()` method, or even better, **f-strings**.\n",
        "\n",
        "* For a nice quick introduction try this article: [Python String Formatting Best Practices](https://realpython.com/python-string-formatting/) (the flow chart at the end is good -- you should almost always be using methods #2 or #3).\n",
        "* For a rather deeper dive, try: [A Guide to the Newer Python String Format Techniques](https://realpython.com/python-formatted-output/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vcI5H2DtEVE0"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rlx6L52vEVE0"
      },
      "source": [
        "### Lists\n",
        "\n",
        "**List**s are one of the most important data-structures available in Python.  They can be created in a number of different ways."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_XVfNq3DEVE0"
      },
      "source": [
        "# literal lists are built with square-bracket notation\n",
        "pythons = ['Graham', 'John', 'Terry', 'Eric', 'Terry', 'Michael']\n",
        "print(pythons)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WAWe28ZcEVE2"
      },
      "source": [
        "Above we saw how **list**s are returned by the `.split()` method of a **string**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_JdMXHL4EVE3"
      },
      "source": [
        "# a list created by splitting a string\n",
        "knights_of_the_round_table = 'Sir Bedevere the Wise, Sir Lancelot the Brave, Sir Galahad the Pure, Sir Robin the Not-Quite-So-Brave-as-Sir-Lancelot, Sir Not-Appearing-in-this-Film'\n",
        "knights_of_the_round_table.split(', ')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rBEEmAyJEVE5"
      },
      "source": [
        "A third way is to create an empty **list** and use the `.append()` method that exists on all lists:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ymxlJ_ZEEVE5"
      },
      "source": [
        "# we can create an empty list with the following syntax\n",
        "menu = []\n",
        "\n",
        "# and then add items to the list with the .append() method\n",
        "menu.append('egg')\n",
        "menu.append('bacon')\n",
        "menu.append('sausage')\n",
        "menu.append('spam')\n",
        "\n",
        "print(menu)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZN7WdLVeEVE7"
      },
      "source": [
        "This example highlights one of the features that make **list**s so versatile and useful -- they can be added to once they have been created.  Building **list**s programmatically is one of the most common types of task you are likely to find yourself tackling in Python.\n",
        "\n",
        "This feature of **list**s is called _**mutability**_, and it includes the ability to modify entries in the list in-place:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "du6TKagIEVE7"
      },
      "source": [
        "print(\"before: \", menu)\n",
        "\n",
        "menu[0] = \"spam\"\n",
        "menu[1] = \"spam\"\n",
        "menu[2] = \"spam\"\n",
        "\n",
        "print(\"after:  \", menu)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N7dNJkIiVfit"
      },
      "source": [
        "If `.split()` allows us to turn **string**s into **list**s, `.join()` allows us to turn **list**s into **string**s."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DVFRScN3EVE9"
      },
      "source": [
        "# joining our list literal from above\n",
        "pythons = ['Graham', 'John', 'Terry', 'Eric', 'Terry', 'Michael']\n",
        "print(\", \".join(pythons))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hiLAi64TEVFA"
      },
      "source": [
        "# join the menu with the word \"and\"\n",
        "print(\" and \".join(menu))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lWdRmlVbEVFF"
      },
      "source": [
        "# joining on the newline character is often useful, too\n",
        "pythons = ['Graham', 'John', 'Terry', 'Eric', 'Terry', 'Michael']\n",
        "print(\"\\n\".join(pythons))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bdDA2RovEVFL"
      },
      "source": [
        "# splitting and re-joining is a common operation\n",
        "print(knights_of_the_round_table)\n",
        "print(\"-------\")\n",
        "print(\"\\n\".join(knights_of_the_round_table.split(\", \")))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cb-TJ1Z4EVFQ"
      },
      "source": [
        "**List**s can be indexed just like strings:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wkICzKh9EVFR"
      },
      "source": [
        "print(\"pythons:     \", pythons)\n",
        "print(\"pythons[0]:  \", pythons[0])\n",
        "print(\"pythons[-1]: \", pythons[-1])\n",
        "print(\"pythons[:3]: \", pythons[:3])\n",
        "print(\"pythons[3:]: \", pythons[3:])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "quAa5cVvEVFU"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ukwwE1MvEVFU"
      },
      "source": [
        "### Dictionaries\n",
        "\n",
        "A dictionary in Python is a collection of `key`/`value` pairs -- each pair together is known as an `item`.  Values can be any kind of value you like -- strings, numbers, lists, more dictionaries, etc. -- but keys have certain restrictions.  For the majority of purposes you should be using strings as your dictionary keys."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JBkPZawbEVFU"
      },
      "source": [
        "# literal dictionaries are created using brace notation:\n",
        "pythons_by_family_name = {\n",
        "    \"Chapman\": \"Graham Chapman\",\n",
        "    \"Cleese\": \"John Cleese\",\n",
        "    \"Gilliam\": \"Terry Gilliam\",\n",
        "    \"Idle\": \"Eric Idle\",\n",
        "    \"Jones\": \"Terry Jones\",\n",
        "    \"Palin\": \"Michael Palin\"\n",
        "}\n",
        "pythons_by_family_name"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sdq9Kq_3EVFX"
      },
      "source": [
        "# dictionary keys must be unique in the dictionary, so note that while\n",
        "#  this is legal...\n",
        "pythons_by_first_name = {\n",
        "    \"Graham\": \"Graham Chapman\",\n",
        "    \"John\": \"John Cleese\",\n",
        "    \"Terry\": \"Terry Gilliam\",\n",
        "    \"Eric\": \"Eric Idle\",\n",
        "    \"Terry\": \"Terry Jones\",\n",
        "    \"Michael\": \"Michael Palin\"\n",
        "}\n",
        "# the second appearance of the duplicate key has over-written the first\n",
        "pythons_by_first_name"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FQAavJMIEVFd"
      },
      "source": [
        "# dictionary values are accessed using square-bracket notation -- a little\n",
        "#  bit like indexing for sequence types\n",
        "\n",
        "cheeseshop = {\n",
        "    \"Red Leicester\": \"I'm afraid we're fresh out of Red Leicester sir.\",\n",
        "    \"Tilsit\": \"Never at the end of the week, sir. Always get it fresh first thing on Monday.\",\n",
        "    \"Caerphilly\": \"Ah well, it's been on order for two weeks, sir. I was expecting it this morning.\",\n",
        "    \"Bel Paese\": \"Sorry.\",\n",
        "    \"Red Windsor\": \"Normally, sir, yes, but today the van broke down.\",\n",
        "    \"Stilton\": \"Sorry.\"\n",
        "}\n",
        "\n",
        "print(\"Do you have any Tilsit?\", cheeseshop[\"Tilsit\"], sep=\"\\n\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0EOClDIREVFg"
      },
      "source": [
        "# attempting to access a key that doesn't exist raises a `KeyError` exception\n",
        "cheeseshop[\"Venezuelan Beaver Cheese\"]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rxvoe91GEVFk"
      },
      "source": [
        "We're not going to work much more with dictionaries in this workshop, but they are one of the most important weapons in the Python programmer's arsenal and there's much more to be learned about them."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IWjQiY7NEVFk"
      },
      "source": [
        "---\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2g3gJSQdEVFm"
      },
      "source": [
        "## Functions\n",
        "\n",
        "**Function**s are blocks of reusable code.  They provide a way to break monolithic programs into parts; this aids greatly in writing code that is readable, maintainable, and extensible.  It is especially important, of course, when a block of code will or may be used multiple times in the same or similar ways, but a section of code does not need to be used multiple times to justify creating it as a function.\n",
        "\n",
        "---\n",
        "\n",
        "### Built-In Functions\n",
        "\n",
        "We've already seen a number of **function**s in what we've done so far -- `print()`, of course, but there's also `len()` and `type()`.  When functions are bound to objects -- as `.format()`, `.lower()` etc. on string objects, or `.append()` on list objects, we call them **method**s, but the difference is minimal and need not concern us at this point.\n",
        "\n",
        "The functions (and methods) we've seen so far are “built-in” functions -- they're provided to us by the Python interpreter.  The important thing we need to learn in this section is how to _define_ and _call_ (or _invoke_) our own functions.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-dYsUVBIEVFm"
      },
      "source": [
        "### `def`ining Your Own Functions\n",
        "\n",
        "User-Defined Functions, as they are sometimes called, can be created at any time in Python code.  Notice that defining a function in this way creates no output."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MNiHX_dFEVFo"
      },
      "source": [
        "# functions are introduced with the \"def\" keyword (note the final colon)\n",
        "def knights_who_say_ni():\n",
        "    # the block of indented statements beneath the definition statement\n",
        "    #  constitutes the body of the function\n",
        "    print(\"Ni!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NykjKYhNEVFq"
      },
      "source": [
        "# when defined in this way, they can be called just like built-ins:\n",
        "knights_who_say_ni()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gIap6PGYEVFu"
      },
      "source": [
        "# of course, functions are more useful when they take arguments\n",
        "def ask_for_cheese(cheese):\n",
        "    print(\"Do you have any \" + cheese + \"?\")\n",
        "    print(cheeseshop[cheese])\n",
        "    print()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7nrKDJxyEVFx"
      },
      "source": [
        "# arguments (or parameters) are passed when the function is invoked:\n",
        "ask_for_cheese(\"Red Leicester\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sxi_6OM2EVF4"
      },
      "source": [
        "# the benefit of a function like this, of course, is when it will be called many times:\n",
        "ask_for_cheese(\"Red Leicester\")\n",
        "ask_for_cheese(\"Tilsit\")\n",
        "ask_for_cheese(\"Caerphilly\")\n",
        "ask_for_cheese(\"Bel Paese\")\n",
        "ask_for_cheese(\"Red Windsor\")\n",
        "ask_for_cheese(\"Stilton\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U8Rl0CsjEVF7"
      },
      "source": [
        "# ...\n",
        "ask_for_cheese(\"Venezuelan Beaver Cheese\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tyyuplYNEVF_"
      },
      "source": [
        "# functions can take as many arguments as you need\n",
        "def greeting(first_name, last_name):\n",
        "    print(\"Good evening, my name is \" + first_name + \" \" + last_name + \".\")\n",
        "\n",
        "greeting(\"Michael\", \"Palin\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JEs2VqOWEVGC"
      },
      "source": [
        "# and they may be called with \"keyword arguments\" -- this can\n",
        "#  help readability, and allows passing the arguments in any order\n",
        "greeting(first_name=\"Michael\", last_name=\"Palin\")\n",
        "greeting(last_name=\"Palin\", first_name=\"Michael\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i_tm_HrsEVGE"
      },
      "source": [
        "Unless otherwise specified with a `return` statement, functions do not return a value (which is to say, their return value is `None`)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_t2Txpo8EVGE"
      },
      "source": [
        "value = greeting(\"Eric\", \"Idle\")\n",
        "print(value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A-XLftlaEVGH"
      },
      "source": [
        "# to make a function return a value, use an explicit return statement\n",
        "def greeting(first_name, last_name):\n",
        "    return \"Good evening, my name is \" + first_name + \" \" + last_name + \".\"\n",
        "\n",
        "value = greeting(\"Graham\", \"Chapman\")\n",
        "print(value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nXaOGa-2EVGJ"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cIW5dTvuEVGK"
      },
      "source": [
        "### Activity: Write a Pig-Latinizer Function\n",
        "\n",
        "Pig Latin is a language game where you take the first letter of a word, move it to the end of the word, then add “-ay” at the end. For example, “pig latin” would be “igpay atinlay” and “monty python” would turn into “ontymay ythonpay”.\n",
        "\n",
        "In the cell below, write a function that takes a string, lowercases it, and returns the Pig Latin translation of the word. You'll need to use slicing and string concatenation or formatting to make this work."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9msNwcA9EVGK"
      },
      "source": [
        "def pig_latinize(word):\n",
        "    # write your code here -- don't forget to return a result!\n",
        "\n",
        "\n",
        "    \n",
        "# the following should return 'pamalotsay'\n",
        "pig_latinize('Spamalot')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "fPitwR1BEVGN"
      },
      "source": [
        "#@title → Double-click Here to Show/Hide Hints\n",
        "\n",
        "# 1. use word.lower() to lowercase the input\n",
        "# 2. you'll need to use the indexing techniques to get the first letter\n",
        "#    of the word, and everything-but-the-first-letter of the word separately\n",
        "# 3. once you have the pieces you need, stick them together to make your output\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "llbIZJqOEVGP"
      },
      "source": [
        "#@title → Double-click Here to Show/Hide a Prepared Solution\n",
        "\n",
        "def pig_latinize(word):\n",
        "    word = word.lower()\n",
        "    return word[1:] + word[0] + 'ay'\n",
        "\n",
        "\n",
        "# the following should return 'pamalotsay'\n",
        "pig_latinize('Spamalot')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dkk2xir6EVGS"
      },
      "source": [
        "---\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "erBayggIEVGT"
      },
      "source": [
        "## Control Flow\n",
        "\n",
        "Using functions to split up our monolithic code in to manageable blocks also introduces our first element of **_control flow_** -- the ability to have code execute (or not execute) in a non-linear order (i.e. not simply from top to bottom, line by line).\n",
        "\n",
        "In addition to functions, there are two main control flow mechanisms that we will look at in this section: **_conditional execution_** or **_branching_** causes blocks of code to be executed or ignored based on the evaluation of a boolean expression; and **_loop_**s allow us to specify the execution of blocks of code a fixed or indeterminate number of times.\n",
        "\n",
        "Raising and handling **_exception_**s is another way to control the flow of execution in a Python program, but we're not going to cover that here.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M4Tbau3_EVGT"
      },
      "source": [
        "### Conditional Execution (`if` statements)\n",
        "\n",
        "In Python, the compound `if` statement is comprised of three clauses: `if`, `else`, and `elif`.  Each of these clauses defines a block which executes if the appropriate condition is met."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EvwRAPQyEVGU"
      },
      "source": [
        "# if statements test a condition, and execute a block of code accordingly\n",
        "if 2 + 2 == 4:\n",
        "    print('Of course, two plus two equals equals four [sic].')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "McdXzN1aEVGW"
      },
      "source": [
        "# We can also add a block of code in an \"else\" clause\n",
        "test_word = \"shrubbery\"\n",
        "\n",
        "if len(test_word) > 8:\n",
        "    print(\"that's a long word!\")\n",
        "else:\n",
        "    print(\"that's a short word!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sbcxrMSGEVGY"
      },
      "source": [
        "# and there's an elif clause if you need more than two branches\n",
        "test_word = \"\"\n",
        "\n",
        "if type(test_word) != str:\n",
        "    print(\"that's not a word at all!\")\n",
        "elif len(test_word) > 10:\n",
        "    print(\"that's a long word!\")\n",
        "else:\n",
        "    print(\"that's a short word!\")\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2y3eKE7yEVGb"
      },
      "source": [
        "# if statements can have as many elif clauses as needed\n",
        "def spanish_inquisition(weapons):\n",
        "    if weapons == 1:\n",
        "        print(\"surprise\")\n",
        "    elif weapons == 2:\n",
        "        print(\"fear and surprise\")\n",
        "    elif weapons == 3:\n",
        "        print(\"fear and surprise and ruthless efficiency\")\n",
        "    elif weapons == 4:\n",
        "        print(\"fear and surprise and ruthless efficiency and an almost fanatical devotion to the Pope\")\n",
        "        \n",
        "spanish_inquisition(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a0kCxWftEVGd"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ncWYolrtEVGe"
      },
      "source": [
        "### Loops and Iteration (`for` loops)\n",
        "\n",
        "There are two basic kinds of loops in Python: those introduced with the `for` statement are sometimes called _iterative loops_, and we'll look at those below.  Python also has loops that can be introduced with the `while` statement, and these are sometimes referred to as _conditional loops_.  `while` loops are less common in Python, and we won't cover them in this workshop.\n",
        "\n",
        "`for` loops repeat the execution of a code block dependent on an iterable expression. For our purposes an iterable may be understood to refer to anything that can be looped over in a for loop -- in particular, this includes anything that is a sequence type; a list, a tuple, or a string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MchYjhawEVGf"
      },
      "source": [
        "# the syntax for a for-loop looks like this:\n",
        "#  (as with function definition, note the colon and the indented block)\n",
        "for python in pythons:\n",
        "    print(python)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oHl5vKlREVGn"
      },
      "source": [
        "# we can also iterate over the keys of a dictionary\n",
        "for cheese in cheeseshop:\n",
        "    print(cheese)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5L8ZEqP1EVGo"
      },
      "source": [
        "# this becomes more and more useful as we do more in the body of the loop\n",
        "#  -- here we can re-use the ask_for_cheese() function from above\n",
        "for cheese in cheeseshop:\n",
        "    ask_for_cheese(cheese)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KasgCyusEVGv"
      },
      "source": [
        "### Additional Topics in Control Flow\n",
        "\n",
        "There is lots more to learn about flow of execution in Python that we've not had time to cover here.  Among the more important topics you might want to look into are:\n",
        "\n",
        "* comparison operators beyond `==`, `>`, `<`\n",
        "* logical operators such as `and`, `or`, and `not`\n",
        "* `while` loops, sometimes known as **conditional loops**\n",
        "* the `break` and `continue` statements, and other strategies for exiting loops early (including recursive functions and methods)\n",
        "* `try: ... except:` blocks and raising and handling `exceptions`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6s3rx4-pEVGw"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pt5nLRDbEVGw"
      },
      "source": [
        "### Activity: Pig-Latinize a sentence\n",
        "\n",
        "In the cell below, write a function that can pig-latinize and entire phrase or sentence.\n",
        "\n",
        "For example, if your input is:\n",
        "> `\"A 5 ounce bird could not carry a 1 pound coconut\"`\n",
        "\n",
        "the output should be:\n",
        "> `\"aay 5 unceoay irdbay ouldcay otnay arrycay aay 1 oundpay oconutcay\"`\n",
        "\n",
        "\n",
        "* You should reuse the `pig_latinize` function you wrote above.\n",
        "* You'll need to use a loop to operate on each word in turn.\n",
        "* Use the `.isnumeric()` method on each word to test for digits.\n",
        "* Use a conditional structure (`if`/`else`) to execute a different behavior depending on the result of the test.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4l66QIb0EVGx"
      },
      "source": [
        "def pig_latinize_sentence(sentence):\n",
        "    # Your code goes here\n",
        "\n",
        "    \n",
        "    \n",
        "pig_latinize_sentence(\"A 5 ounce bird could not carry a 1 pound coconut\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "IIibq4g3EVGz"
      },
      "source": [
        "#@title → Double-Click Here to Show Hints\n",
        "\n",
        "\n",
        "# You'll need to begin by splitting the sentence into a list of words\n",
        "\n",
        "# Create an empty list to `.append()` the pig-latinized words to\n",
        "\n",
        "# For each word in the list, test whether it's numeric or not\n",
        "#  -- if it is, just append it to the list unaltered\n",
        "\n",
        "# Join the list back together to create the output sentence\n",
        "\n",
        "# Don't forget to `return` the output!\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "Ma82v7-IEVG2"
      },
      "source": [
        "#@title → Double-Click Here to Reveal a Prepared Solution\n",
        "\n",
        "def pig_latinize_sentence(sentence):\n",
        "\n",
        "    words = sentence.split()\n",
        "    latinized_words = []\n",
        "    for word in words:\n",
        "        if word.isnumeric():\n",
        "            latinized_words.append(word)\n",
        "        else:\n",
        "            latinized_words.append(pig_latinize(word))\n",
        "    latinized_sentence = \" \".join(latinized_words)\n",
        "\n",
        "    return latinized_sentence\n",
        "\n",
        "pig_latinize_sentence(\"A 5 ounce bird could not carry a 1 pound coconut\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "07Y8YXOIEVG9"
      },
      "source": [
        "---\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dRNDfn5-EVG9"
      },
      "source": [
        "## Reading and Writing Text To/From a File\n",
        "\n",
        "We cover working with CSV and other kinds of data files in some of our other CIDR workshops.  If we have time in this workshop, though, we'll finish by working together as a group to apply our `pig_latinize` function to an entire file.\n",
        "\n",
        "To do so, we'll begin by looking at how to write and read simple files.  We'll use the text of Eric Idle's \"Galaxy Song\"."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JVpaboWLEVG-"
      },
      "source": [
        "galaxy_song = '''\n",
        "[spoken]\n",
        "Whenever life gets you down, Mrs. Brown,\n",
        "And things seem hard or tough,\n",
        "And people are stupid, obnoxious or daft,\n",
        "\n",
        "[sung]\n",
        "And you feel that you've had quite eno-o-o-o-o-ough,\n",
        "\n",
        "Just remember that you're standing on a planet that's evolving\n",
        "And revolving at 900 miles an hour.\n",
        "It's orbiting at 19 miles a second, so it's reckoned,\n",
        "The sun that is the source of all our power.\n",
        "Now the sun, and you and me, and all the stars that we can see,\n",
        "Are moving at a million miles a day,\n",
        "In the outer spiral arm, at 40,000 miles an hour,\n",
        "Of a galaxy we call the Milky Way.\n",
        "\n",
        "Our galaxy itself contains a hundred billion stars;\n",
        "It's a hundred thousand light-years side to side;\n",
        "It bulges in the middle sixteen thousand light-years thick,\n",
        "But out by us it's just three thousand light-years wide.\n",
        "We're thirty thousand light-years from Galactic Central Point,\n",
        "We go 'round every two hundred million years;\n",
        "And our galaxy itself is one of millions of billions\n",
        "In this amazing and expanding universe.\n",
        "\n",
        "[waltz]\n",
        "\n",
        "Our universe itself keeps on expanding and expanding,\n",
        "In all of the directions it can whiz;\n",
        "As fast as it can go, at the speed of light, you know,\n",
        "Twelve million miles a minute and that's the fastest speed there is.\n",
        "So remember, when you're feeling very small and insecure,\n",
        "How amazingly unlikely is your birth;\n",
        "And pray that there's intelligent life somewhere out in space,\n",
        "'Cause there's bugger all down here on Earth!\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7r-YWJykEVHD"
      },
      "source": [
        "When working with files in Python, we need to:\n",
        "* open the file and save a pointer to it\n",
        "* write our content to the file\n",
        "* close the file\n",
        "\n",
        "This could look something like this:\n",
        "```python\n",
        "file_handle = open(\"galaxy_song.txt\", \"w\")\n",
        "file_handle.write(galaxy_song)\n",
        "file_handle.close()\n",
        "```\n",
        "\n",
        "This can be a cumbersome operation, and so the common idiom in Python looks like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5JO0azuMEVHE"
      },
      "source": [
        "# using a \"with\" block means we don't have to worry about closing\n",
        "#  the file properly ourselves\n",
        "with open(\"galaxy_song.txt\", \"w\") as file_handle:\n",
        "    file_handle.write(galaxy_song)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gjF7BRPPEVHG"
      },
      "source": [
        "The \"Files\" tab in left-hand sidebar should now reveal the new file we've created.  You may need to click the \"Refresh\" button to see it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hxga4g8GEVHH"
      },
      "source": [
        "# Now, let's read the file back.\n",
        "with open(\"galaxy_song.txt\", \"r\") as file_handle:\n",
        "    file_contents = file_handle.read()\n",
        "    \n",
        "print(file_contents)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IHEVjrZOEVHJ"
      },
      "source": [
        "# We can also read the file line by line\n",
        "with open(\"galaxy_song.txt\", \"r\") as file_handle:\n",
        "    for line in file_handle:\n",
        "        line = \" == \" + line\n",
        "        print(line, end=\"\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MbdY2uu1EVHL"
      },
      "source": [
        "### Group Activity: Pig-Latinize a File\n",
        "\n",
        "Our goal is to read in the contents of our `galaxy_song.txt` file, Pig-Latinize it, and write the translated version out to a new file.  \n",
        "\n",
        "Here are some hints:\n",
        "\n",
        "* it will probably be easiest to go through the song line-by-line, and then word-by-word\n",
        "* for each line, build an new list of pig-latinized words, and then save that line, before moving on to the next\n",
        "* the direction lines (in square brackets) should be left as they are\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P5UH7WHnEVHL"
      },
      "source": [
        "# (Y)Our code here:\n",
        "# (there's no need to write this as a function -- unless you want to)\n",
        "\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gu599WQ5lV8_",
        "cellView": "form"
      },
      "source": [
        "#@title → Double-Click For Step-by-Step Hints\n",
        "\n",
        "#  1. Create an empty list called \"latinized_lines\" to store each line after it\n",
        "#     has been pig-latinized.\n",
        "#  2. Open the file using a \"with\" block, getting a reference to a file_handle\n",
        "#     object.\n",
        "#  3. Inside the \"with\" block, loop through the file line-by-line.\n",
        "#  4. For each line, begin by stripping the newline character from the end.\n",
        "#  5. If the line begins with an opening square bracket, consider it a\n",
        "#     stage-direction and add it to the \"latinized_lines\" list as it is.\n",
        "#  6. Otherwise, split the line into a list of words\n",
        "#  7. Create an empty list called \"latinized_words\" to store each word after it\n",
        "#     has been pig-latinized.\n",
        "#  8. For each word, pig-latinize it by calling the pig_latinize() function we\n",
        "#     created above.\n",
        "#  9. Add the pig-latinized version of the work to the \"latinized_words\" list.\n",
        "# 10. Once every word has been processed, exit the for-each-word loop and join\n",
        "#     the \"latinized_words\" list back together into a string that represents\n",
        "#     the whole line.\n",
        "# 11. Add this pig-latinized line to the \"latinized_lines\" list.\n",
        "# 12. Once every line has been processed, exit the for-each-line loop and the\n",
        "#     \"with\" block, and join the \"latinized_lines\" list back together to create\n",
        "#     a string that comprises the entire text.\n",
        "# 13. Open a new file for writing using a new \"with\" block.\n",
        "# 14. Inside the \"with\" block, write the string to the file.\n",
        "# 15. Profit?\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gYtgsLugEVHR",
        "cellView": "both"
      },
      "source": [
        "#@title → Double-Click Here to Reveal a Prepared Solution\n",
        "\n",
        "# there are lots of ways to achieve this task: here is a\n",
        "#  simple solution using only the techniques we've covered\n",
        "#  in this workshop.\n",
        "\n",
        "\n",
        "# create an empty list to .append() our latinized lines to\n",
        "latinized_lines = []\n",
        "\n",
        "# open the file for \"r\"eading\n",
        "with open(\"galaxy_song.txt\", \"r\") as file_handle:\n",
        "    \n",
        "    # loop through the contents of the file one line at a time\n",
        "    for line in file_handle:\n",
        "        \n",
        "        # remove the newline character at the end of every line\n",
        "        line = line.strip(\"\\n\")        \n",
        "        \n",
        "        # lines with stage directions should just be added to our\n",
        "        #  output unaltered\n",
        "        if line.startswith(\"[\"):\n",
        "            latinized_lines.append(line)\n",
        "        \n",
        "        # otherwise...\n",
        "        else:           \n",
        "            # split the line into individual \"words\"\n",
        "            words = line.split()\n",
        "            \n",
        "            # create a new empty list to .append() latinized words to\n",
        "            # (a new list just for this contents of *this current line*)\n",
        "            latinized_words = []\n",
        "\n",
        "            # loop through the words\n",
        "            for word in words:\n",
        "                \n",
        "                # latinize the word...\n",
        "                latinized_word = pig_latinize(word)\n",
        "                \n",
        "                # ...and then append it to the list \n",
        "                latinized_words.append(latinized_word)\n",
        "\n",
        "            # now that we've latinized all the words (we've completed \n",
        "            #  and exited the loop), we need to join the words back\n",
        "            #  together into a line\n",
        "            latinized_line = \" \".join(latinized_words)\n",
        "\n",
        "            # we can capitalize the first letter of each line\n",
        "            latinized_line = latinized_line.capitalize()\n",
        "            \n",
        "            # and then we can add the newly created line to our list of lines\n",
        "            latinized_lines.append(latinized_line)\n",
        "\n",
        "# finally, now that we've got all the lines, we join them back together\n",
        "#  into a new block of text, by joining on the newline character \"\\n\"\n",
        "latinized_text = \"\\n\".join(latinized_lines)\n",
        "\n",
        "# and then just write it out to our new file!\n",
        "with open(\"galaxy_song_latinized.txt\", \"w\") as file_handle:\n",
        "    file_handle.write(latinized_text)\n",
        "\n",
        "\n",
        "print(\"Look for galaxy_song_latinized.txt in the Files panel on the left!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HnVawzN5EVHS",
        "cellView": "form"
      },
      "source": [
        "#@title → Double-Click Here For an Alternative Solution\n",
        "\n",
        "# For a point of comparison, here's the exact same algorithmic operation coded \n",
        "#  in a much terser fashion.  If you spend a lot of time writing Python code this\n",
        "#  is surprisingly readable -- but even then, I think you could make a strong case\n",
        "#  that the longer, more spelled-out version is better in most respects.\n",
        "\n",
        "latinized_galaxy_song = \"\\n\".join(\n",
        "    \" \".join(pig_latinize(word) for word in line.split()).capitalize()\n",
        "    if not line.startswith(\"[\") else line.strip()\n",
        "    for line in open(\"galaxy_song.txt\", \"r\")\n",
        ")\n",
        "\n",
        "print(latinized_galaxy_song)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "af2xz2owewps"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DDtKu6uGUvfG"
      },
      "source": [
        "A couple of obviously desirable improvements that could be made to this include better handling of punctuation and numbers expressed in digits.  Both of these would probably be best handled my making the `pig_latinize()` function a bit more sophisticated.  This is a bit out-of-scope for our workshop today, but below is one approach for those who would like to go a little further.  Let us know if you'd like to know more about these kinds of more advanced techniques and packages in future workshops!\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zfIussiAWNTg"
      },
      "source": [
        "# inflect is a third-party package that happens to be installed by\n",
        "#  default in Google Collaboratory environments, so we'll use it to\n",
        "#  convert the digits into words, and then we'll pig-latinize those\n",
        "#  words -- e.g. 19 -> \"ineteennay\"\n",
        "import inflect \n",
        "\n",
        "inf = inflect.engine()\n",
        "\n",
        "def pig_latinize_2(word):\n",
        "    # This bit deals with the digits by converting them into words and\n",
        "    #  then pig-latinizing the words.\n",
        "    # Note that since converting digits to words might mean turning one \"word\" into \n",
        "    #  more that one (e.g. 900 -> \"nine hundred\"), the function calls itself again\n",
        "    #  on each of the new words -- this is what is called \"recursion\".\n",
        "    if any(char.isnumeric() for char in word):\n",
        "        return \" \".join(\n",
        "            pig_latinize_2(new_word)\n",
        "            for new_word in inf.number_to_words(word).split()\n",
        "        )\n",
        "\n",
        "    word = word.lower()\n",
        "\n",
        "    # This bit handles getting the punctuation in the right place.\n",
        "    # It's pretty naïve -- it only works when there's a single punctuation\n",
        "    #  character in the final position (which is fine for our text).\n",
        "    # I'm not sure what the canonical way to deal with apostrophized \n",
        "    #  contractions and ellipsis is in Pig Latin!\n",
        "    if word.endswith(tuple(\",.;!\")):\n",
        "        return word[1:-1] + word[0] + 'ay' + word[-1]\n",
        "\n",
        "    return word[1:] + word[0] + 'ay'\n",
        "\n",
        "\n",
        "latinized_galaxy_song = \"\\n\".join(\n",
        "    \" \".join(pig_latinize_2(word) for word in line.split()).capitalize()\n",
        "    if not line.startswith(\"[\") else line.strip()\n",
        "    for line in open(\"galaxy_song.txt\", \"r\")\n",
        ")\n",
        "\n",
        "print(latinized_galaxy_song)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MzRbmt0jEVHU"
      },
      "source": [
        "# Additional Resources and Topics\n",
        "\n",
        "## Resources\n",
        "- https://python.swaroopch.com/ (A Byte of Python is a great intro book and reference for Python)\n",
        "- https://docs.python.org/3/ (Official Python documentation and tutorials)\n",
        "- https://realpython.com/ (Contains a lot of different tutorials at different levels)\n",
        "- [Automate the Boring Stuff with Python](https://automatetheboringstuff.com/) (Simon's personal favourite)\n",
        "- LinkedIn Learning (formerly Lynda.com): https://www.linkedin.com/learning/topics/python (LinkedIn Learning is avaliable for free to those with Stanford accounts.)\n",
        "\n",
        "## Further Topics\n",
        "- Other data structures:, in particular `sets`, `tuples`\n",
        "- Comprehensions\n",
        "- Modules, libraries, packages, and `pip`\n",
        "- Writing `.py` scripts, and using IDEs\n",
        "- Virtual environments\n",
        "- The object-oriented paradigm in Python: classes, methods"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tHVMa8V3EVHV"
      },
      "source": [
        "Thank you!"
      ]
    }
  ]
}