Add section on mutability to lesson 4

Author: audiodude

lessons/04-function-definitions/function_definitions.ipynb

@@ -148,7 +148,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "8e60bf90",
    "metadata": {},
    "outputs": [],
@@ -173,7 +173,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "eee490d3",
    "metadata": {},
    "outputs": [],
@@ -530,163 +530,263 @@
   },
   {
    "cell_type": "markdown",
-   "id": "b6700428",
+   "id": "5a6efcb7",
    "metadata": {},
    "source": [
-    "## Iterating over dictionaries\n",
+    "# Mutability\n",
     "\n",
-    "We can iterate over dictionaries by calling the dictionary's `.items()` method. It returns an iterable of tuples, with each tuple containing a key and its value:"
+    "**Mutability** refers to the concept of what values in a program can change. An object in Python is **mutable** if it can be changed, and **immutable** if it cannot. We've already discussed the fact that tuples are immutable. Strings and numbers are also immutable. If you assign a number to a variable, it's always the same number. If you later assign a different number to the variable, the variable has changed, but the number hasn't."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "a9e25ce5",
+   "id": "b4448fc8",
    "metadata": {},
    "outputs": [],
    "source": [
-    "prices = {\n",
-    "    'apple': 0.99,\n",
-    "    'orange': 1.29,\n",
-    "    'watermelon': {'one': 1.79, 'two': 2.99},\n",
-    "}\n",
+    "x = 42\n",
+    "print(x)\n",
     "\n",
-    "for key, value in prices.items():\n",
-    "    print(f'Key is {key}, value is {value}')"
+    "# x.add(1)  # This isn't possible, we can't change the number\n",
+    "\n",
+    "# We still have a variable named x, it's the same variable, but now\n",
+    "# it refers to a different value.\n",
+    "x = 50\n",
+    "print(x)\n",
+    "\n",
+    "# Now we've added 10 to x, which creates a \"new\" number, that\n",
+    "# is assigned to x.\n",
+    "x = x + 10\n",
+    "print(x)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "31ebc9af",
+   "id": "125fd6f2",
    "metadata": {},
    "source": [
-    "## Adding default arguments\n",
-    "\n",
-    "A popular pattern when writing Python code is to use keyword arguments to introduce new features to a function without having to update all of the existing places where it is called."
+    "42, 50 and 60 are all different numbers. The variable `x` holds each of them in turn."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a78eb419",
+   "metadata": {},
+   "source": [
+    "Strings may \"appear\" to be mutable, but methods on strings that seem to modify the string actually return a new string."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "1ea57c5f",
+   "id": "dd1bbd4e",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def find_job(database, cpu):\n",
-    "    workers = []\n",
-    "    for name, cycles in database.items():\n",
-    "        if cycles >= cpu:\n",
-    "            workers.append(name)\n",
-    "    return workers\n",
-    "        \n",
-    "def find_increasing_jobs(database):\n",
-    "    candidates = {}\n",
-    "    for i in range(0, 100, 10):\n",
-    "        candidates[i] = find_job(database, i)\n",
-    "    return candidates\n",
-    "        \n",
-    "db = {\n",
-    "    'alpha': 45,\n",
-    "    'beta': 55,\n",
-    "    'gamma': 91,\n",
-    "    'phi': 27,\n",
-    "}\n",
-    "\n",
-    "data = find_increasing_jobs(db)\n",
-    "print(data)"
+    "p = 'pineapple'\n",
+    "p.capitalize()\n",
+    "print(p)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "7801a176",
+   "id": "8c5f58d8",
    "metadata": {},
    "source": [
-    "We can add an argument for only returning the first job that meets our criteria. The main thing here to consider is that the default value of the argument should match the behavior before we modified the code. Here we introduce the `first_only` keyword argument, and set it to `False` because the old version of the function behaved as if this value was `False`."
+    "The code `p.capitalize()` returns a new version of the string with it capitalized. We have to assign it to a variable or otherwise use it in an expression for it to do anything."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "229bc790",
+   "id": "31933868",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def find_job(database, cpu, first_only=False):\n",
-    "    workers = []\n",
-    "    for name, cycles in database.items():\n",
-    "        if cycles >= cpu:\n",
-    "            workers.append(name)\n",
-    "            if first_only:\n",
-    "                break\n",
-    "    return workers\n",
-    "\n",
-    "def find_first_increasing_jobs(database):\n",
-    "    candidates = {}\n",
-    "    for i in range(0, 100, 10):\n",
-    "        candidates[i] = find_job(database, i, first_only=True)\n",
-    "    return candidates\n",
-    "\n",
-    "data = find_increasing_jobs(db)\n",
-    "print(data)\n",
-    "\n",
-    "print('===')\n",
-    "\n",
-    "data2 = find_first_increasing_jobs(db)\n",
-    "print(data2)"
+    "p = 'pineapple'\n",
+    "q = p.capitalize()\n",
+    "print(q)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "bf69868e",
+   "id": "0ac4580f",
    "metadata": {},
    "source": [
-    "Given the following function definition:"
+    "Of course, we could have also \"overwritten\" the value of `p` with the newly capitilized string."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "b7c3a4b1",
+   "id": "5ac8d008",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def find_grocery_deals(groceries, price_point):\n",
-    "  ans = []\n",
-    "  for item, price in groceries.items():\n",
-    "    if price <= price_point:\n",
-    "      ans.append(item)\n",
-    "  return ans\n",
+    "p = 'pineapple'\n",
+    "p = p.capitalize()\n",
+    "print(p)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36faae94",
+   "metadata": {},
+   "source": [
+    "Meanwhile, data structures like lists and dictionaries are mutable. We can modify them with methods like `append()`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1dc8e9c3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['apple', 'lime', 'pear', 'kiwi']\n"
+     ]
+    }
+   ],
+   "source": [
+    "fruits = ['apple', 'lime', 'pear']\n",
+    "fruits.append('kiwi')\n",
+    "print(fruits)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c2ede6f",
+   "metadata": {},
+   "source": [
+    "If two variables refer to the same list, changes to the list will be reflected in both."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a3535ed3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['apple', 'lime', 'pear', 'kiwi']\n"
+     ]
+    }
+   ],
+   "source": [
+    "fruits = ['apple', 'lime', 'pear']\n",
+    "other_fruits = fruits\n",
+    "fruits.append('kiwi')\n",
+    "print(other_fruits)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "65f2f7dc",
+   "metadata": {},
+   "source": [
+    "This means that if we pass a list to a funciton, and the function modifies the list, we will see those changes in the place where we called the function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3069413b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['apple', 'lime', 'pear']\n",
+      "['apple', 'lime', 'pear', 'kiwi']\n"
+     ]
+    }
+   ],
+   "source": [
+    "def add_kiwi(fruits):\n",
+    "    fruits.append('kiwi')\n",
     "\n",
-    "safeway = {\n",
-    "  'apples': 1.29,\n",
-    "  'limes': 0.79,\n",
-    "  'toilet paper': 2.99,\n",
-    "  'chicken': 4.99,\n",
-    "  'beans': 1.79,\n",
-    "}\n",
+    "fruit_list = ['apple', 'lime', 'pear']\n",
+    "print(fruit_list)\n",
+    "add_kiwi(fruit_list)\n",
+    "print(fruit_list)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73447721",
+   "metadata": {},
+   "source": [
+    "Not so for numbers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e5fa2b9a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "42\n",
+      "42\n"
+     ]
+    }
+   ],
+   "source": [
+    "def add_ten(x):\n",
+    "  # We only reassigned the value of the variable x, we did not\n",
+    "  # modify the number `42`, because the number is immutable.\n",
+    "  x = x + 10\n",
     "\n",
-    "result = find_grocery_deals(safeway, 2.00)\n",
-    "print(result)"
+    "y = 42\n",
+    "print(y)\n",
+    "add_ten(y)\n",
+    "print(y)\n"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "9fd18c5d",
+   "id": "b48eb1a1",
    "metadata": {},
    "source": [
-    "Try to extend the `find_grocery_deals` function in a *backwards compatible way*, so that it can skip any items that are in the fruit list:"
+    "It may seem that you have to memorize that numbers just kind of behave differently than lists. But that's not the case! The real difference between those two blocks of code is that `fruits.append('kiwi')` is calling the `.append()` method on the list directly, which modifies the list. The code `x = x + 10` only modifies _which value x is refering to_ (52 instead of 42), it does not modify the number `42`. The actual objects and data \"in memory\" are different than the variables that refer to them."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6700428",
+   "metadata": {},
+   "source": [
+    "## Iterating over dictionaries\n",
+    "\n",
+    "We can iterate over dictionaries by calling the dictionary's `.items()` method. It returns an iterable of tuples, with each tuple containing a key and its value:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "9b1584de",
+   "id": "a9e25ce5",
    "metadata": {},
    "outputs": [],
    "source": [
-    "fruits = ['apples', 'limes']\n",
+    "prices = {\n",
+    "    'apple': 0.99,\n",
+    "    'orange': 1.29,\n",
+    "    'watermelon': {'one': 1.79, 'two': 2.99},\n",
+    "}\n",
     "\n",
-    "def find_grocery_deals(groceries, price_point, ???)"
+    "for key, value in prices.items():\n",
+    "    print(f'Key is {key}, value is {value}')"
    ]
   },
   {
@@ -1089,7 +1189,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "PythonClass-OhLRe-cl",
    "language": "python",
    "name": "python3"
   },
@@ -1103,7 +1203,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.0"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,