notebooks/ch10-lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 10: Lists\n",
    "***\n",
    "__Contents__\n",
    "- [A list is a sequence](#A-list-is-a-sequence)\n",
    "- [Lists are mutable](#Lists-are-mutable)\n",
    "- [Traversing a list](#Traversing-a-list)\n",
    "- [List operations](#List-operations)\n",
    "- [List slices](#List-slices)\n",
    "- [List methods](#List-methods)\n",
    "- [Map, filter and reduce](#Map,-filter-and-reduce)\n",
    "- [Deleting elements](#Deleting-elements)\n",
    "- [Lists and strings](#Lists-and-strings)\n",
    "- [Objects and values](#Objects-and-values)\n",
    "- [Aliasing](#Aliasing)\n",
    "- [List arguments](#List-arguments)\n",
    "- [Debugging](#Debugging)\n",
    "- [Exercises](#Exercises)\n",
    "***\n",
    "\n",
    "_This notebook is based on \"Think Python, 2Ed\" by Allen B. Downey_ <br>\n",
    "[https://greenteapress.com/wp/think-python-2e/](https://greenteapress.com/wp/think-python-2e/)\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A list is a sequence\n",
    "- A __list__ is a sequence of values (like a string)\n",
    "- The values are referred to as __elements__ or __items__\n",
    "- The simplest way to create a list is using square brackets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dog', 'fish', 'bird']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[10, 20, 30, 40]\n",
    "['dog', 'fish', 'bird']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The elements of a list don't have to be the same data type in Python (in other languages they do)\n",
    "- However, if you want a sequence with different data types there are better alternatives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['bob', 3.14, 42, ['sam', 55]]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['bob', 3.14, 42, ['sam', 55]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- As you can see, lists can be __nested__\n",
    "- A list containing no elements is an __empty list__\n",
    "- An empty list is created using empty brackets ``[]``\n",
    "- You can assign a list to a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "cheeses = ['Chedder', 'Pepper Jack', 'Queso Fresca']\n",
    "grades = [99, 84, 91]\n",
    "empty = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists are mutable\n",
    "- Unlike strings, lists are __mutable__\n",
    "- This means we can change them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Gouda', 'Pepper Jack', 'Queso Fresca']\n"
     ]
    }
   ],
   "source": [
    "cheeses = ['Chedder', 'Pepper Jack', 'Queso Fresca']\n",
    "cheeses[0] = 'Gouda'\n",
    "print( cheeses )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Note that like strings, indices start at 0\n",
    "- In fact, all the things you can use for indices and use indices for in strings, you can do in lists\n",
    "- This includes the ``in`` operator\n",
    "- One way to think of the relationship between indices and elements is that it is a __mapping__\n",
    "- Each index _maps_ to one of the elements\n",
    "- Much like a word maps to a definition in a dictionary\n",
    "- __TODO__ State diagram for some lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Traversing a list\n",
    "- The most common way to traverse a list is with a ``for`` loop\n",
    "- It is the same approach we used with strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gouda\n",
      "Pepper Jack\n",
      "Queso Fresca\n"
     ]
    }
   ],
   "source": [
    "for cheese in cheeses:\n",
    "    print( cheese )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- However, if you need the index, you need to use the ``range`` and ``len`` functions\n",
    "- For example, you may want to update the values in the list as you traverse it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3]\n",
    "\n",
    "for i in range( len( numbers ) ):\n",
    "    numbers[i] = numbers[i] * 2\n",
    "\n",
    "print( numbers )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A ``for`` loop over an empty list never executes the body of the loop\n",
    "- If you have a nested list, the nested list still counts as a single element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nested_list = ['spam', 1, [ 'Brie', 'Roquefort' , 'Pol le Veq'], [1, 2, 3] ]\n",
    "len( nested_list )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List operations\n",
    "- The ``+`` operator __concatenates__ lists\n",
    "- This means that it links them together into a single list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "a = [ 1, 2, 3 ]\n",
    "b = [ 4, 5, 6 ]\n",
    "c = a + b\n",
    "print( c )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Similarly, the ``*`` operator repeats a list a specified number of times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "d = [ 0 ] * 4\n",
    "print( d )\n",
    "\n",
    "e = [ 1, 2, 3 ] * 3\n",
    "print( e )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List slices\n",
    "- The slice operator also works on lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['b', 'c']\n",
      "['a', 'b', 'c', 'd']\n",
      "['d', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "f = [ 'a', 'b', 'c', 'd', 'e', 'f' ]\n",
    "print( f[1:3] )\n",
    "print( f[:4] )\n",
    "print( f[3:] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Just as with strings, if you omit the first index the slice starts at the beginning\n",
    "- If you omit the second, the slice goes to the end\n",
    "- If you omit both, the slice is th entire list\n",
    "- Since lists are mutable, sometimes it is important to make a copy of a list before you change it\n",
    "- You can use a slice to update multiple elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'x', 'y', 'd', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "f[1:3] = [ 'x', 'y' ]\n",
    "print( f )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List methods\n",
    "- ``append`` will add a new element to the end of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "list1 = [ 'a', 'b', 'c' ]\n",
    "list1.append( 'd' )\n",
    "print( list1 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ``extend`` takes a list as an argument and appends all of the elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e']\n",
      "['d', 'e']\n"
     ]
    }
   ],
   "source": [
    "list2 = [ 'a', 'b', 'c' ]\n",
    "list3 = [ 'd', 'e', ]\n",
    "list2.extend( list3 )\n",
    "\n",
    "print( list2 )\n",
    "print( list3 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Note that ``list3`` is unmodified\n",
    "- ``sort`` arranges the elements of a list from low to high"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e']\n"
     ]
    }
   ],
   "source": [
    "list4 = [ 'd', 'c', 'e', 'a', 'b' ]\n",
    "list4.sort()\n",
    "print( list4 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- All of these list methods are ``void``\n",
    "- This means that they modify the list argument and return ``None``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Map, filter and reduce\n",
    "- To add up all the numbers in a list, use a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_all( a_list ):\n",
    "    total = 0\n",
    "\n",
    "    for value in a_list:\n",
    "        total += value\n",
    "\n",
    "    return total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- As we have seen before, the ``+=`` operator updates a variable\n",
    "- It is referred to as an __augmented assignment statement__\n",
    "- In the code, ``total`` is used in the loop as an __accumulator__\n",
    "- Python provides the ``sum`` function to sum the elements of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_numbers = [ 1, 2, 3 ]\n",
    "sum( list_of_numbers )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- A function that combines a sequence of elements into a single value is sometimes called a ``reduce`` function\n",
    "- Sometimes you want to build a new list from an existing list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Life', 'The', 'Universe', 'And', 'Everything']\n"
     ]
    }
   ],
   "source": [
    "def capitalize_all( a_list ):\n",
    "    result = []\n",
    "    for a_string in a_list:\n",
    "        result.append( a_string.capitalize() )\n",
    "    return result\n",
    "\n",
    "words = [ 'life', 'the', 'universe', 'and', 'everything' ]\n",
    "capitalized_words = capitalize_all( words )\n",
    "print( capitalized_words )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- This is sometimes called a ``map`` function since it \"maps\" a function onto each of the elements in a sequence\n",
    "- Note that a map is more commonly used to refer to a specific data structure (e.g., a __dictionary__)\n",
    "- Another common operation is to __filter__ elements from one list to another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['LIFE', 'AND']\n"
     ]
    }
   ],
   "source": [
    "def only_upper( a_list ):\n",
    "    result = []\n",
    "    for a_string in a_list:\n",
    "        if( a_string.isupper() ):\n",
    "            result.append( a_string )\n",
    "    return result\n",
    "\n",
    "words = [ 'LIFE', 'The', 'uNiverse', 'AND', 'everything' ]\n",
    "some_words = only_upper( words )\n",
    "print( some_words )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deleting elements\n",
    "- The ``pop`` function can be used to delete an element from a list if you know the index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'c']\n",
      "b\n"
     ]
    }
   ],
   "source": [
    "a_list = [ 'a', 'b', 'c' ]\n",
    "value = a_list.pop( 1 )\n",
    "print( a_list )\n",
    "print( value )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Note that the function returns the deleted element\n",
    "- If you don’t specify an index, it operates on the last element\n",
    "- If you don’t need the deleted value, use the ``del`` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'c']\n"
     ]
    }
   ],
   "source": [
    "a_list = [ 'a', 'b', 'c' ]\n",
    "del a_list[1]\n",
    "print( a_list )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ``del`` can also be used with a slice index to remove more than one element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'f']\n"
     ]
    }
   ],
   "source": [
    "a_list = [ 'a', 'b', 'c', 'd', 'e', 'f' ]\n",
    "del a_list[1:5]\n",
    "print( a_list )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If you know the element you want to remove, but not the index, use the ``remove`` operator\n",
    "- Note that it only removes the first matching element if there are duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'c', 'a', 'b', 'c']\n"
     ]
    }
   ],
   "source": [
    "a_list = [ 'a', 'b', 'c', 'a', 'b', 'c' ]\n",
    "a_list.remove( 'b' )\n",
    "print( a_list )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists and strings\n",
    "- A list of characters is not the same as a string\n",
    "- To convert a string to a list, use the ``list`` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['s', 'p', 'a', 'm']\n"
     ]
    }
   ],
   "source": [
    "a_string = 'spam'\n",
    "a_list = list( a_string )\n",
    "print( a_list )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Since it is an operator, don’t use ``list`` as a variable name\n",
    "- Don’t use ``l`` either since it looks like a ``1``\n",
    "- Use ``a_list`` or something more descriptive detailing a value in your algorithm\n",
    "- If you want to split a string into words and not letters, use ``split``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['pining', 'for', 'the', 'fjords']\n"
     ]
    }
   ],
   "source": [
    "a_string = 'pining for the fjords'\n",
    "a_list = a_string.split()\n",
    "print( a_list )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- By default, the __delimiter__ is a space\n",
    "- You can change that by passing it as an argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['spam', 'spam', 'spam']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_string = 'spam-spam-spam'\n",
    "delimiter = '-'\n",
    "a_string.split( delimiter )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ``join`` is the inverse of ``split``\n",
    "- Since it is a string method, you have to invoke it on a string\n",
    "- In this case, invoke it on the delimiter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pining for the fjords'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [ 'pining', 'for', 'the', 'fjords' ]\n",
    "delimiter = ' '\n",
    "delimiter.join( a_list )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objects and values\n",
    "- To check whether two variables refer to the same object, use the ``is`` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'banana'\n",
    "b = 'banana'\n",
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Note that this is different from the values of the two objects being equivalent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [ 1, 2, 3 ]\n",
    "b = [ 1, 2, 3 ]\n",
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- In the first example, Python only create one string object\n",
    "- In the second, Python created two lists that are equivalent, but not identical\n",
    "- _Why the difference?_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aliasing\n",
    "- A variable doesn’t actually hold an object, it has a __reference__ to it\n",
    "- When two variables refer to the same object, it is called __aliasing__\n",
    "- If an object is mutable, changes made to one affect the other"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[17, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "a = [ 1, 2, 3 ]\n",
    "b = a\n",
    "b[0] = 17\n",
    "print( a )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Be careful because this can cause problems if you aren’t paying attention\n",
    "- For immutable objects (like strings), it isn’t a problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List arguments\n",
    "- When you pass a list as an argument to a function, it gets a reference to the list\n",
    "- _What does this mean?_\n",
    "- If the list modifies the list, it is the same list as in the calling function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-30-f8f590617787>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-30-f8f590617787>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def delete_head( a_list )\u001b[0m\n\u001b[0m                             ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "def delete_head( a_list )\n",
    "    del a_list[0]\n",
    "\n",
    "letters = [ 'a', 'b', 'c' ]\n",
    "delete_head( letters )\n",
    "print( letters )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- See the stack diagram on pg. 97 of the textbook\n",
    "- Make sure you know if the function you are using modifies the list argument or returns a new list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "list1 = [ 1, 2 ]\n",
    "list2 = list1.append( 3 )\n",
    "print( list1 )\n",
    "print( list2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debugging\n",
    "- Be careful of common pitfalls when using lists and other mutable objects:\n",
    "  1. Most list methods modify the argument and return ``None``. This is the opposite of string methods.\n",
    "  1. Pick an idiom (or way of doing things) and stick with it\n",
    "  1. Make copies to avoid aliasing and accidental modifications"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "- Write a function called ``cumulative_sum`` that takes a list of numbers and returns the cumulative sum; that is, a new list where the $i$-th element is the sum of the furst $i$ elements from the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cumulative_sum( a_list ):\n",
    "    # INSERT YOUR CODE HERE\n",
    "    return []\n",
    "\n",
    "numbers = [ 1, 2, 3 ]\n",
    "result = cumulative_sum( numbers )\n",
    "# The answer should be:\n",
    "# [ 1, 3, 6 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Write a function called ``chop`` that takes a list and modifies it by removing the first and last element.  The function should return ``None``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remove this line\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "def chop( a_list ):\n",
    "    # INSERT YOUR CODE HERE\n",
    "    print( 'Remove this line' ) # Jupyter needs a statement to compile\n",
    "\n",
    "numbers = [ 1, 2, 3, 4 ]\n",
    "chop( numbers )\n",
    "print( numbers )\n",
    "# Should print: [ 2, 3 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Two words are anagrams if you can rearrange the letters from one to spell the other.  Write a function called ``is_anagram`` that takes two strings and returns ``True`` if they are anagrams."
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}