diff --git a/s24/Louis_Lecture_Notes/20_Objects_and_Tuples/Lec_20_Objects_and_Tuples_Solution_Oliphant.ipynb b/s24/Louis_Lecture_Notes/20_Objects_and_Tuples/Lec_20_Objects_and_Tuples_Solution_Oliphant.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9749749a99b43a1a10137622fc633be60f7f2237
--- /dev/null
+++ b/s24/Louis_Lecture_Notes/20_Objects_and_Tuples/Lec_20_Objects_and_Tuples_Solution_Oliphant.ipynb
@@ -0,0 +1,857 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Warmups"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['name', 'description', 'loanAmount', 'geocode'])"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Warmup 0: Recall how to read in and use json data\n",
+    "\n",
+    "import json\n",
+    "# we are going to learn about this today !\n",
+    "from collections import namedtuple\n",
+    "\n",
+    "# Deserialize\n",
+    "def read_json(path):\n",
+    "    with open(path, encoding=\"utf-8\") as f: # f is a variable \n",
+    "        return json.load(f)                 # f represents a reference the JSON file\n",
+    "    \n",
+    "# Serialize\n",
+    "def write_json(path, data):\n",
+    "    with open(path, 'w', encoding=\"utf-8\") as f:\n",
+    "        json.dump(data, f, indent=2)\n",
+    "\n",
+    "kiva_dict = read_json('kiva.json')\n",
+    "loan_list = kiva_dict['data']['lend']['loans']['values'] # this gives us a list of dicts\n",
+    "loan_list[0].keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4350.0"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Warmup 1a: What is the total amount needed to fund all of the loans?\n",
+    "tot_loan_amount = 0.0\n",
+    "for loan_dict in loan_list:\n",
+    "    tot_loan_amount += float(loan_dict['loanAmount'])\n",
+    "tot_loan_amount"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['Albania', 'Kenya', 'Tajikistan', 'Togo']"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Warmup 1b: What are the unique countries of origin in alphabetical order?\n",
+    "\n",
+    "countries = []\n",
+    "for loan_dict in loan_list:\n",
+    "    countries.append(loan_dict['geocode']['country']['name'])\n",
+    "uniq_countries = sorted(list(set(countries)))\n",
+    "uniq_countries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup 2: Explain what the code below does\n",
+    "x = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# In Plain English: It assigns the value of 1 to x."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# CS220: Lecture 20\n",
+    "\n",
+    "\n",
+    "## Learning Objectives\n",
+    "After this lecture you will be able to...\n",
+    "- Explain the difference between objects vs references, and stack vs heap.\n",
+    "- Determine the side effects that occur when modifying parameters.\n",
+    "- Use tuples to store immutable sequences of values.\n",
+    "- Use namedtuple (immutable) to store user-defined data objects.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Objects vs References & Stack vs Heap\n",
+    "\n",
+    "- Check out the slides!\n",
+    "- Try some of the code in PythonTutor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup 2: Explain what the code below does\n",
+    "x = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# In Plain English: It assigns the value of 1 to x."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# More Precisely: It creates a reference variable, x, which refers to the object 1.\n",
+    "\n",
+    "# Why? In Python, every variable is just a reference to an object.\n",
+    "#      The variable only holds the memory address of the object it is referring to.\n",
+    "#      The object is the actual data (e.g. an int, string, list, etc.)\n",
+    "#\n",
+    "#      Think about it like a class roster.\n",
+    "#      Each name on the roster refers to a student in the class.\n",
+    "#      In this example, each name represents a variable, and each student represents an object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# MOST Precisely: It creates a reference variable, x, stored on the stack\n",
+    "#                 which refers to the object 1, stored on the heap.\n",
+    "\n",
+    "# Why? The heap is the collection of ALL objects. Think about it like a supermarket.\n",
+    "#      The stack is the \"stack\" of frames we studied earlier in the semester.\n",
+    "#      It is the ordered collection of function frames and their variables.\n",
+    "#\n",
+    "#      Tip: Use PythonTutor to visualize this!\n",
+    "#\n",
+    "# Typically, the stack is much smaller in size than the heap.\n",
+    "# "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup 2b: Explain what the code below does\n",
+    "shelf = [\"sugar\", \"coffee\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# In Plain English: It assigns a list of coffee and sugar to shelf."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# More Precisely: It creates a reference variable, shelf, stored on the stack which\n",
+    "#                 refers to a list of sugar and coffee on the heap."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# MOST Precisely: It creates a reference variable, shelf, stored on the stack which\n",
+    "#                 refers to a list object on the heap. This list object contains a\n",
+    "#                 reference to a string object \"sugar\" on the heap, followed by a\n",
+    "#                 reference to a string object \"coffee\" on the heap."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Determine the side effects that occur when modifying parameters.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example 1a [PythonTutor Link](https://pythontutor.com/visualize.html#code=def%20f%28x%29%3A%0A%20%20%20%20x%20*%3D%203%0A%20%20%20%20print%28%22f%3A%22,%20x%29%0A%0Anum%20%3D%2010%0Aprint%28%22before%3A%22,%20num%29%0Af%28num%29%0Aprint%28%22after%3A%22,%20num%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "before: 10\n",
+      "f: 30\n",
+      "after: 10\n"
+     ]
+    }
+   ],
+   "source": [
+    "def f(x):\n",
+    "    x *= 3\n",
+    "    print(\"f:\", x)\n",
+    "\n",
+    "num = 10\n",
+    "print(\"before:\", num)\n",
+    "f(num)\n",
+    "print(\"after:\", num)\n",
+    "\n",
+    "# Takeaway: What happens when a parameter is reassigned in a function?\n",
+    "#           The original value does not change!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example 1b, [PythonTutor Link](https://pythontutor.com/visualize.html#code=def%20f%28items%29%3A%0A%20%20%20%20items.append%28%22donuts%22%29%0A%20%20%20%20print%28%22f%3A%22,%20items%29%0A%0Awords%20%3D%20%5B'sugar',%20'coffee'%5D%0Aprint%28%22before%3A%22,%20words%29%0Af%28words%29%0Aprint%28%22after%3A%22,%20words%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "before: ['sugar', 'coffee']\n",
+      "f: ['sugar', 'coffee', 'donuts']\n",
+      "after: ['sugar', 'coffee', 'donuts']\n"
+     ]
+    }
+   ],
+   "source": [
+    "def f(items):\n",
+    "    items.append(\"donuts\")\n",
+    "    print(\"f:\", items)\n",
+    "\n",
+    "words = ['sugar', 'coffee']\n",
+    "print(\"before:\", words)\n",
+    "f(words)\n",
+    "print(\"after:\", words)\n",
+    "\n",
+    "# Takeaway: What happens when a list parameter is mutated in a function?\n",
+    "#           The list is changed! This is true for any mutable object."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example 1c [PythonTutor Link](https://pythontutor.com/visualize.html#code=def%20f%28items%29%3A%0A%20%20%20%20items%20%3D%20items%20%2B%20%5B%22donuts%22%5D%0A%20%20%20%20print%28%22f%3A%22,%20items%29%0A%0Awords%20%3D%20%5B'sugar',%20'coffee'%5D%0Aprint%28%22before%3A%22,%20words%29%0Af%28words%29%0Aprint%28%22after%3A%22,%20words%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "before: ['sugar', 'coffee']\n",
+      "f: ['sugar', 'coffee', 'donuts']\n",
+      "after: ['sugar', 'coffee']\n"
+     ]
+    }
+   ],
+   "source": [
+    "def f(items):\n",
+    "    items = items + [\"donuts\"]\n",
+    "    print(\"f:\", items)\n",
+    "\n",
+    "words = ['sugar', 'coffee']\n",
+    "print(\"before:\", words)\n",
+    "f(words)\n",
+    "print(\"after:\", words)\n",
+    "\n",
+    "# Takeaway: What happens when a list parameter is reassigned?\n",
+    "#           The original list is not changed."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example 1d [PythonTutor Link](https://pythontutor.com/visualize.html#code=def%20first%28items%29%3A%0A%20%20%20%20return%20items%5B0%5D%0A%0Adef%20smallest%28items%29%3A%0A%20%20%20%20items.sort%28%29%0A%20%20%20%20return%20items%5B0%5D%0A%0Anumbers%20%3D%20%5B4,5,3,2,1%5D%0Aprint%28%22first%3A%22,%20first%28numbers%29%29%0Aprint%28%22smallest%3A%22,%20smallest%28numbers%29%29%0Aprint%28%22first%3A%22,%20first%28numbers%29%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "first: 4\n",
+      "smallest: 1\n",
+      "first: 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "def first(items):\n",
+    "    return items[0]\n",
+    "\n",
+    "def smallest(items):\n",
+    "    items.sort()\n",
+    "    return items[0]\n",
+    "\n",
+    "numbers\t= [4,5,3,2,1]\n",
+    "print(\"first:\", first(numbers))\n",
+    "print(\"smallest:\", smallest(numbers))\n",
+    "print(\"first:\", first(numbers))\n",
+    "\n",
+    "# Takeaway: What happens when a list parameter is sorted \"in place\" using .sort() ?\n",
+    "#           The original list is changed!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example 1e [PythonTutor Link](https://pythontutor.com/visualize.html#code=def%20first%28items%29%3A%0A%20%20%20%20return%20items%5B0%5D%0A%0Adef%20smallest%28items%29%3A%0A%20%20%20%20items%20%3D%20sorted%28items%29%0A%20%20%20%20return%20items%5B0%5D%0A%0Anumbers%20%3D%20%5B4,5,3,2,1%5D%0Aprint%28%22first%3A%22,%20first%28numbers%29%29%0Aprint%28%22smallest%3A%22,%20smallest%28numbers%29%29%0Aprint%28%22first%3A%22,%20first%28numbers%29%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "first: 4\n",
+      "smallest: 1\n",
+      "first: 4\n"
+     ]
+    }
+   ],
+   "source": [
+    "def first(items):\n",
+    "    return items[0]\n",
+    "\n",
+    "def smallest(items):\n",
+    "    items = sorted(items)\n",
+    "    return items[0]\n",
+    "\n",
+    "numbers = [4,5,3,2,1]\n",
+    "print(\"first:\", first(numbers))\n",
+    "print(\"smallest:\", smallest(numbers))\n",
+    "print(\"first:\", first(numbers))\n",
+    "\n",
+    "# Takeaway: What happens when a list parameter is sorted using sorted()? \n",
+    "#           The original list does not change."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# What can we say about the last two examples?\n",
+    "# sort() mutates the list; sorted does not mutate the list, it returns a new list."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write one good thing about lists being mutable:\n",
+    "# We can change (mutate) them in functions!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write one bad thing about lists being mutable:\n",
+    "# We can change (mutate) them in functions!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Your Turn!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Explain how the below code works."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Malibu': ['Swimming'], 'San Diego': ['Touring', 'Shopping']}\n",
+      "{'Madison': ['Studying'], 'HWY 151': ['Driving'], 'Devils Lake': ['Swimming', 'Kayaking', 'Hiking']}\n",
+      "['Touring', 'Shopping']\n",
+      "[]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def add_vacation_plan(itinerary, location, plan):\n",
+    "    # Itinerary is a dictionary of locations, where each location has a list of plans.\n",
+    "    # We know that dictionaries and lists are mutable, so we can change them within this function.\n",
+    "    # \n",
+    "    # We first check if they have plans for the location, and if not start an empty list.\n",
+    "    # Then, we add our plan onto the list of plans for that location.\n",
+    "    if location not in itinerary:\n",
+    "        itinerary[location] = []\n",
+    "    itinerary[location].append(plan)\n",
+    "    \n",
+    "def get_vacation_plans(itinerary, location):\n",
+    "    if location not in itinerary:\n",
+    "        return []\n",
+    "    return itinerary[location]\n",
+    "    \n",
+    "alices_vacay = {}\n",
+    "bobs_vacay = {}\n",
+    "\n",
+    "add_vacation_plan(alices_vacay, \"Malibu\", \"Swimming\")\n",
+    "add_vacation_plan(alices_vacay, \"San Diego\", \"Touring\")\n",
+    "add_vacation_plan(alices_vacay, \"San Diego\", \"Shopping\")\n",
+    "\n",
+    "add_vacation_plan(bobs_vacay, \"Madison\", \"Studying\")\n",
+    "add_vacation_plan(bobs_vacay, \"HWY 151\", \"Driving\")\n",
+    "add_vacation_plan(bobs_vacay, \"Devils Lake\", \"Swimming\")\n",
+    "add_vacation_plan(bobs_vacay, \"Devils Lake\", \"Kayaking\")\n",
+    "add_vacation_plan(bobs_vacay, \"Devils Lake\", \"Hiking\")\n",
+    "\n",
+    "print(alices_vacay)\n",
+    "print(bobs_vacay)\n",
+    "print(get_vacation_plans(alices_vacay, 'San Diego'))\n",
+    "print(get_vacation_plans(bobs_vacay, 'Seattle'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Use tuples to store immutable sequences of values.\n",
+    "Check out the slides about tuples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Tuples are like lists BUT are IMMUTABLE\n",
+    "\n",
+    "# practice with tuples\n",
+    "scores = [32, 55, 72, 91]   # a list is mutable\n",
+    "coordinates = (-3, 4, 7)    # a tuple is not mutable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[32, 55, 72, 100]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# show that scores is mutable\n",
+    "scores[-1] = 100\n",
+    "print(scores)\n",
+    "\n",
+    "# show that tuples are immutable\n",
+    "#coordinates[-1] = 100.   #tuple not mutable\n",
+    "#print(coordinates)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(5, 77, -3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "coordinates = (5, 77, -3)   # However, re-assignment is OK\n",
+    "print(coordinates)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(32, 55, 72, 100)\n"
+     ]
+    }
+   ],
+   "source": [
+    "scores_tuple = tuple(scores) # you can convert a list into a tuple\n",
+    "print(scores_tuple)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question:  Can tuples be sorted?\n",
+    "# Discuss with your neighbor\n",
+    "\n",
+    "# coordinates.sort() # tuples are immutable\n",
+    "new_tuple = sorted(coordinates) # sorted makes a new object"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# reference:  https://www.w3schools.com/python/python_tuples.asp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "unhashable type: 'list'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[29], line 6\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# Why use tuples? \u001b[39;00m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;66;03m#     keys in dictionaries must be immutable types\u001b[39;00m\n\u001b[0;32m      3\u001b[0m \u001b[38;5;66;03m#     some data never changes : GPS coordinates\u001b[39;00m\n\u001b[0;32m      4\u001b[0m \n\u001b[0;32m      5\u001b[0m \u001b[38;5;66;03m# Fails with TypeError\u001b[39;00m\n\u001b[1;32m----> 6\u001b[0m buildings \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m      7\u001b[0m     [\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m0\u001b[39m]: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mComp Sci\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m      8\u001b[0m     [\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m2\u001b[39m]: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPsychology\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m      9\u001b[0m     [\u001b[38;5;241m4\u001b[39m,\u001b[38;5;241m0\u001b[39m]: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNoland\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m     10\u001b[0m     [\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m8\u001b[39m]: \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mVan Vleck\u001b[39m\u001b[38;5;124m\"\u001b[39m }\n",
+      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# Why use tuples? \n",
+    "#     keys in dictionaries must be immutable types\n",
+    "#     some data never changes : GPS coordinates\n",
+    "\n",
+    "# Fails with TypeError\n",
+    "buildings = {\n",
+    "    [0,0]: \"Comp Sci\",\n",
+    "    [0,2]: \"Psychology\",\n",
+    "    [4,0]: \"Noland\",\n",
+    "    [1,8]: \"Van Vleck\" }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Noland'"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Works with tuple as keys\n",
+    "buildings = {\n",
+    "    (0,0): \"Comp Sci\",\n",
+    "    (0,2): \"Psychology\",\n",
+    "    (4,0): \"Noland\",\n",
+    "    (1,8): \"Van Vleck\" }\n",
+    "\n",
+    "# find the name of the building at coordinate (4,0)\n",
+    "buildings[(4,0)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 21.3 Use namedtuple (immutable) to store user-defined data objects.\n",
+    "- namedtuple is useful for creating well-defined objects\n",
+    "- namedtuple is like a mix of tuples and dictionaries\n",
+    "- let's look at the slides\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "124\n"
+     ]
+    }
+   ],
+   "source": [
+    "people = []\n",
+    "\n",
+    "# A namedtuple is like its own kind of type!\n",
+    "# its a Python convention to use a Capital letter when naming a namedtuple\n",
+    "# define a namedtuple called Person\n",
+    "Person = namedtuple(\"Person\", [\"fname\", \"lname\", \"age\"])\n",
+    "\n",
+    "# make a single person....please don't name it person !!\n",
+    "p1 = Person(\"Bucky\", \"Badger\", 124)\n",
+    "print(p1.age)\n",
+    "\n",
+    "# Add another Person by using keyword arguments \n",
+    "person2 = Person(age=25, lname=\"Star\", fname = \"Patrick\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello Alice Anderson\n"
+     ]
+    }
+   ],
+   "source": [
+    "# make a list of Persons\n",
+    "people=[\n",
+    "    Person(\"Alice\", \"Anderson\", 30),  # positional arguments\n",
+    "    Person(\"Bob\", \"Baker\", 31),\n",
+    "    # add two more Persons to people\n",
+    "    Person(\"Celia\", \"Answer\", 21),\n",
+    "    Person(\"Marcus\", \"Carlson\", 33)\n",
+    "    \n",
+    "]\n",
+    "\n",
+    "# Print the first person's name.\n",
+    "person0 = people[0]\n",
+    "print(\"Hello \" + person0.fname + \" \" + person0.lname)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Person(fname='Alice', lname='Anderson', age=30), Person(fname='Bob', lname='Baker', age=31), Person(fname='Celia', lname='Answer', age=21), Person(fname='Marcus', lname='Carlson', age=33)]\n",
+      "Hello Alice Anderson\n",
+      "Hello Bob Baker\n",
+      "Hello Celia Answer\n",
+      "Hello Marcus Carlson\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Print out everyone's name!\n",
+    "print(people)\n",
+    "\n",
+    "for p in people:\n",
+    "    print(\"Hello \" + p.fname + \" \" + p.lname)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Namedtuples have a deeper significance....the namedtuples we create are their own type"
+   ]
+  },
+  {
+   "attachments": {
+    "namedtuple.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![namedtuple.png](attachment:namedtuple.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "28.75"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Write a function to find the average age of the Persons in people\n",
+    "def avg_age(p_list):\n",
+    "    # assume p_list is a list of Persons\n",
+    "    sum_ages = 0\n",
+    "    for person in p_list:\n",
+    "        sum_ages += person.age\n",
+    "    return sum_ages / len(p_list)\n",
+    "\n",
+    "avg_age(people)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/s24/Louis_Lecture_Notes/20_Objects_and_Tuples/Lec_20_Objects_and_Tuples_Template_Oliphant.ipynb b/s24/Louis_Lecture_Notes/20_Objects_and_Tuples/Lec_20_Objects_and_Tuples_Template_Oliphant.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1de34c5dbc8c9082ef2a07a635f86493a4c48d46
--- /dev/null
+++ b/s24/Louis_Lecture_Notes/20_Objects_and_Tuples/Lec_20_Objects_and_Tuples_Template_Oliphant.ipynb
@@ -0,0 +1,696 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Warmups"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['name', 'description', 'loanAmount', 'geocode'])"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Warmup 0: Recall how to read in and use json data\n",
+    "\n",
+    "import json\n",
+    "# we are going to learn about this today !\n",
+    "from collections import namedtuple\n",
+    "\n",
+    "# Deserialize\n",
+    "def read_json(path):\n",
+    "    with open(path, encoding=\"utf-8\") as f: # f is a variable \n",
+    "        return json.load(f)                 # f represents a reference the JSON file\n",
+    "    \n",
+    "# Serialize\n",
+    "def write_json(path, data):\n",
+    "    with open(path, 'w', encoding=\"utf-8\") as f:\n",
+    "        json.dump(data, f, indent=2)\n",
+    "\n",
+    "kiva_dict = read_json('kiva.json')\n",
+    "loan_list = kiva_dict['data']['lend']['loans']['values'] # this gives us a list of dicts\n",
+    "loan_list[0].keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup 1a: What is the total amount needed to fund all of the loans\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup 1b: What are the unique countries of origin in alphabetical order?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup 2: Explain what the code below does\n",
+    "x = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# CS220: Lecture 20\n",
+    "\n",
+    "\n",
+    "## Learning Objectives\n",
+    "After this lecture you will be able to...\n",
+    "- Explain the difference between objects vs references, and stack vs heap.\n",
+    "- Determine the side effects that occur when modifying parameters.\n",
+    "- Use tuples to store immutable sequences of values.\n",
+    "- Use namedtuple (immutable) to store user-defined data objects.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Objects vs References & Stack vs Heap\n",
+    "\n",
+    "- Check out the slides!\n",
+    "- Try some of the code in PythonTutor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup 2: Explain what the code below does\n",
+    "x = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup 2b: Explain what the code below does\n",
+    "shelf = [\"sugar\", \"coffee\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Determine the side effects that occur when modifying parameters.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example 1a [PythonTutor Link](https://pythontutor.com/visualize.html#code=def%20f%28x%29%3A%0A%20%20%20%20x%20*%3D%203%0A%20%20%20%20print%28%22f%3A%22,%20x%29%0A%0Anum%20%3D%2010%0Aprint%28%22before%3A%22,%20num%29%0Af%28num%29%0Aprint%28%22after%3A%22,%20num%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "before: 10\n",
+      "f: 30\n",
+      "after: 10\n"
+     ]
+    }
+   ],
+   "source": [
+    "def f(x):\n",
+    "    x *= 3\n",
+    "    print(\"f:\", x)\n",
+    "\n",
+    "num = 10\n",
+    "print(\"before:\", num)\n",
+    "f(num)\n",
+    "print(\"after:\", num)\n",
+    "\n",
+    "# Takeaway: What happens when a parameter is reassigned in a function?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example 1b, [PythonTutor Link](https://pythontutor.com/visualize.html#code=def%20f%28items%29%3A%0A%20%20%20%20items.append%28%22donuts%22%29%0A%20%20%20%20print%28%22f%3A%22,%20items%29%0A%0Awords%20%3D%20%5B'sugar',%20'coffee'%5D%0Aprint%28%22before%3A%22,%20words%29%0Af%28words%29%0Aprint%28%22after%3A%22,%20words%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "before: ['sugar', 'coffee']\n",
+      "f: ['sugar', 'coffee', 'donuts']\n",
+      "after: ['sugar', 'coffee', 'donuts']\n"
+     ]
+    }
+   ],
+   "source": [
+    "def f(items):\n",
+    "    items.append(\"donuts\")\n",
+    "    print(\"f:\", items)\n",
+    "\n",
+    "words = ['sugar', 'coffee']\n",
+    "print(\"before:\", words)\n",
+    "f(words)\n",
+    "print(\"after:\", words)\n",
+    "\n",
+    "# Takeaway: What happens when a list parameter is mutated in a function?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example 1c [PythonTutor Link](https://pythontutor.com/visualize.html#code=def%20f%28items%29%3A%0A%20%20%20%20items%20%3D%20items%20%2B%20%5B%22donuts%22%5D%0A%20%20%20%20print%28%22f%3A%22,%20items%29%0A%0Awords%20%3D%20%5B'sugar',%20'coffee'%5D%0Aprint%28%22before%3A%22,%20words%29%0Af%28words%29%0Aprint%28%22after%3A%22,%20words%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "before: ['sugar', 'coffee']\n",
+      "f: ['sugar', 'coffee', 'donuts']\n",
+      "after: ['sugar', 'coffee']\n"
+     ]
+    }
+   ],
+   "source": [
+    "def f(items):\n",
+    "    items = items + [\"donuts\"]\n",
+    "    print(\"f:\", items)\n",
+    "\n",
+    "words = ['sugar', 'coffee']\n",
+    "print(\"before:\", words)\n",
+    "f(words)\n",
+    "print(\"after:\", words)\n",
+    "\n",
+    "# Takeaway: What happens when a list parameter is reassigned?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example 1d [PythonTutor Link](https://pythontutor.com/visualize.html#code=def%20first%28items%29%3A%0A%20%20%20%20return%20items%5B0%5D%0A%0Adef%20smallest%28items%29%3A%0A%20%20%20%20items.sort%28%29%0A%20%20%20%20return%20items%5B0%5D%0A%0Anumbers%20%3D%20%5B4,5,3,2,1%5D%0Aprint%28%22first%3A%22,%20first%28numbers%29%29%0Aprint%28%22smallest%3A%22,%20smallest%28numbers%29%29%0Aprint%28%22first%3A%22,%20first%28numbers%29%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "first: 4\n",
+      "smallest: 1\n",
+      "first: 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "def first(items):\n",
+    "    return items[0]\n",
+    "\n",
+    "def smallest(items):\n",
+    "    items.sort()\n",
+    "    return items[0]\n",
+    "\n",
+    "numbers\t= [4,5,3,2,1]\n",
+    "print(\"first:\", first(numbers))\n",
+    "print(\"smallest:\", smallest(numbers))\n",
+    "print(\"first:\", first(numbers))\n",
+    "\n",
+    "# Takeaway: What happens when a list parameter is sorted \"in place\" using .sort() ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example 1e [PythonTutor Link](https://pythontutor.com/visualize.html#code=def%20first%28items%29%3A%0A%20%20%20%20return%20items%5B0%5D%0A%0Adef%20smallest%28items%29%3A%0A%20%20%20%20items%20%3D%20sorted%28items%29%0A%20%20%20%20return%20items%5B0%5D%0A%0Anumbers%20%3D%20%5B4,5,3,2,1%5D%0Aprint%28%22first%3A%22,%20first%28numbers%29%29%0Aprint%28%22smallest%3A%22,%20smallest%28numbers%29%29%0Aprint%28%22first%3A%22,%20first%28numbers%29%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "first: 4\n",
+      "smallest: 1\n",
+      "first: 4\n"
+     ]
+    }
+   ],
+   "source": [
+    "def first(items):\n",
+    "    return items[0]\n",
+    "\n",
+    "def smallest(items):\n",
+    "    items = sorted(items)\n",
+    "    return items[0]\n",
+    "\n",
+    "numbers = [4,5,3,2,1]\n",
+    "print(\"first:\", first(numbers))\n",
+    "print(\"smallest:\", smallest(numbers))\n",
+    "print(\"first:\", first(numbers))\n",
+    "\n",
+    "# Takeaway: What happens when a list parameter is sorted using sorted()? "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# What can we say about the last two examples?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write one good thing about lists being mutable:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Write one bad thing about lists being mutable:\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Your Turn!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Explain how the below code works."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Malibu': ['Swimming'], 'San Diego': ['Touring', 'Shopping']}\n",
+      "{'Madison': ['Studying'], 'HWY 151': ['Driving'], 'Devils Lake': ['Swimming', 'Kayaking', 'Hiking']}\n",
+      "['Touring', 'Shopping']\n",
+      "[]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def add_vacation_plan(itinerary, location, plan):\n",
+    "    if location not in itinerary:\n",
+    "        itinerary[location] = []\n",
+    "    itinerary[location].append(plan)\n",
+    "    \n",
+    "def get_vacation_plans(itinerary, location):\n",
+    "    if location not in itinerary:\n",
+    "        return []\n",
+    "    return itinerary[location]\n",
+    "    \n",
+    "alices_vacay = {}\n",
+    "bobs_vacay = {}\n",
+    "\n",
+    "add_vacation_plan(alices_vacay, \"Malibu\", \"Swimming\")\n",
+    "add_vacation_plan(alices_vacay, \"San Diego\", \"Touring\")\n",
+    "add_vacation_plan(alices_vacay, \"San Diego\", \"Shopping\")\n",
+    "\n",
+    "add_vacation_plan(bobs_vacay, \"Madison\", \"Studying\")\n",
+    "add_vacation_plan(bobs_vacay, \"HWY 151\", \"Driving\")\n",
+    "add_vacation_plan(bobs_vacay, \"Devils Lake\", \"Swimming\")\n",
+    "add_vacation_plan(bobs_vacay, \"Devils Lake\", \"Kayaking\")\n",
+    "add_vacation_plan(bobs_vacay, \"Devils Lake\", \"Hiking\")\n",
+    "\n",
+    "print(alices_vacay)\n",
+    "print(bobs_vacay)\n",
+    "print(get_vacation_plans(alices_vacay, 'San Diego'))\n",
+    "print(get_vacation_plans(bobs_vacay, 'Seattle'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Use tuples to store immutable sequences of values.\n",
+    "Check out the slides about tuples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Tuples are like lists BUT are IMMUTABLE\n",
+    "\n",
+    "# practice with tuples\n",
+    "scores = [32, 55, 72, 91]   # a list is mutable\n",
+    "coordinates = (-3, 4, 7)    # a tuple is not mutable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[32, 55, 72, 100]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# show that scores is mutable\n",
+    "scores[-1] = 100\n",
+    "print(scores)\n",
+    "\n",
+    "# show that tuples are immutable\n",
+    "#coordinates[-1] = 100.   #tuple not mutable\n",
+    "#print(coordinates)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(5, 77, -3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "coordinates = (5, 77, -3)   # However, re-assignment is OK\n",
+    "print(coordinates)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(32, 55, 72, 100)\n"
+     ]
+    }
+   ],
+   "source": [
+    "scores_tuple = tuple(scores) # you can convert a list into a tuple\n",
+    "print(scores_tuple)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Question:  Can tuples be sorted?\n",
+    "# Discuss with your neighbor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# reference:  https://www.w3schools.com/python/python_tuples.asp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "unhashable type: 'list'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32mC:\\Users\\COLENE~1\\AppData\\Local\\Temp/ipykernel_18196/3672081683.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;31m# Fails with TypeError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m buildings = {\n\u001b[0m\u001b[0;32m      7\u001b[0m     \u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m\"Comp Sci\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m     \u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m\"Psychology\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# Why use tuples? \n",
+    "#     keys in dictionaries must be immutable types\n",
+    "#     some data never changes : GPS coordinates\n",
+    "\n",
+    "# Fails with TypeError\n",
+    "buildings = {\n",
+    "    [0,0]: \"Comp Sci\",\n",
+    "    [0,2]: \"Psychology\",\n",
+    "    [4,0]: \"Noland\",\n",
+    "    [1,8]: \"Van Vleck\" }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Noland'"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Works with tuple as keys\n",
+    "buildings = {\n",
+    "    (0,0): \"Comp Sci\",\n",
+    "    (0,2): \"Psychology\",\n",
+    "    (4,0): \"Noland\",\n",
+    "    (1,8): \"Van Vleck\" }\n",
+    "\n",
+    "# find the name of the building at coordinate (4,0)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 21.3 Use namedtuple (immutable) to store user-defined data objects.\n",
+    "- namedtuple is useful for creating well-defined objects\n",
+    "- namedtuple is like a mix of tuples and dictionaries\n",
+    "- let's look at the slides\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "people = []\n",
+    "\n",
+    "# A namedtuple is like its own kind of type!\n",
+    "# its a Python convention to use a Capital letter when naming a namedtuple\n",
+    "# define a namedtuple called Person\n",
+    "Person = namedtuple(\"Person\", [\"fname\", \"lname\", \"age\"])\n",
+    "\n",
+    "# make a single person....please don't name it person !!\n",
+    "\n",
+    "# Add another Person by using keyword arguments \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello Alice Anderson\n"
+     ]
+    }
+   ],
+   "source": [
+    "# make a list of Persons\n",
+    "people=[\n",
+    "    Person(\"Alice\", \"Anderson\", 30),  # positional arguments\n",
+    "    Person(\"Bob\", \"Baker\", 31),\n",
+    "    # add two more Persons to people\n",
+    "    Person(\"Celia\", \"Answer\", 21),\n",
+    "    Person(\"Marcus\", \"Carlson\", 33)\n",
+    "    \n",
+    "]\n",
+    "\n",
+    "# Print the first person's name.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Person(fname='Alice', lname='Anderson', age=30), Person(fname='Bob', lname='Baker', age=31), Person(fname='Celia', lname='Answer', age=21), Person(fname='Marcus', lname='Carlson', age=33)]\n",
+      "Hello Alice Anderson\n",
+      "Hello Bob Baker\n",
+      "Hello Celia Answer\n",
+      "Hello Marcus Carlson\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Print out everyone's name!\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Namedtuples have a deeper significance....the namedtuples we create are their own type"
+   ]
+  },
+  {
+   "attachments": {
+    "namedtuple.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![namedtuple.png](attachment:namedtuple.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "28.75"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Write a function to find the average age of the Persons in people\n",
+    "def avg_age(p_list):\n",
+    "    # assume p_list is a list of Persons\n",
+    "    pass\n",
+    "\n",
+    "avg_age(people)"
+   ]
+  }
+ ],
+ "metadata": {
+  "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/s24/Louis_Lecture_Notes/20_Objects_and_Tuples/kiva.json b/s24/Louis_Lecture_Notes/20_Objects_and_Tuples/kiva.json
new file mode 100644
index 0000000000000000000000000000000000000000..8495da076f3311930a009e7e30b023e663696b3c
--- /dev/null
+++ b/s24/Louis_Lecture_Notes/20_Objects_and_Tuples/kiva.json
@@ -0,0 +1,75 @@
+{
+  "data": {
+    "lend": {
+      "loans": {
+        "values": [
+          {
+            "name": "Polikseni",
+            "description": "Polikseni is 70 years old and married. She and her husband are both retired and their main income is a retirement pension of $106 a month for Polikseni and disability income for her husband of $289 a month. <br /><br />Polikseni's husband, even though disabled, works in a very small shop as a watchmaker on short hours, just to provide additional income for his family and to feel useful. Polikseni's husband needs constant medical treatment due to his health problems. She requested another loan, which she will use to continue paying for the therapy her husband needs. With a part of the loan, she is going to pay the remainder of the previous loan.",
+            "loanAmount": "1325.00",
+            "geocode": {
+              "city": "Korce",
+              "country": {
+                "name": "Albania",
+                "region": "Eastern Europe",
+                "fundsLentInCountry": 9051250
+              }
+            }
+          },
+          {
+            "name": "Safarmo",
+            "description": "Safarmo is 47 years old. She lives with her husband and her children in Khuroson district. <br /><br />Safarmo is a seamstress. She has been engaged in sewing for 10 years. She learned this activity with help of her mother and elder sister. <br /><br />Safarmo's sewing machine is old and she cannot work well. Her difficulty is lack of money. That’s why she applied for a loan to buy a new modern sewing machine. <br /><br />Safarmo needs your support.",
+            "loanAmount": "1075.00",
+            "geocode": {
+              "city": "Khuroson",
+              "country": {
+                "name": "Tajikistan",
+                "region": "Asia",
+                "fundsLentInCountry": 64243075
+              }
+            }
+          },
+          {
+            "name": "Elizabeth",
+            "description": "Elizabeth is a mom blessed with five lovely children, who are her greatest motivation in life.  She lives in the Natuu area of Kenya.  Elizabeth is one of the most hardworking women in sub-Saharan Africa.  Being a mother and living in a poor country has never been an excuse for Elizabeth, who has practiced mixed farming for the past few years.<br /><br />The cultural expectations in her area contribute to the notion that men should support their families.  However, Elizabeth works independently for the success of her children.  She perseveres because she wants to provide a better future for them.<br /><br />Elizabeth  has always loved farming. She is a very proud farmer and enjoys milking her dairy cows.  Elizabeth keeps poultry and grows crops, but she has not been making a good profit because of poor farming inputs. <br /><br />Elizabeth will use this loan to buy farm inputs and purchase high-quality seeds and good fertilizer to improve her crop production.  Modern farming requires the use of modern techniques, and, therefore, using high-quality seeds will assure her of a bumper harvest and increased profit levels.<br /><br />Elizabeth  is very visionary.  Her goal for the season is to boost her crop production over the previous year.",
+            "loanAmount": "800.00",
+            "geocode": {
+              "city": "Matuu",
+              "country": {
+                "name": "Kenya",
+                "region": "Africa",
+                "fundsLentInCountry": 120841775
+              }
+            }
+          },
+          {
+            "name": "Ester",
+            "description": "Ester believes that this year is her year of prosperity. Ester is a hardworking, progressive and honest farmer from a very remote village in the Kitale area of Kenya. This area is very fertile, with favorable weather patterns that support farming activities. Ester is happily married and the proud mother of lovely children. Together, they live on a small piece of land that she really treasures. Her primary sources of income are eggs and milk.<br /><br />Although this humble and industrious mother makes a profit, she faces the challenge of not being able to produce enough to meet the readily available market. Therefore, she is seeking funds from Kiva lenders to buy farm inputs such as good fertilizer and good-quality seeds. Through this loan, Ester should double her production, and this will translate into increased income. She then intends to save more money in the future so that she can develop her farming.<br /><br />One objective that Juhudi Kilimo aims at fulfilling is increasing the ease of accessing farm inputs and income-generating assets for farmers. Through the intervention of Juhudi Kilimo and Kiva, inputs such as fertilizers and pesticides have become more accessible to its members than buying a bottle of water. Ester is very optimistic and believes this loan will change her life completely.",
+            "loanAmount": "275.00",
+            "geocode": {
+              "city": "Kitale",
+              "country": {
+                "name": "Kenya",
+                "region": "Africa",
+                "fundsLentInCountry": 120841775
+              }
+            }
+          },
+          {
+            "name": "Cherifa",
+            "description": "Cherifa is married, 57 years old with two children. She caters and also sells the local drink. She asks for credit to buy the necessities, in particular bags of anchovies, bags of maize and bundles of firewood. She wants to have enough income to run the house well.",
+            "loanAmount": "875.00",
+            "geocode": {
+              "city": "Agoe",
+              "country": {
+                "name": "Togo",
+                "region": "Africa",
+                "fundsLentInCountry": 13719125
+              }
+            }
+          }
+        ]
+      }
+    }
+  }
+}
\ No newline at end of file