chapters/chap09.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1331faa1",
   "metadata": {},
   "source": [
    "You can order print and ebook versions of *Think Python 3e* from\n",
    "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n",
    "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bde1c3f9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from os.path import basename, exists\n",
    "\n",
    "def download(url):\n",
    "    filename = basename(url)\n",
    "    if not exists(filename):\n",
    "        from urllib.request import urlretrieve\n",
    "\n",
    "        local, _ = urlretrieve(url, filename)\n",
    "        print(\"Downloaded \" + str(local))\n",
    "    return filename\n",
    "\n",
    "download('https://github.com/AllenDowney/ThinkPython/raw/v3/thinkpython.py');\n",
    "download('https://github.com/AllenDowney/ThinkPython/raw/v3/diagram.py');\n",
    "\n",
    "import thinkpython"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c25ca7e",
   "metadata": {},
   "source": [
    "# Lists\n",
    "\n",
    "This chapter presents one of Python's most useful built-in types, lists.\n",
    "You will also learn more about objects and what can happen when multiple variables refer to the same object.\n",
    "\n",
    "In the exercises at the end of the chapter, we'll make a word list and use it to search for special words like palindromes and anagrams."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d32b3e2",
   "metadata": {},
   "source": [
    "## A list is a sequence\n",
    "\n",
    "Like a string, a **list** is a sequence of values. In a string, the\n",
    "values are characters; in a list, they can be any type.\n",
    "The values in a list are called **elements**.\n",
    "\n",
    "There are several ways to create a new list; the simplest is to enclose the elements in square brackets (`[` and `]`).\n",
    "For example, here is a list of two integers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a16a119b",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [42, 123]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5d6112c",
   "metadata": {},
   "source": [
    "And here's a list of three strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ac7a4a0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "cheeses = ['Cheddar', 'Edam', 'Gouda']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dda58c67",
   "metadata": {},
   "source": [
    "The elements of a list don't have to be the same type.\n",
    "The following list contains a string, a float, an integer, and even another list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "18fb0e21",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = ['spam', 2.0, 5, [10, 20]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "147fa217",
   "metadata": {},
   "source": [
    "A list within another list is **nested**.\n",
    "\n",
    "A list that contains no elements is called an empty list; you can create\n",
    "one with empty brackets, `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0ff58916",
   "metadata": {},
   "outputs": [],
   "source": [
    "empty = []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f95381bc",
   "metadata": {},
   "source": [
    "The `len` function returns the length of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f3153f36",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(cheeses)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "371403a3",
   "metadata": {},
   "source": [
    "The length of an empty list is `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "58727d35",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "len(empty)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3589a5d",
   "metadata": {},
   "source": [
    "The following figure shows the state diagram for `cheeses`, `numbers` and `empty`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "25582cad",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from diagram import make_list, Binding, Value\n",
    "\n",
    "list1 = make_list(cheeses, dy=-0.3, offsetx=0.17)\n",
    "binding1 = Binding(Value('cheeses'), list1)\n",
    "\n",
    "list2 = make_list(numbers, dy=-0.3, offsetx=0.17)\n",
    "binding2 = Binding(Value('numbers'), list2)\n",
    "\n",
    "list3 = make_list(empty, dy=-0.3, offsetx=0.1)\n",
    "binding3 = Binding(Value('empty'), list3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "925c7d67",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from diagram import diagram, adjust, Bbox\n",
    "\n",
    "width, height, x, y = [3.66, 1.58, 0.45, 1.2]\n",
    "ax = diagram(width, height)\n",
    "bbox1 = binding1.draw(ax, x, y)\n",
    "bbox2 = binding2.draw(ax, x+2.25, y)\n",
    "bbox3 = binding3.draw(ax, x+2.25, y-1.0)\n",
    "\n",
    "bbox = Bbox.union([bbox1, bbox2, bbox3])\n",
    "#adjust(x, y, bbox)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "503f25d8",
   "metadata": {},
   "source": [
    "Lists are represented by boxes with the word \"list\" outside and the numbered elements of the list inside."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b8ff01",
   "metadata": {},
   "source": [
    "## Lists are mutable\n",
    "\n",
    "To read an element of a list, we can use the bracket operator.\n",
    "The index of the first element is `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9deb85a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "cheeses[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9747e951",
   "metadata": {},
   "source": [
    "Unlike strings, lists are mutable. When the bracket operator appears on\n",
    "the left side of an assignment, it identifies the element of the list\n",
    "that will be assigned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "98ec5d9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers[1] = 17\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5097a517",
   "metadata": {},
   "source": [
    "The second element of `numbers`, which used to be `123`, is now `17`.\n",
    "\n",
    "List indices work the same way as string indices:\n",
    "\n",
    "-   Any integer expression can be used as an index.\n",
    "\n",
    "-   If you try to read or write an element that does not exist, you get\n",
    "    an `IndexError`.\n",
    "\n",
    "-   If an index has a negative value, it counts backward from the end of\n",
    "    the list.\n",
    "\n",
    "The `in` operator works on lists -- it checks whether a given element appears anywhere in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "000aed26",
   "metadata": {},
   "outputs": [],
   "source": [
    "'Edam' in cheeses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "bcb8929c",
   "metadata": {},
   "outputs": [],
   "source": [
    "'Wensleydale' in cheeses"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89d01ebf",
   "metadata": {},
   "source": [
    "Although a list can contain another list, the nested list still counts as a single element -- so in the following list, there are only four elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5ad51a26",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = ['spam', 2.0, 5, [10, 20]]\n",
    "len(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e0ea41d",
   "metadata": {},
   "source": [
    "And `10` is not considered to be an element of `t` because it is an element of a nested list, not `t`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "156dbc10",
   "metadata": {},
   "outputs": [],
   "source": [
    "10 in t"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ee7a4d9",
   "metadata": {},
   "source": [
    "## List slices\n",
    "\n",
    "The slice operator works on lists the same way it works on strings.\n",
    "The following example selects the second and third elements from a list of four letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "70b16371",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = ['a', 'b', 'c', 'd']\n",
    "letters[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc59d952",
   "metadata": {},
   "source": [
    "If you omit the first index, the slice starts at the beginning. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e67bab33",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters[:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aaaae86",
   "metadata": {},
   "source": [
    "If you omit the second, the slice goes to the end. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a310f506",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters[2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67ad02e8",
   "metadata": {},
   "source": [
    "So if you omit both, the slice is a copy of the whole list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1385a75e",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9232c1ef",
   "metadata": {},
   "source": [
    "Another way to copy a list is to use the `list` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a0ca0135",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50e4b182",
   "metadata": {},
   "source": [
    "Because `list` is the name of a built-in function, you should avoid using it as a variable name.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b057c0c",
   "metadata": {},
   "source": [
    "## List operations\n",
    "\n",
    "The `+` operator concatenates lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "66804de0",
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = [1, 2]\n",
    "t2 = [3, 4]\n",
    "t1 + t2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "474a5c40",
   "metadata": {},
   "source": [
    "The `*` operator repeats a list a given number of times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "96620f93",
   "metadata": {},
   "outputs": [],
   "source": [
    "['spam'] * 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b33bc51",
   "metadata": {},
   "source": [
    "No other mathematical operators work with lists, but the built-in function `sum` adds up the elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0808ed08",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum(t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f216a14d",
   "metadata": {},
   "source": [
    "And `min` and `max` find the smallest and largest elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7ed7e53d",
   "metadata": {},
   "outputs": [],
   "source": [
    "min(t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "dda02e4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "max(t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "533a2009",
   "metadata": {},
   "source": [
    "## List methods\n",
    "\n",
    "Python provides methods that operate on lists. For example, `append`\n",
    "adds a new element to the end of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bcf04ef9",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters.append('e')\n",
    "letters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccc57f77",
   "metadata": {},
   "source": [
    "`extend` takes a list as an argument and appends all of the elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "be55916d",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters.extend(['f', 'g'])\n",
    "letters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f39d9f6",
   "metadata": {},
   "source": [
    "There are two methods that remove elements from a list.\n",
    "If you know the index of the element you want, you can use `pop`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b22da905",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = ['a', 'b', 'c']\n",
    "t.pop(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6729415a",
   "metadata": {},
   "source": [
    "The return value is the element that was removed.\n",
    "And we can confirm that the list has been modified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "01bdff91",
   "metadata": {},
   "outputs": [],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e97ee7d",
   "metadata": {},
   "source": [
    "If you know the element you want to remove (but not the index), you can use `remove`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "babe366e",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = ['a', 'b', 'c']\n",
    "t.remove('b')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60e710fe",
   "metadata": {},
   "source": [
    "The return value from `remove` is `None`.\n",
    "But we can confirm that the list has been modified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f80f5b1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a9448a8",
   "metadata": {},
   "source": [
    "If the element you ask for is not in the list, that's a ValueError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "861f8e7e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%expect ValueError\n",
    "\n",
    "t.remove('d')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18305f96",
   "metadata": {},
   "source": [
    "## Lists and strings\n",
    "\n",
    "A string is a sequence of characters and a list is a sequence of values,\n",
    "but a list of characters is not the same as a string. \n",
    "To convert from a string to a list of characters, you can use the `list` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "1b50bc13",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'spam'\n",
    "t = list(s)\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0291ef69",
   "metadata": {},
   "source": [
    "The `list` function breaks a string into individual letters.\n",
    "If you want to break a string into words, you can use the `split` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c28e5127",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'pining for the fjords'\n",
    "t = s.split()\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e16909d",
   "metadata": {},
   "source": [
    "An optional argument called a **delimiter** specifies which characters to use as word boundaries. The following example uses a hyphen as a delimiter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "ec6ea206",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'ex-parrot'\n",
    "t = s.split('-')\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c61f916",
   "metadata": {},
   "source": [
    "If you have a list of strings, you can concatenate them into a single string using `join`.\n",
    "`join` is a string method, so you have to invoke it on the delimiter and pass the list as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "75c74d3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "delimiter = ' '\n",
    "t = ['pining', 'for', 'the', 'fjords']\n",
    "s = delimiter.join(t)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bedd842b",
   "metadata": {},
   "source": [
    "In this case the delimiter is a space character, so `join` puts a space\n",
    "between words.\n",
    "To join strings without spaces, you can use the empty string, `''`, as a delimiter."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "181215ce",
   "metadata": {},
   "source": [
    "## Looping through a list\n",
    "\n",
    "You can use a `for` statement to loop through the elements of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "a5df1e10",
   "metadata": {},
   "outputs": [],
   "source": [
    "for cheese in cheeses:\n",
    "    print(cheese)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0e53a09",
   "metadata": {},
   "source": [
    "For example, after using `split` to make a list of words, we can use `for` to loop through them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "76b2c2e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'pining for the fjords'\n",
    "\n",
    "for word in s.split():\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0857b55b",
   "metadata": {},
   "source": [
    "A `for` loop over an empty list never runs the indented statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "7e844887",
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in []:\n",
    "    print('This never happens.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e5f55c9",
   "metadata": {},
   "source": [
    "## Sorting lists\n",
    "\n",
    "Python provides a built-in function called `sorted` that sorts the elements of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "9db54d53",
   "metadata": {},
   "outputs": [],
   "source": [
    "scramble = ['c', 'a', 'b']\n",
    "sorted(scramble)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44e028cf",
   "metadata": {},
   "source": [
    "The original list is unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "33d11287",
   "metadata": {},
   "outputs": [],
   "source": [
    "scramble"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "530146af",
   "metadata": {},
   "source": [
    "`sorted` works with any kind of sequence, not just lists. So we can sort the letters in a string like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "38c7cb0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted('letters')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f90bd9ea",
   "metadata": {},
   "source": [
    "The result it a list.\n",
    "To convert the list to a string, we can use `join`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "2adb2fc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "''.join(sorted('letters'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a57084e2",
   "metadata": {},
   "source": [
    "With an empty string as the delimiter, the elements of the list are joined with nothing between them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce98b3d5",
   "metadata": {},
   "source": [
    "## Objects and values\n",
    "\n",
    "If we run these assignment statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "aa547282",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'banana'\n",
    "b = 'banana'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33d020aa",
   "metadata": {},
   "source": [
    "We know that `a` and `b` both refer to a string, but we don't know whether they refer to the *same* string. \n",
    "There are two possible states, shown in the following figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "95a2aded",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from diagram import Frame, Stack\n",
    "\n",
    "s = 'banana'\n",
    "bindings = [Binding(Value(name), Value(repr(s))) for name in 'ab']\n",
    "frame1 = Frame(bindings, dy=-0.25)\n",
    "\n",
    "binding1 = Binding(Value('a'), Value(repr(s)), dy=-0.11)\n",
    "binding2 = Binding(Value('b'), draw_value=False, dy=0.11)\n",
    "frame2 = Frame([binding1, binding2], dy=-0.25)\n",
    "\n",
    "stack = Stack([frame1, frame2], dx=1.7, dy=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "3d75a28c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "width, height, x, y = [2.85, 0.76, 0.17, 0.51]\n",
    "ax = diagram(width, height)\n",
    "bbox = stack.draw(ax, x, y)\n",
    "# adjust(x, y, bbox)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f0b0431",
   "metadata": {},
   "source": [
    "In the diagram on the left, `a` and `b` refer to two different objects that have the\n",
    "same value. In the diagram on the right, they refer to the same object.\n",
    "To check whether two variables refer to the same object, you can use the `is` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "a37e37bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'banana'\n",
    "b = 'banana'\n",
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1eb0e36",
   "metadata": {},
   "source": [
    "In this example, Python only created one string object, and both `a`\n",
    "and `b` refer to it.\n",
    "But when you create two lists, you get two objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "d6af7316",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [1, 2, 3]\n",
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8d4c3d4",
   "metadata": {},
   "source": [
    "So the state diagram looks like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "dea08b82",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "t = [1, 2, 3]\n",
    "binding1 = Binding(Value('a'), Value(repr(t)))\n",
    "binding2 = Binding(Value('b'), Value(repr(t)))\n",
    "frame = Frame([binding1, binding2], dy=-0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "7e66ee69",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "width, height, x, y = [1.16, 0.76, 0.21, 0.51]\n",
    "ax = diagram(width, height)\n",
    "bbox = frame.draw(ax, x, y)\n",
    "# adjust(x, y, bbox)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc115a9f",
   "metadata": {},
   "source": [
    "In this case we would say that the two lists are **equivalent**, because they have the same elements, but not **identical**, because they are not the same object. \n",
    "If two objects are identical, they are also equivalent, but if they are equivalent, they are not necessarily identical."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a58db021",
   "metadata": {},
   "source": [
    "## Aliasing\n",
    "\n",
    "If `a` refers to an object and you assign `b = a`, then both variables refer to the same object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "d6a7eb5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a\n",
    "b is a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6ab3262",
   "metadata": {},
   "source": [
    "So the state diagram looks like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "dd406791",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "t = [1, 2, 3]\n",
    "binding1 = Binding(Value('a'), Value(repr(t)), dy=-0.11)\n",
    "binding2 = Binding(Value('b'), draw_value=False, dy=0.11)\n",
    "frame = Frame([binding1, binding2], dy=-0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "552e1e1e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "width, height, x, y = [1.11, 0.81, 0.17, 0.56]\n",
    "ax = diagram(width, height)\n",
    "bbox = frame.draw(ax, x, y)\n",
    "# adjust(x, y, bbox)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c676fde9",
   "metadata": {},
   "source": [
    "The association of a variable with an object is called a **reference**.\n",
    "In this example, there are two references to the same object.\n",
    "\n",
    "An object with more than one reference has more than one name, so we say the object is **aliased**.\n",
    "If the aliased object is mutable, changes made with one name affect the other.\n",
    "In this example, if we change the object `b` refers to, we are also changing the object `a` refers to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "6e3c1b24",
   "metadata": {},
   "outputs": [],
   "source": [
    "b[0] = 5\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3ef0537",
   "metadata": {},
   "source": [
    "So we would say that `a` \"sees\" this change.\n",
    "Although this behavior can be useful, it is error-prone.\n",
    "In general, it is safer to avoid aliasing when you are working with mutable objects.\n",
    "\n",
    "For immutable objects like strings, aliasing is not as much of a problem.\n",
    "In this example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "dad8a246",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'banana'\n",
    "b = 'banana'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "952bbf60",
   "metadata": {},
   "source": [
    "It almost never makes a difference whether `a` and `b` refer to the same\n",
    "string or not."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35045bef",
   "metadata": {},
   "source": [
    "## List arguments\n",
    "\n",
    "When you pass a list to a function, the function gets a reference to the\n",
    "list. If the function modifies the list, the caller sees the change. For\n",
    "example, `pop_first` uses the list method `pop` to remove the first element from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "613b1845",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pop_first(lst):\n",
    "    return lst.pop(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4953b0f9",
   "metadata": {},
   "source": [
    "We can use it like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "3aff3598",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = ['a', 'b', 'c']\n",
    "pop_first(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5d3c1e",
   "metadata": {},
   "source": [
    "The return value is the first element, which has been removed from the list -- as we can see by displaying the modified list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "c10e4dcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5288e08",
   "metadata": {},
   "source": [
    "In this example, the parameter `lst` and the variable `letters` are aliases for the same object, so the state diagram looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "a13e72c7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "lst = make_list('abc', dy=-0.3, offsetx=0.1)\n",
    "binding1 = Binding(Value('letters'), draw_value=False)\n",
    "frame1 = Frame([binding1], name='__main__', loc='left')\n",
    "\n",
    "binding2 = Binding(Value('lst'), draw_value=False, dx=0.61, dy=0.35)\n",
    "frame2 = Frame([binding2], name='pop_first', loc='left', offsetx=0.08)\n",
    "\n",
    "stack = Stack([frame1, frame2], dx=-0.3, dy=-0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "1a06dae9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "width, height, x, y = [2.04, 1.24, 1.06, 0.85]\n",
    "ax = diagram(width, height)\n",
    "bbox1 = stack.draw(ax, x, y)\n",
    "bbox2 = lst.draw(ax, x+0.5, y)\n",
    "bbox = Bbox.union([bbox1, bbox2])\n",
    "adjust(x, y, bbox)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1a093d2",
   "metadata": {},
   "source": [
    "Passing a reference to an object as an argument to a function creates a form of aliasing.\n",
    "If the function modifies the object, those changes persist after the function is done."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88c07ec9",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Making a word list\n",
    "\n",
    "In the previous chapter, we read the file `words.txt` and searched for words with certain properties, like using the letter `e`.\n",
    "But we read the entire file many times, which is not efficient.\n",
    "It is better to read the file once and put the words in a list.\n",
    "The following loop shows how."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "6550f0b8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "download('https://raw.githubusercontent.com/AllenDowney/ThinkPython/v3/words.txt');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "e5a94833",
   "metadata": {},
   "outputs": [],
   "source": [
    "word_list = []\n",
    "\n",
    "for line in open('words.txt'):\n",
    "    word = line.strip()\n",
    "    word_list.append(word)\n",
    "    \n",
    "len(word_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44450ffa",
   "metadata": {},
   "source": [
    "Before the loop, `word_list` is initialized with an empty list.\n",
    "Each time through the loop, the `append` method adds a word to the end.\n",
    "When the loop is done, there are more than 113,000 words in the list.\n",
    "\n",
    "Another way to do the same thing is to use `read` to read the entire file into a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "32e28204",
   "metadata": {},
   "outputs": [],
   "source": [
    "string = open('words.txt').read()\n",
    "len(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65718c7f",
   "metadata": {},
   "source": [
    "The result is a single string with more than a million characters.\n",
    "We can use the `split` method to split it into a list of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "4e35f7ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "word_list = string.split()\n",
    "len(word_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b5b25a3",
   "metadata": {},
   "source": [
    "Now, to check whether a string appears in the list, we can use the `in` operator.\n",
    "For example, `'demotic'` is in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "a778a62a",
   "metadata": {},
   "outputs": [],
   "source": [
    "'demotic' in word_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9df6674d",
   "metadata": {},
   "source": [
    "But `'contrafibularities'` is not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "63341c0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "'contrafibularities' in word_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "243c25b6",
   "metadata": {},
   "source": [
    "And I have to say, I'm anaspeptic about it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce9ffd79",
   "metadata": {},
   "source": [
    "## Debugging\n",
    "\n",
    "Note that most list methods modify the argument and return `None`.\n",
    "This is the opposite of the string methods, which return a new string and leave the original alone.\n",
    "\n",
    "If you are used to writing string code like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "88872f14",
   "metadata": {},
   "outputs": [],
   "source": [
    "word = 'plumage!'\n",
    "word = word.strip('!')\n",
    "word"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2117582",
   "metadata": {},
   "source": [
    "It is tempting to write list code like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "e28e7135",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = [1, 2, 3]\n",
    "t = t.remove(3)           # WRONG!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "991c439d",
   "metadata": {},
   "source": [
    "`remove` modifies the list and returns `None`, so next operation you perform with `t` is likely to fail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "97cf0c61",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%%expect AttributeError\n",
    "\n",
    "t.remove(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c500e2d8",
   "metadata": {},
   "source": [
    "This error message takes some explaining.\n",
    "An **attribute** of an object is a variable or method associated with it.\n",
    "In this case, the value of `t` is `None`, which is a `NoneType` object, which does not have a attribute named `remove`, so the result is an `AttributeError`.\n",
    "\n",
    "If you see an error message like this, you should look backward through the program and see if you might have called a list method incorrectly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f90db780",
   "metadata": {},
   "source": [
    "## Glossary\n",
    "\n",
    "**list:**\n",
    " An object that contains a sequence of values.\n",
    "\n",
    "**element:**\n",
    " One of the values in a list or other sequence.\n",
    "\n",
    "**nested list:**\n",
    "A list that is an element of another list.\n",
    "\n",
    "**delimiter:**\n",
    " A character or string used to indicate where a string should be split.\n",
    "\n",
    "**equivalent:**\n",
    " Having the same value.\n",
    "\n",
    "**identical:**\n",
    " Being the same object (which implies equivalence).\n",
    "\n",
    "**reference:**\n",
    " The association between a variable and its value.\n",
    "\n",
    "**aliased:**\n",
    "If there is more than one variable that refers to an object, the object is aliased.\n",
    "\n",
    "**attribute:**\n",
    " One of the named values associated with an object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e67864e5",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4e34564",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This cell tells Jupyter to provide detailed debugging information\n",
    "# when a runtime error occurs. Run it before working on the exercises.\n",
    "\n",
    "%xmode Verbose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae9c42da",
   "metadata": {},
   "source": [
    "### Ask a virtual assistant\n",
    "\n",
    "In this chapter, I used the words \"contrafibularities\" and \"anaspeptic\", but they are not actually English words.\n",
    "They were used in the British television show *Black Adder*, Season 3, Episode 2, \"Ink and Incapability\".\n",
    "\n",
    "However, when I asked ChatGPT 3.5 (August 3, 2023 version) where those words came from, it initially claimed they are from Monty Python, and later claimed they are from the Tom Stoppard play *Rosencrantz and Guildenstern Are Dead*.\n",
    "\n",
    "If you ask now, you might get different results.\n",
    "But this example is a reminder that virtual assistants are not always accurate, so you should check whether the results are correct.\n",
    "As you gain experience, you will get a sense of which questions virtual assistants can answer reliably.\n",
    "In this example, a conventional web search can identify the source of these words quickly.\n",
    "\n",
    "If you get stuck on any of the exercises in this chapter, consider asking a virtual assistant for help.\n",
    "If you get a result that uses features we haven't learned yet, you can assign the VA a \"role\".\n",
    "\n",
    "For example, before you ask a question try typing \"Role: Basic Python Programming Instructor\".\n",
    "After that, the responses you get should use only basic features.\n",
    "If you still see features we you haven't learned, you can follow up with \"Can you write that using only basic Python features?\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31d5b304",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Two words are anagrams if you can rearrange the letters from one to spell the other.\n",
    "For example, `tops` is an anagram of `stop`.\n",
    "\n",
    "One way to check whether two words are anagrams is to sort the letters in both words.\n",
    "If the lists of sorted letters are the same, the words are anagrams.\n",
    "\n",
    "Write a function called `is_anagram` that takes two strings and returns `True` if they are anagrams."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a882bfeb",
   "metadata": {
    "tags": []
   },
   "source": [
    "To get you started, here's an outline of the function with doctests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "9c5916ed",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def is_anagram(word1, word2):\n",
    "    \"\"\"Checks whether two words are anagrams.\n",
    "    \n",
    "    >>> is_anagram('tops', 'stop')\n",
    "    True\n",
    "    >>> is_anagram('skate', 'takes')\n",
    "    True\n",
    "    >>> is_anagram('tops', 'takes')\n",
    "    False\n",
    "    >>> is_anagram('skate', 'stop')\n",
    "    False\n",
    "    \"\"\"\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "5885cbd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a86e7403",
   "metadata": {
    "tags": []
   },
   "source": [
    "You can use `doctest` to test your function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "ce7a96ec",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from doctest import run_docstring_examples\n",
    "\n",
    "def run_doctests(func):\n",
    "    run_docstring_examples(func, globals(), name=func.__name__)\n",
    "\n",
    "run_doctests(is_anagram)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8501f3ba",
   "metadata": {},
   "source": [
    "Using your function and the word list, find all the anagrams of `takes`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "75e17c7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f279f2f",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Python provides a built-in function called `reversed` that takes as an argument a sequence of elements -- like a list or string -- and returns a `reversed` object that contains the elements in reverse order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "aafa5db5",
   "metadata": {},
   "outputs": [],
   "source": [
    "reversed('parrot')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f95c76f",
   "metadata": {},
   "source": [
    "If you want the reversed elements in a list, you can use the `list` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "06cbb42a",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(reversed('parrot'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fc79a2f",
   "metadata": {},
   "source": [
    "Of if you want them in a string, you can use the `join` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "18a73205",
   "metadata": {},
   "outputs": [],
   "source": [
    "''.join(reversed('parrot'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec4ce196",
   "metadata": {},
   "source": [
    "So we can write a function that reverses a word like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "408932cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse_word(word):\n",
    "    return ''.join(reversed(word))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21550b5f",
   "metadata": {},
   "source": [
    "A palindrome is a word that is spelled the same backward and forward, like \"noon\" and \"rotator\".\n",
    "Write a function called `is_palindrome` that takes a string argument and returns `True` if it is a palindrome and `False` otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3748b4e0",
   "metadata": {
    "tags": []
   },
   "source": [
    "Here's an outline of the function with doctests you can use to check your function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "9179d51c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def is_palindrome(word):\n",
    "    \"\"\"Check if a word is a palindrome.\n",
    "    \n",
    "    >>> is_palindrome('bob')\n",
    "    True\n",
    "    >>> is_palindrome('alice')\n",
    "    False\n",
    "    >>> is_palindrome('a')\n",
    "    True\n",
    "    >>> is_palindrome('')\n",
    "    True\n",
    "    \"\"\"\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "16d493ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "33c9b4ec",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "run_doctests(is_palindrome)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad857abf",
   "metadata": {},
   "source": [
    "You can use the following loop to find all of the palindromes in the word list with at least 7 letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "fea01394",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for word in word_list:\n",
    "    if len(word) >= 7 and is_palindrome(word):\n",
    "        print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11386f70",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Write a function called `reverse_sentence` that takes as an argument a string that contains any number of words separated by spaces.\n",
    "It should return a new string that contains the same words in reverse order.\n",
    "For example, if the argument is \"Reverse this sentence\", the result should be \"Sentence this reverse\".\n",
    "\n",
    "Hint: You can use the `capitalize` methods to capitalize the first word and convert the other words to lowercase. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13882893",
   "metadata": {
    "tags": []
   },
   "source": [
    "To get you started, here's an outline of the function with doctests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "d9b5b362",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def reverse_sentence(input_string):\n",
    "    '''Reverse the words in a string and capitalize the first.\n",
    "    \n",
    "    >>> reverse_sentence('Reverse this sentence')\n",
    "    'Sentence this reverse'\n",
    "\n",
    "    >>> reverse_sentence('Python')\n",
    "    'Python'\n",
    "\n",
    "    >>> reverse_sentence('')\n",
    "    ''\n",
    "\n",
    "    >>> reverse_sentence('One for all and all for one')\n",
    "    'One for all and all for one'\n",
    "    '''\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "a2cb1451",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "769d1c7a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "run_doctests(reverse_sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb5f24b1",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Write a function called `total_length` that takes a list of strings and returns the total length of the strings.\n",
    "The total length of the words in `word_list` should be $902{,}728$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "1fba5377",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "21f4cf1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution goes here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3efb216",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a7f4edf8",
   "metadata": {
    "tags": []
   },
   "source": [
    "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n",
    "\n",
    "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n",
    "\n",
    "Code license: [MIT License](https://mit-license.org/)\n",
    "\n",
    "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}