docs/tutorials/lee-python-2021-april.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "smooth-tongue",
   "metadata": {},
   "source": [
    "# Basic Python for Linguists in 15 Minutes\n",
    "\n",
    "[Jackson Lee](https://jacksonllee.com/)\n",
    "\n",
    "April 2021\n",
    "\n",
    "Source of this Jupyter notebook: https://github.com/jacksonllee/pycantonese/blob/main/docs/tutorials/lee-python-2021-april.ipynb\n",
    "\n",
    "The easiest way to immediately play with this notebook is to log on to your Google account (Gmail, etc.) and [open this notebook in Google Colab](https://colab.research.google.com/github/jacksonllee/pycantonese/blob/main/docs/tutorials/lee-python-2021-april.ipynb). You'll have your own copy to run cells from, make changes, and save in your Google Drive."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "still-window",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "Perhaps you're attending a class or tutorial that says \"prior experience in Python programming is helpful but not required\" or similar. You may not have a background in computer programming and/or the Python language, but would like to attend and get something out of it nonetheless. Before attending, and if you have 15 minutes to spare, the following topics are more or less the bare minimum that you'd want to understand -- at least by just reading through the code snippets in this Jupyter notebook (this is the name of this thing you're reading right now - Jupyter is pronounced like the planet in our solar system):\n",
    "\n",
    "* *Strings*, probably the most important type of Python objects you need to know when handling language data\n",
    "* *Lists*, to handle a bunch of things\n",
    "* *Loops*, to do something repeatedly\n",
    "* *Dicts*, to map something to something else\n",
    "* *Conditionals*, to do X instead of Y by some condition\n",
    "* *Outputting A File*, to keep results in a text file (plain text, CSV, etc.)\n",
    "\n",
    "If you're a linguist, picking up a language should be a piece of cake. 🙂"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "vietnamese-lounge",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "To work with language data in Python, understand how **strings** work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ancient-january",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"this is a string\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "noble-tamil",
   "metadata": {},
   "source": [
    "What's just happened? We've assigned the string `\"this is a string\"` to the variable `x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "lyric-chair",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "amino-stranger",
   "metadata": {},
   "source": [
    "How many characters are there in the string? The **`len()`** (for \"length\") function is defined for strings (and many other data types for which the idea of \"number of things in it\" makes sense)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "completed-tattoo",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reported-rescue",
   "metadata": {},
   "source": [
    "Access the first character. Python counts from zero, like many programming languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "thorough-minutes",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'t'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "continental-confusion",
   "metadata": {},
   "source": [
    "You can **slice** a string. This example with `[5:10]` means accessing the characters from index 5 to (but excluding) index 10.\n",
    "You get back a string whose length is 5, for indices {5, 6, 7, 8, 9}.\n",
    "(Yes, the space is a character and has a length of one.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "standing-attention",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'is a '"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[5:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "handled-robin",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "attended-directory",
   "metadata": {},
   "source": [
    "We can handle a single string like `x` above. What about multiple strings? Sure, we can define more variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "nuclear-subcommittee",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = \"this is another string\"\n",
    "z = \"this is yet another string\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "favorite-virginia",
   "metadata": {},
   "source": [
    "Okay, you see where this is going. What if we want to handle many more, or an unspecified number of them? Defining variables one by one isn't sustainable. We need a way to deal with _a bunch of things_. That's where containers in Python come in. We're going to see how **lists** in Python work below. (There're many other options -- hey, you've got only 15 minutes!)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "public-edwards",
   "metadata": {},
   "source": [
    "Note how square brackets `[ ]` are used to define a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "drawn-fetish",
   "metadata": {},
   "outputs": [],
   "source": [
    "words = [\"cats\", \"dogs\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "approximate-things",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "heated-supplier",
   "metadata": {},
   "source": [
    "Just like strings, you can ask for the length of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "demanding-emerald",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "consolidated-radical",
   "metadata": {},
   "source": [
    "Remember the string `x` from above? We can break it up by the spaces to create a list of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "sensitive-relationship",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a string'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "retained-concentrate",
   "metadata": {},
   "source": [
    "`.split()` applies to a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "crude-reflection",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = x.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "seeing-village",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this', 'is', 'a', 'string']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "relative-symbol",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "affiliated-sender",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "scientific-fantasy",
   "metadata": {},
   "source": [
    "Things are getting more interesting now. We've just begun combing knowledge of strings and lists!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "biological-maker",
   "metadata": {},
   "source": [
    "A list behaves just like a string does for the slicing syntax with `[0]`, `[5:10]`, etc that we've seen above for strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "spare-productivity",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "finished-collins",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'string'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result[-1]  # [-1] gives the final element."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "documentary-selling",
   "metadata": {},
   "source": [
    "Slicing a list gives you a list, just as slicing a string gives you a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "strategic-flesh",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this', 'is']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result[:2]  # If the starting index isn't specified, it's 0, i.e., from the beginning."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unauthorized-stand",
   "metadata": {},
   "source": [
    "## `for` loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "terminal-italy",
   "metadata": {},
   "source": [
    "You've probably heard that computers are very good at repeating a task over and over. Let's see how Python **loops** work. We'll have time for **`for`** loops only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "lasting-physics",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this', 'is', 'a', 'string']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "impressed-wales",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this\n",
      "t\n",
      "is\n",
      "i\n",
      "a\n",
      "a\n",
      "string\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "for word in result:\n",
    "    print(word)\n",
    "    print(word[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "molecular-stress",
   "metadata": {},
   "source": [
    "Okay, let's unpack what you've just seen.\n",
    "\n",
    "* `result` is a list of four strings.\n",
    "* We iterate over each of them and give it a variable name `word` -- that's the `for word in result:` part.\n",
    "* With every `word`, we do the following: just print it, and then just print the first character of it.\n",
    "\n",
    "This is a toy example, but the power comes in when you have a lot of elements to iterate over, and when you can control what the computer should do in specific iterations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coupled-reality",
   "metadata": {},
   "source": [
    "## Dicts\n",
    "\n",
    "A dict (for \"dictionary\") is a map from something to something else."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "transsexual-medicine",
   "metadata": {},
   "source": [
    "You can map a string to another string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "selected-african",
   "metadata": {},
   "outputs": [],
   "source": [
    "# What does each animal say?\n",
    "animals = {\n",
    "    \"dog\": \"woof\",\n",
    "    \"cat\": \"meow\",\n",
    "    \"pig\": \"oink\",\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "preceding-silly",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "neural-tension",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'woof'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals[\"dog\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "affiliated-auckland",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oink'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals[\"pig\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "greenhouse-glenn",
   "metadata": {},
   "source": [
    "You can also map a string to a number. Whenever you're counting things (e.g., word frequencies), it's very natural to model a counter as a dict from the things you care about to their counts. In fact, counting is such a common use case that Python has a built-in `Counter`.\n",
    "\n",
    "Let's use the string variables `x`, `y`, and `z` from above and tally up the words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "supposed-quilt",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a string'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "clinical-sphere",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is another string'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "vital-summer",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is yet another string'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "emerging-doctrine",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "word_counter = Counter()  # Initialize an empty counter\n",
    "\n",
    "# `[x, y, z]` is a list (note the square brackets) of the three strings.\n",
    "# `s` represents each of these strings in the `for` loop.\n",
    "for s in [x, y, z]:\n",
    "\n",
    "    words = s.split()\n",
    "\n",
    "    # For each word, add it to the counter.\n",
    "    # If the word doesn't already exist in the counter, its count is now 1.\n",
    "    # If the word already exists in the counter, its count increments by 1.\n",
    "    for word in words:\n",
    "        word_counter[word] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "dated-jordan",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'this': 3, 'is': 3, 'a': 1, 'string': 3, 'another': 2, 'yet': 1})"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_counter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "split-windsor",
   "metadata": {},
   "source": [
    "We can see that \"this\" appears three times, \"another\" two times, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accessory-packaging",
   "metadata": {},
   "source": [
    "A dict has the `items` method for iterating through the key-value pairs (i.e., the pairs of things in a dict)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "egyptian-packing",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this 3\n",
      "is 3\n",
      "a 1\n",
      "string 3\n",
      "another 2\n",
      "yet 1\n"
     ]
    }
   ],
   "source": [
    "for word, count in word_counter.items():\n",
    "    print(word, count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "electric-accent",
   "metadata": {},
   "source": [
    "Another advantage of using a `Counter` object is that it has a couple pretty nifty methods, e.g., `most_common`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "offensive-panama",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('this', 3), ('is', 3), ('string', 3), ('another', 2)]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_counter.most_common(4)  # top 4 most common items and their counts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "chief-cattle",
   "metadata": {},
   "source": [
    "## Conditionals\n",
    "\n",
    "No, we aren't talking about counterfactuals, etc. Conditionals in programming languages are just about the plain, indicative kind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "apart-blackjack",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n"
     ]
    }
   ],
   "source": [
    "if 3 > 2:\n",
    "    print(\"hi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "weighted-finding",
   "metadata": {},
   "outputs": [],
   "source": [
    "if 3 < 2:\n",
    "    print(\"hi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "facial-proposition",
   "metadata": {},
   "source": [
    "If condition C is true, do X. If condition C is not true, don't do X. Got it? (For the semanticists / pragmaticists / logicians out there, I know what you have in mind...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "respective-toner",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bye\n"
     ]
    }
   ],
   "source": [
    "if 3 < 2:\n",
    "    print(\"hi\")\n",
    "else:\n",
    "    print(\"bye\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "protecting-mother",
   "metadata": {},
   "source": [
    "This is an if-else code block. If some condition is true, do X, or else do Y instead.\n",
    "\n",
    "This is the point where in a language class you'd be tossed with an example that combines some of what you've been introduced explicitly, possibly with new stuff as well, and you'd be left squinting and trying to make sense of it. Behold!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "superior-ready",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Among the languages that are spoken today, only few are even tolerably well known to science. Of many we have inadequate information, of others none at all.\"\n",
    "# The very first sentence of the chapter \"The Languages of the World\" in Bloomfield's (1933) _Language_\n",
    "\n",
    "start_with_a = []\n",
    "not_start_with_a = []\n",
    "\n",
    "for word in text.strip().lower().split():\n",
    "    if word.startswith(\"a\"):\n",
    "        start_with_a.append(word)\n",
    "    else:\n",
    "        not_start_with_a.append(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "successful-montgomery",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['among', 'are', 'are', 'at', 'all.']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start_with_a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "viral-statement",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['the',\n",
       " 'languages',\n",
       " 'that',\n",
       " 'spoken',\n",
       " 'today,',\n",
       " 'only',\n",
       " 'few',\n",
       " 'even',\n",
       " 'tolerably',\n",
       " 'well',\n",
       " 'known',\n",
       " 'to',\n",
       " 'science.',\n",
       " 'of',\n",
       " 'many',\n",
       " 'we',\n",
       " 'have',\n",
       " 'inadequate',\n",
       " 'information,',\n",
       " 'of',\n",
       " 'others',\n",
       " 'none']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not_start_with_a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "indie-grade",
   "metadata": {},
   "source": [
    "## Outputting A File\n",
    "\n",
    "We're going to wrap up this short tutorial by briefly getting into how to write a text file to the local disk. I'm re-using the word counter from earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "rental-edwards",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'this': 3, 'is': 3, 'a': 1, 'string': 3, 'another': 2, 'yet': 1})"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_counter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "traditional-confidence",
   "metadata": {},
   "source": [
    "The `with open(\"results.csv\", \"w\") as f:` part below takes care of creating a file for the specified file path and representing the file by the variable `f` so that we can specify when and what to write to the file and how."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "informed-hormone",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"results.csv\", \"w\") as f:\n",
    "\n",
    "    for word, count in word_counter.items():\n",
    "        f.write(f\"{word},{count}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thousand-consumer",
   "metadata": {},
   "source": [
    "#### If you are running this notebook locally on your computer...\n",
    "\n",
    "You should have created a text file called `results.csv` at the same directory of this notebook. The text file looks like this:\n",
    "\n",
    "```\n",
    "this,3\n",
    "is,3\n",
    "a,1\n",
    "string,3\n",
    "another,2\n",
    "yet,1\n",
    "```\n",
    "\n",
    "You may open this CSV file with a spreadsheet program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "complete-witch",
   "metadata": {},
   "source": [
    "#### If you are running this notebook on Google Colab...\n",
    "\n",
    "You can run the following cell to retrieve `results.csv` to your computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "worldwide-trustee",
   "metadata": {},
   "outputs": [],
   "source": [
    "from google.colab import files\n",
    "\n",
    "files.download(\"results.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bronze-garlic",
   "metadata": {},
   "source": [
    "I hope you've found this tutorial helpful!"
   ]
  }
 ],
 "metadata": {
  "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}