From 3b2fe50854b08896dd6f156100aefc6cdbde3e9b Mon Sep 17 00:00:00 2001
From: Anna Meyer <annapmeyer95@gmail.com>
Date: Wed, 5 Jul 2023 13:47:21 -0500
Subject: [PATCH] after lec 7

---
 .../lec_06_Iteration_Practice_notes.ipynb     |   61 +-
 .../07_Strings/Exam_1_review.ipynb            |   92 +-
 .../07_Strings/Exam_1_review_notes.ipynb      |  507 ++++++++
 .../07_Strings/lec_07_Strings_notes.ipynb     | 1060 +++++++++++++++++
 4 files changed, 1652 insertions(+), 68 deletions(-)
 create mode 100644 sum23/lecture_materials/07_Strings/Exam_1_review_notes.ipynb
 create mode 100644 sum23/lecture_materials/07_Strings/lec_07_Strings_notes.ipynb

diff --git a/sum23/lecture_materials/06_Iteration1/lec_06_Iteration_Practice_notes.ipynb b/sum23/lecture_materials/06_Iteration1/lec_06_Iteration_Practice_notes.ipynb
index 0ae71e0..3d5c8c5 100644
--- a/sum23/lecture_materials/06_Iteration1/lec_06_Iteration_Practice_notes.ipynb
+++ b/sum23/lecture_materials/06_Iteration1/lec_06_Iteration_Practice_notes.ipynb
@@ -1,7 +1,6 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "6a76ef95",
    "metadata": {},
@@ -10,7 +9,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "103da70b",
    "metadata": {},
@@ -149,7 +147,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "7fb78f6b",
    "metadata": {},
@@ -179,7 +176,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "3c97d494",
    "metadata": {},
@@ -229,7 +225,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "37898141",
    "metadata": {},
@@ -259,7 +254,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "60730da8",
    "metadata": {},
@@ -289,7 +283,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "af3d9d8c",
    "metadata": {},
@@ -337,7 +330,6 @@
    "source": []
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "b9ff6434",
    "metadata": {},
@@ -357,7 +349,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 3,
    "id": "38bd778a",
    "metadata": {},
    "outputs": [
@@ -370,7 +362,9 @@
     }
    ],
    "source": [
-    "max_age = 0\n",
+    "# max_age = 0 # Anna did it like this in lecture, but this isn't good style\n",
+    "max_age = None\n",
+    "\n",
     "for idx in range(project.count()):\n",
     "    age = project.get_age(idx)\n",
     "    \n",
@@ -381,14 +375,13 @@
     "\n",
     "    lecture_num = project.get_lecture(idx)\n",
     "    if lecture_num == 'LEC001':\n",
-    "        if age > max_age:\n",
+    "        if max_age == None or age > max_age:\n",
     "            max_age = age\n",
     "\n",
     "print(max_age)"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "b40a32fb",
    "metadata": {},
@@ -406,7 +399,6 @@
    "source": []
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "296c2a49",
    "metadata": {},
@@ -449,7 +441,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "48f1c791",
    "metadata": {},
@@ -461,7 +452,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 9,
    "id": "a524873b",
    "metadata": {},
    "outputs": [
@@ -476,8 +467,12 @@
    "source": [
     "# NOTE: this works, but is bad style. Instead, we should initalize min_age and min_age_idx to `None`\n",
     "# (Anna will discuss this in class on Wednesday)\n",
-    "min_age = 99\n",
-    "min_age_idx = -1 \n",
+    "# min_age = 99\n",
+    "# min_age_idx = -1 \n",
+    "\n",
+    "# do this instead:\n",
+    "min_age = None\n",
+    "min_age_idx = None\n",
     "\n",
     "for idx in range(project.count()):\n",
     "    age = project.get_age(idx)\n",
@@ -490,7 +485,7 @@
     "    if lecture_number != \"LEC001\":\n",
     "        continue\n",
     "        \n",
-    "    if age < min_age:\n",
+    "    if min_age == None or age < min_age:\n",
     "        min_age = age\n",
     "        min_age_idx = idx\n",
     "\n",
@@ -507,7 +502,6 @@
    "source": []
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "5294702a",
    "metadata": {},
@@ -524,7 +518,6 @@
    "source": []
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "68793d99",
    "metadata": {},
@@ -533,7 +526,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "2eeed867",
    "metadata": {},
@@ -542,7 +534,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "1ea57e12",
    "metadata": {},
@@ -551,7 +542,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "cf0ac7c8",
    "metadata": {},
@@ -560,7 +550,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "ffd5e10f",
    "metadata": {},
@@ -570,7 +559,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "f255b95a",
    "metadata": {},
@@ -580,7 +568,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "db60812c",
    "metadata": {},
@@ -589,7 +576,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "70a8ac57",
    "metadata": {},
@@ -599,7 +585,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "581ea197",
    "metadata": {},
@@ -624,15 +609,17 @@
     }
    ],
    "source": [
-    "maximum_latitude = -1000\n",
-    "max_idx = -1 \n",
+    "# Note: initialize maximum_latitude and max_idx to None (not real numbers, like Anna did in class)\n",
+    "maximum_latitude = None\n",
+    "max_idx = None\n",
     "\n",
     "for idx in range(project.count()):\n",
     "    latitude = float(project.get_latitude(idx))\n",
     "    if abs(latitude) > 90:\n",
     "        continue\n",
     "    \n",
-    "    if latitude > maximum_latitude:\n",
+    "    # first check if maximum_latitude is None, then check if current latitude is larger than current max\n",
+    "    if maximum_latitude == None or latitude > maximum_latitude:\n",
     "        maximum_latitude = latitude\n",
     "        max_idx = idx\n",
     "        \n",
@@ -641,7 +628,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "5f943c98",
    "metadata": {},
@@ -666,16 +652,15 @@
     }
    ],
    "source": [
-    "# NOTE: this isn't the best way to initialize variables\n",
-    "minimum_longitude = 1000\n",
-    "min_idx = -1 \n",
+    "minimum_longitude = None\n",
+    "min_idx = None\n",
     "\n",
     "for idx in range(project.count()):\n",
     "    longitude = float(project.get_longitude(idx))\n",
     "    if abs(longitude) > 90:\n",
     "        continue\n",
     "    \n",
-    "    if longitude < minimum_longitude:\n",
+    "    if minimum_longitude == None or longitude < minimum_longitude:\n",
     "        minimum_longitude = longitude\n",
     "        min_idx = idx\n",
     "        \n",
@@ -684,7 +669,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "dceca301",
    "metadata": {},
@@ -711,7 +695,7 @@
     "        continue\n",
     "    \n",
     "    # introduce a check for minimum_longitude is None or (original condition)\n",
-    "    if minimum_longitude is None or longitude < minimum_longitude:\n",
+    "    if minimum_longitude == None or longitude < minimum_longitude:\n",
     "        minimum_longitude = longitude\n",
     "        min_idx = idx\n",
     "        \n",
@@ -720,7 +704,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "9b104a50",
    "metadata": {},
diff --git a/sum23/lecture_materials/07_Strings/Exam_1_review.ipynb b/sum23/lecture_materials/07_Strings/Exam_1_review.ipynb
index 29fa01a..5fc9b0d 100644
--- a/sum23/lecture_materials/07_Strings/Exam_1_review.ipynb
+++ b/sum23/lecture_materials/07_Strings/Exam_1_review.ipynb
@@ -18,7 +18,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "138a92cc",
    "metadata": {},
    "outputs": [],
@@ -36,7 +36,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# TODO: what are all the ways we can (or cannot) call person()?"
+    "# TODO: what are all the ways we can (or cannot) call person()?\n",
+    "person(\"Anna\", 10, \"purple\", \"fish\")\n",
+    "\n",
+    "person(\"Anna\", 10, \"purple\")\n",
+    "\n",
+    "# person(\"Anna\") # doesn't work, need to specify age\n",
+    "person(\"Anna\", age=20)\n",
+    "# person(age=20, \"Anna\") # doesn't work, need to specify positional arguments first\n",
+    "\n",
+    "person(age=20, name=\"Anna\")\n",
+    "person(animal=\"zebra\", age=20, name=\"Anna\")\n",
+    "\n",
+    "# person(20, name=\"Anna\") # doesn't work, positional parameters fill first from left to right\n",
+    "\n",
+    "person(20, 20) \n"
    ]
   },
   {
@@ -67,6 +81,10 @@
     "\n",
     "def my_func(alpha, beta):\n",
     "    # TODO: what variables are accessible at line 5? what values do they have?\n",
+    "    # we can access these local variables:\n",
+    "    # -- alpha (has value of parameter passed into function)\n",
+    "    # -- beta (has value of parameter passed into function)\n",
+    "    # -- pi (global variable, value = 3.14)\n",
     "    delta = alpha + beta\n",
     "    gamma = delta ** 2\n",
     "    \n",
@@ -76,7 +94,9 @@
     "\n",
     "answer2 = my_func(answer, alpha)\n",
     "\n",
-    "# TODO what variables are accessible here? What values do they have?"
+    "# TODO what variables are accessible here? What values do they have?\n",
+    "# CANNOT access delta, gamma, beta\n",
+    "# alpha = 4 (note that using the variable name alpha in my_func does not change the global variable)"
    ]
   },
   {
@@ -94,7 +114,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "two = 3.14\n",
+    "two = 2\n",
     "alpha = 4\n",
     "\n",
     "def my_func1(alpha, beta):\n",
@@ -104,7 +124,8 @@
     "    \n",
     "    return gamma\n",
     "\n",
-    "answer = my_func(alpha, two)\n",
+    "answer = my_func1(alpha, two)\n",
+    "print(answer)\n",
     "\n",
     "# TODO what variables are accessible here? What values do they have?"
    ]
@@ -127,8 +148,8 @@
     "    \n",
     "    return gamma\n",
     "\n",
-    "answer = my_func(alpha, two)\n",
-    "\n",
+    "answer = my_func2(alpha, two)\n",
+    "print(answer)\n",
     "# TODO what variables are accessible here? What values do they have?"
    ]
   },
@@ -150,7 +171,7 @@
     "    two = 7\n",
     "    return gamma\n",
     "\n",
-    "answer = my_func(alpha, two)\n",
+    "answer = my_func3(alpha, two)\n",
     "\n",
     "# TODO what variables are accessible here? What values do they have?"
    ]
@@ -167,6 +188,8 @@
     "\n",
     "def my_func3(alpha, beta):\n",
     "    # TODO: what variables are accessible at line 5? what values do they have?\n",
+    "    \n",
+    "    global delta # adding this in to show how we create a global variable in a function\n",
     "    delta = alpha + beta\n",
     "    \n",
     "    global two\n",
@@ -174,8 +197,8 @@
     "    two = 7\n",
     "    return gamma\n",
     "\n",
-    "answer = my_func(alpha, two)\n",
-    "\n",
+    "answer = my_func3(alpha, two)\n",
+    "print(answer)\n",
     "# TODO what variables are accessible here? What values do they have?"
    ]
   },
@@ -197,7 +220,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "7e25ba85",
    "metadata": {},
    "outputs": [],
@@ -232,7 +255,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "678f8ec2",
    "metadata": {},
    "outputs": [],
@@ -240,9 +263,9 @@
     "def some_func_1(x, y, z): \n",
     "    if x >= 7:\n",
     "        return True\n",
-    "    if y < 18:\n",
+    "    elif y < 18:\n",
     "        return True\n",
-    "    if z == 32:\n",
+    "    elif z == 32:\n",
     "        return True\n",
     "    else:\n",
     "        return False"
@@ -260,41 +283,44 @@
     "    return x >= 7 or y < 18 or z == 32\n",
     "\n",
     "def some_func_1b(x, y, z):\n",
-    "    return x >= 7 and y < 18 and z == 32"
+    "    return x >= 7 and y < 18 and z == 32\n",
+    "\n"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "063829c0",
+   "cell_type": "markdown",
+   "id": "bbfbdfcc",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# TODO \n",
-    "# Discuss: given two possible versions of a function (where one is correct),\n",
-    "#          what is the general strategy for figuring out which one is correct?"
+    "## Iteration"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "d1ba721c",
+   "id": "55b93aa1",
    "metadata": {},
    "source": [
-    "## Iteration"
+    "### Example 1 (Reimann sums)"
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "851c3e95",
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eda1fd93",
    "metadata": {},
+   "outputs": [],
    "source": [
-    "### Example 1 (Reimann sums)"
+    " # copied from lecture 6 notes\n",
+    "def f(x):\n",
+    "    return 5 - (x - 2) ** 2\n",
+    "    \n",
+    "print(f(1))"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "85e203c9",
+   "id": "6a58812c",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -309,7 +335,7 @@
     "# delta_x = 0.01\n",
     "# delta_x = 0.001\n",
     "\n",
-    "while current_x <= end_x:\n",
+    "while current_x <= ???:\n",
     "    y = ???                # TODO: use f(x) defined previously\n",
     "    rect_area = ???\n",
     "    total_area += ???\n",
@@ -317,6 +343,14 @@
     "    \n",
     "print(\"Area found using approximation is:\", total_area)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9d49036",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/sum23/lecture_materials/07_Strings/Exam_1_review_notes.ipynb b/sum23/lecture_materials/07_Strings/Exam_1_review_notes.ipynb
new file mode 100644
index 0000000..d79edf2
--- /dev/null
+++ b/sum23/lecture_materials/07_Strings/Exam_1_review_notes.ipynb
@@ -0,0 +1,507 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "482016d5",
+   "metadata": {},
+   "source": [
+    "# Exam 1 review"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "96330469",
+   "metadata": {},
+   "source": [
+    "## Arguments"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "138a92cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def person(name, age, color='blue', animal='cat'):\n",
+    "    print(name, \" is \", age, \" years old \", end=\"\")\n",
+    "    print(\"their favorite color is \",color, end=\"\")\n",
+    "    print(\" and their favorite animal is \",animal)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a5f2edbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Anna  is  10  years old their favorite color is  purple and their favorite animal is  fish\n",
+      "Anna  is  10  years old their favorite color is  purple and their favorite animal is  cat\n",
+      "Anna  is  20  years old their favorite color is  blue and their favorite animal is  cat\n",
+      "Anna  is  20  years old their favorite color is  blue and their favorite animal is  cat\n",
+      "Anna  is  20  years old their favorite color is  blue and their favorite animal is  zebra\n",
+      "20  is  20  years old their favorite color is  blue and their favorite animal is  cat\n"
+     ]
+    }
+   ],
+   "source": [
+    "# TODO: what are all the ways we can (or cannot) call person()?\n",
+    "person(\"Anna\", 10, \"purple\", \"fish\")\n",
+    "\n",
+    "person(\"Anna\", 10, \"purple\")\n",
+    "\n",
+    "# person(\"Anna\") # doesn't work, need to specify age\n",
+    "person(\"Anna\", age=20)\n",
+    "# person(age=20, \"Anna\") # doesn't work, need to specify positional arguments first\n",
+    "\n",
+    "person(age=20, name=\"Anna\")\n",
+    "person(animal=\"zebra\", age=20, name=\"Anna\")\n",
+    "\n",
+    "# person(20, name=\"Anna\") # doesn't work, positional parameters fill first from left to right\n",
+    "\n",
+    "person(20, 20) \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6f623b4b",
+   "metadata": {},
+   "source": [
+    "## Function Scope"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e54320ef",
+   "metadata": {},
+   "source": [
+    "### Example 1 -- basic function scope"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7e4d570a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pi = 3.14\n",
+    "alpha = 4\n",
+    "\n",
+    "def my_func(alpha, beta):\n",
+    "    # TODO: what variables are accessible at line 5? what values do they have?\n",
+    "    # we can access these local variables:\n",
+    "    # -- alpha (has value of parameter passed into function)\n",
+    "    # -- beta (has value of parameter passed into function)\n",
+    "    # -- pi (global variable, value = 3.14)\n",
+    "    delta = alpha + beta\n",
+    "    gamma = delta ** 2\n",
+    "    \n",
+    "    return gamma\n",
+    "\n",
+    "answer = my_func(alpha, pi)\n",
+    "\n",
+    "answer2 = my_func(answer, alpha)\n",
+    "\n",
+    "# TODO what variables are accessible here? What values do they have?\n",
+    "# CANNOT access delta, gamma, beta\n",
+    "# alpha = 4 (note that using the variable name alpha in my_func does not change the global variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "33a302bf",
+   "metadata": {},
+   "source": [
+    "### Example 2 -- global vs. local"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "7a5ed848",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "12\n"
+     ]
+    }
+   ],
+   "source": [
+    "two = 2\n",
+    "alpha = 4\n",
+    "\n",
+    "def my_func1(alpha, beta):\n",
+    "    # TODO: what variables are accessible at line 5? what values do they have?\n",
+    "    # can access two (global), alpha (local), and beta (local)\n",
+    "    delta = alpha + beta\n",
+    "    gamma = delta * two\n",
+    "    \n",
+    "    return gamma\n",
+    "\n",
+    "answer = my_func1(alpha, two)\n",
+    "print(answer)\n",
+    "\n",
+    "# TODO what variables are accessible here? What values do they have?\n",
+    "# can access two (value=2), alpha (value=4), and answer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "04428811",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "112\n"
+     ]
+    }
+   ],
+   "source": [
+    "two = 2\n",
+    "alpha = 14\n",
+    "\n",
+    "def my_func2(alpha, beta):\n",
+    "    # TODO: what variables are accessible at line 5? what values do they have?\n",
+    "    # can access alpha (local), beta, two (global)\n",
+    "    delta = alpha + beta\n",
+    "    two = 7\n",
+    "    gamma = delta * two\n",
+    "    \n",
+    "    return gamma\n",
+    "\n",
+    "answer = my_func2(alpha, two)\n",
+    "print(answer)\n",
+    "# TODO what variables are accessible here? What values do they have?\n",
+    "# can access two (value=2, global variable two is not affected by line 8), alpha (14), and answer (112)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "51696c45",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "UnboundLocalError",
+     "evalue": "local variable 'two' referenced before assignment",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[5], line 13\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m gamma\n\u001b[1;32m     12\u001b[0m \u001b[38;5;66;03m# oops, there was a typo in the template: next line should call my_func3 not my_func\u001b[39;00m\n\u001b[0;32m---> 13\u001b[0m answer \u001b[38;5;241m=\u001b[39m \u001b[43mmy_func3\u001b[49m\u001b[43m(\u001b[49m\u001b[43malpha\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtwo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     15\u001b[0m \u001b[38;5;66;03m# TODO what variables are accessible here? What values do they have?\u001b[39;00m\n",
+      "Cell \u001b[0;32mIn[5], line 8\u001b[0m, in \u001b[0;36mmy_func3\u001b[0;34m(alpha, beta)\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmy_func3\u001b[39m(alpha, beta):\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;66;03m# TODO: what variables are accessible at line 5? what values do they have?\u001b[39;00m\n\u001b[1;32m      6\u001b[0m     delta \u001b[38;5;241m=\u001b[39m alpha \u001b[38;5;241m+\u001b[39m beta\n\u001b[0;32m----> 8\u001b[0m     gamma \u001b[38;5;241m=\u001b[39m delta \u001b[38;5;241m*\u001b[39m \u001b[43mtwo\u001b[49m\n\u001b[1;32m      9\u001b[0m     two \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m7\u001b[39m\n\u001b[1;32m     10\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m gamma\n",
+      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'two' referenced before assignment"
+     ]
+    }
+   ],
+   "source": [
+    "two = 2\n",
+    "alpha = 14\n",
+    "\n",
+    "def my_func3(alpha, beta):\n",
+    "    # TODO: what variables are accessible at line 5? what values do they have?\n",
+    "    # can access alpha and beta\n",
+    "    # CANNOT access global variable two because we define a local version of two later in this function\n",
+    "    delta = alpha + beta\n",
+    "    \n",
+    "    gamma = delta * two\n",
+    "    two = 7\n",
+    "    return gamma\n",
+    "\n",
+    "# oops, there was a typo in the template: next line should call my_func3 not my_func\n",
+    "answer = my_func3(alpha, two)\n",
+    "\n",
+    "# TODO what variables are accessible here? What values do they have?\n",
+    "# N/A: this code crashes because in line 10 we access the local variable \"two\" before it is defined"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "6cdb7a02",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "32\n"
+     ]
+    }
+   ],
+   "source": [
+    "two = 2\n",
+    "alpha = 14\n",
+    "\n",
+    "def my_func3(alpha, beta):\n",
+    "    # TODO: what variables are accessible at line 5? what values do they have?\n",
+    "    # can access two (global), alpha (local), beta (local)\n",
+    "    \n",
+    "    global delta # adding this in to show how we create a global variable in a function\n",
+    "    delta = alpha + beta\n",
+    "    \n",
+    "    global two\n",
+    "    gamma = delta * two\n",
+    "    two = 7\n",
+    "    return gamma\n",
+    "\n",
+    "# oops, there was a typo in the template: next line should call my_func3 not my_func\n",
+    "answer = my_func3(alpha, two)\n",
+    "print(answer)\n",
+    "# TODO what variables are accessible here? What values do they have?\n",
+    "# can access two (value=7), alpha (value=14), delta (value = 16), answer (value=32)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2ebbfa8b",
+   "metadata": {},
+   "source": [
+    "## Refactoring"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c61c0d46",
+   "metadata": {},
+   "source": [
+    "### Example 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7e25ba85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def some_func():\n",
+    "    if some_cond1:\n",
+    "        if some_cond2:\n",
+    "            if some_cond3:\n",
+    "                return True\n",
+    "    return False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d6dc250a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "# TODO how can we rewrite some_func() to only use 1 line of code? \n",
+    "def some_func_short():\n",
+    "    return some_cond1 and some_cond2 and some_cond3\n",
+    "\n",
+    "some_cond1 = True\n",
+    "some_cond2 = True\n",
+    "some_cond3 = True\n",
+    "print(some_func())\n",
+    "print(some_func_short())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9da2d00",
+   "metadata": {},
+   "source": [
+    "### Example 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "678f8ec2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def some_func_1(x, y, z): \n",
+    "    # trial 1: x = 8, y = 19, z = 32\n",
+    "    if x >= 7:\n",
+    "        return True\n",
+    "    elif y < 18:\n",
+    "        return True\n",
+    "    elif z == 32:\n",
+    "        return True\n",
+    "    else:\n",
+    "        return False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "d1bf3938",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "# TODO which of these refactoring options is correct?\n",
+    "def some_func_1a(x, y, z):\n",
+    "    return x >= 7 or y < 18 or z == 32\n",
+    "\n",
+    "def some_func_1b(x, y, z):\n",
+    "    return x >= 7 and y < 18 and z == 32\n",
+    "\n",
+    "print(some_func_1(8, 19, 32))\n",
+    "print(some_func_1a(8, 19, 32))\n",
+    "print(some_func_1b(8, 19, 32))\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "718663c1",
+   "metadata": {},
+   "source": [
+    "TODO \n",
+    "\n",
+    "Discuss: given two possible versions of a function (where one is correct),          what is the general strategy for figuring out which one is correct?\n",
+    "\n",
+    "1. Check what kind of conditionals you have: nested or chained\n",
+    "   - If nested, usually use \"and\"\n",
+    "   - If chained, usually use \"or\"\n",
+    "   - But be careful, because the addition of \"not\" or \"False\" will change things\n",
+    "   \n",
+    "2. Test cases to see what answers agree\n",
+    "   - Assign parameter values and trace through each function using these same values. Check whether the output agrees.\n",
+    "   - If a function takes only 2 True/False inputs, there are only 4 combinations of inputs total. It's usually possible to check the 4 possible outcomes by hand.\n",
+    "   \n",
+    "3. Use logic. \n",
+    "   - Listing out by hand when the function will return True or False\n",
+    "   - What parameters can you use to get the function to execute particular paths?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bbfbdfcc",
+   "metadata": {},
+   "source": [
+    "## Iteration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55b93aa1",
+   "metadata": {},
+   "source": [
+    "### Example 1 (Reimann sums)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "eda1fd93",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n"
+     ]
+    }
+   ],
+   "source": [
+    " # copied from lecture 6 notes\n",
+    "def f(x):\n",
+    "    return 5 - (x - 2) ** 2\n",
+    "    \n",
+    "print(f(1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "6a58812c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Area found using approximation is: 10.670666000001766\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Let's try the values from 1 to 5\n",
+    "start_x = 1\n",
+    "end_x = 5\n",
+    "total_area = 0\n",
+    "current_x = start_x\n",
+    "# Try out increasing values of width, make sure to comment the other width values\n",
+    "# delta_x = 1\n",
+    "# delta_x = 0.1\n",
+    "# delta_x = 0.01\n",
+    "delta_x = 0.001\n",
+    "\n",
+    "while current_x <= end_x:\n",
+    "    y = f(current_x)                # TODO: use f(x) defined previously\n",
+    "    rect_area = delta_x * y\n",
+    "    total_area += rect_area\n",
+    "    current_x += delta_x\n",
+    "    \n",
+    "print(\"Area found using approximation is:\", total_area)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9d49036",
+   "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.10.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/sum23/lecture_materials/07_Strings/lec_07_Strings_notes.ipynb b/sum23/lecture_materials/07_Strings/lec_07_Strings_notes.ipynb
new file mode 100644
index 0000000..7090f01
--- /dev/null
+++ b/sum23/lecture_materials/07_Strings/lec_07_Strings_notes.ipynb
@@ -0,0 +1,1060 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Strings\n",
+    "\n",
+    "## Readings\n",
+    "\n",
+    "- Chapter 8 ( + 9) of Think Python\n",
+    "- Chapter 7 of Python for Everybody"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Review"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Review1: Build a string using `+=`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dog = \"\"\n",
+    "cat = \"\"\n",
+    "chicken = \"\"\n",
+    "\n",
+    "sentence = \"\"\n",
+    "sentence += \"I have a dog named \" + dog\n",
+    "sentence += \" a cat named \" + cat\n",
+    "sentence += \" and a chicken named \" + chicken\n",
+    "print(sentence)\n",
+    "\n",
+    "# TODO: print the length of sentence using len\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Learning Objectives:\n",
+    "- Compare two strings by hand using < or > \n",
+    "- Recognize common string methods, explain what they do, and use them in Python code\n",
+    "- Define the term sequence, name common sequence operations, and explain how a string is a sequence\n",
+    "- Index and slice strings using correct syntax, including positive and negative indices\n",
+    "- Read and Write code that uses a for loop to iterate over a string"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Compare two strings by hand using `<`, `>`, `==`, or `!=` "
+   ]
+  },
+  {
+   "attachments": {
+    "string%20comparison.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:string%20comparison.png\" width=\"600\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"cat\" != \"dog\") # use !=\n",
+    "print() # TODO: use ==\n",
+    "print() # TODO: use <\n",
+    "print() # TODO: use >"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### String comparison:\n",
+    "\n",
+    "Strings are compared one char at a time, using the ASCII table: https://simple.wikipedia.org/wiki/ASCII\n",
+    "\n",
+    "#### Exceptions\n",
+    "\n",
+    "1. upper case comes before lower case\n",
+    "2. string of digits are compared one character at a time\n",
+    "3. prefixes come before any word containing that prefix (because space comes before any alphabet in the ASCII table)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n",
+      "True\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"H\" < \"h\")                 # upper case comes before lower case\n",
+    "print(\"dorm room\" < \"dormroom\")  # space comes before 'r' in the ASCII table\n",
+    "print(\"base\" < \"baseball\")       # strings that end come before strings that continue, \n",
+    "                                 # that is no character comes before some character\n",
+    "print(\"11\" < \"2\")                # strings of digits are compared one character at a time"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You keep the comparison going until you find the first non-matching character."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"doo doo\" < \"dog\") # \"o\" comes after \"g\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"15.1\" < \"150\")\n",
+    "print(\".\" < \"0\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Worksheet problem 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "False\n",
+      "False\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"a\" < \"z\") # true\n",
+    "print(\"a\" < \"Z\") # False\n",
+    "print(\"x\" < \"x\") # False\n",
+    "print(\"0\" < \"x\")  # True\n",
+    "print(\"1\" < \"0\") # False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "False\n",
+      "True\n",
+      "False\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"ax\" < \"ay\") # True\n",
+    "print(\"x2\" < \"x1\") # False\n",
+    "print(\"abcX\" < \"abcY\") # True\n",
+    "print(\"abcX\" < \"aBcY\") # False\n",
+    "print(\"abc\" < \"abcd\") # True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n",
+      "False\n",
+      "True\n",
+      "True\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"abc\" < \"abCd\") # False\n",
+    "print(\"zero\"< \"999\") # False\n",
+    "print(\"10\" < \"999\") # True\n",
+    "print(\"1000\" < \"999\") # True\n",
+    "print(\"88888888888\" < \"9\") # True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### String methods\n",
+    "\n",
+    "- Strings have special functions that are part of the definition of a string\n",
+    "- These are called methods and are called with a '.', similar to modules"
+   ]
+  },
+  {
+   "attachments": {
+    "string%20methods.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:string%20methods.png\" width=\"600\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CAT\n",
+      "cat\n",
+      "cAt\n"
+     ]
+    }
+   ],
+   "source": [
+    "dog = \"cAt\"\n",
+    "print(dog.upper())     \n",
+    "print(dog.lower())\n",
+    "print(dog) # calling a method on a string does not change the original variable's value"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "So, how do you update the original variable?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CAT\n"
+     ]
+    }
+   ],
+   "source": [
+    "dog = dog.upper()\n",
+    "print(dog)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`dog.upper()` is equivalent to `str.upper(dog)`. Programmers don't prefer the latter usage as `str` is redundant (it is obvious that dog variable stores a data type of string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'CAT'"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dog = \"cAt\"\n",
+    "str.upper(dog)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Stripping removes whitespace."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'       A       B\\nC      '"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "some_word = \"       A       B\\nC      \"\n",
+    "some_word"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "       A       B\n",
+      "C      \n"
+     ]
+    }
+   ],
+   "source": [
+    "print(some_word)  # recall that print function formats the string and only \n",
+    "                  # displays the formatted output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'A       B\\nC'"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# TODO: call strip method\n",
+    "some_word.strip()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'A       B\\nC      '"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# TODO: call lstrip method\n",
+    "some_word.lstrip()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'       A       B\\nC'"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# TODO: call rstrip method\n",
+    "some_word.rstrip()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "find method returns index of first matching character of the search string or -1, if there is no match.\n",
+    "\n",
+    "- `find` requires a search string as argument. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220 is Awesome!\n"
+     ]
+    }
+   ],
+   "source": [
+    "some_str = \"220 is Awesome!\"\n",
+    "print(some_str)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n",
+      "2\n",
+      "7\n",
+      "10\n",
+      "-1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# print(some_str.find(\"1\"))   \n",
+    "print(some_str.find(\"2\"))   \n",
+    "print(some_str.find(\"0\")) \n",
+    "print(some_str.find(\"A\")) \n",
+    "print(some_str.find(\"some\")) \n",
+    "\n",
+    "# TODO: try to find \"awe\": does it work? How can you make it work?\n",
+    "print(some_str.find(\"awe\"))\n",
+    "# TODO: discuss: what method can you invoke prior to invoking find method \n",
+    "# to successfully find \"awe\"?\n",
+    "\n",
+    "# One option: convert the string to lowercase\n",
+    "# Another option: checking that the answer is at least 0\n",
+    "if some_str.find(\"awe\") > 0:\n",
+    "    # do stuff\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "False\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(some_str.startswith(\"220\"))\n",
+    "print(some_str.startswith(\"319\"))\n",
+    "print(some_str.endswith(\"some!\"))\n",
+    "print(some_str.endswith(\"Awesome\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Replace replaces all matching occurrence.\n",
+    "\n",
+    "`string_to_updated.replace(search_string, replacement_string)`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220 is AwEsomE!\n",
+      "220 is AwEsomE!\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(some_str.replace(\"e\", \"E\"))\n",
+    "# adding this line updates the string for future computations\n",
+    "some_str = some_str.replace(\"e\", \"E\")\n",
+    "print(some_str.replace(\"3\", \"three\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "String methods can be called on literals."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "HELLO\n",
+      "Moot mo at tho biko racks\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Hello\".upper())\n",
+    "print(\"Meet me at the bike racks\".replace('e', 'o'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Format function enables us specify placeholders within the string, which can be replaced with some variable's value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dear Viyan, your grade for exam1 is A\n",
+      "Dear Anna, your grade for exam1 is B\n"
+     ]
+    }
+   ],
+   "source": [
+    "email = \"Dear {}, your grade for exam1 is {}\"\n",
+    "print(email.format(\"Viyan\", \"A\"))\n",
+    "\n",
+    "# TODO: give yourself or your friend some grade\n",
+    "print(email.format(\"Anna\", \"B\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "IndexError",
+     "evalue": "Replacement index 1 out of range for positional args tuple",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[11], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# TODO: what will happen when you pass only one argument to \u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m# format method using email string?\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43memail\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mformat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mAnna\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m) \n",
+      "\u001b[0;31mIndexError\u001b[0m: Replacement index 1 out of range for positional args tuple"
+     ]
+    }
+   ],
+   "source": [
+    "# TODO: what will happen when you pass only one argument to \n",
+    "# format method using email string?\n",
+    "print(email.format(\"Anna\")) "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Sequence\n",
+    "\n",
+    "- Definition: a sequence is a collection of numbered/ordered values\n",
+    "- String: a sequence of one-character strings"
+   ]
+  },
+  {
+   "attachments": {
+    "sequences.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<div>\n",
+    "<img src=\"attachment:sequences.png\" width=\"600\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "220 is AwEsomE!\n",
+      "15\n"
+     ]
+    }
+   ],
+   "source": [
+    "# TODO: find length of some_str\n",
+    "print(some_str)\n",
+    "print(len(some_str))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Indexing\n",
+    "\n",
+    "- enables you to extract one item in your sequence, that is one character in a string\n",
+    "- Syntax: string_var`[index]`\n",
+    "    - index needs to be in range, that is from `0` to `len(string_var) - 1`\n",
+    "    - other index values will produce `IndexError`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Friday\n",
+      "r\n",
+      "y\n",
+      "y\n",
+      "a\n"
+     ]
+    },
+    {
+     "ename": "IndexError",
+     "evalue": "string index out of range",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[16], line 8\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28mprint\u001b[39m(day[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]) \u001b[38;5;66;03m# last\u001b[39;00m\n\u001b[1;32m      7\u001b[0m \u001b[38;5;28mprint\u001b[39m(day[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m]) \u001b[38;5;66;03m# 2nd last\u001b[39;00m\n\u001b[0;32m----> 8\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mday\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m50\u001b[39;49m\u001b[43m]\u001b[49m) \u001b[38;5;66;03m# this won't work\u001b[39;00m\n",
+      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
+     ]
+    }
+   ],
+   "source": [
+    "day = \"Friday\"\n",
+    "print(day)\n",
+    "print(day[1])  # 2nd character\n",
+    "print(day[5])  # last\n",
+    "\n",
+    "print(day[-1]) # last\n",
+    "print(day[-2]) # 2nd last\n",
+    "print(day[50]) # this won't work"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Slicing\n",
+    "- enables you to extract a sub-sequence\n",
+    "- sub-sequence will be of same type as original sequence\n",
+    "- Syntax: string_var`[start_index:end_indx]`:\n",
+    "    - start_index is inclusive\n",
+    "    - end_index is exclusive\n",
+    "    - index need not be in range. Slicing will ignore indices which are not in range of `0` to `len(string_var) - 1`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Friday\n",
+      "ri\n",
+      "riday\n",
+      "riday\n",
+      "Fri\n",
+      "Friday\n",
+      "da\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(day)\n",
+    "# Friday\n",
+    "print(day[1:3])    # include 1, exclude 3 --> \"ri\"\n",
+    "print(day[1:100])  # slicing is forgiving --> \"riday\"\n",
+    "print(day[1:])     # can skip 2nd number --> \"riday\"\n",
+    "print(day[:3])     # can skip 1st number --> \"Fri\"\n",
+    "print(day[:])      # this, too! --> \"Friday\"\n",
+    "print(day[-3:-1])  # can use negative indices --> \"da\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "''"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "day[4:3] # if start_index >= end_index, return the empty string"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### for loops\n",
+    "\n",
+    "- can iterate over every item in a sequence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "F\n",
+      "r\n",
+      "i\n",
+      "d\n",
+      "a\n",
+      "y\n"
+     ]
+    }
+   ],
+   "source": [
+    "# print each letter of the string using while loop\n",
+    "index = 0\n",
+    "while index < len(day):\n",
+    "    print(day[index])\n",
+    "    index += 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "F\n",
+      "r\n",
+      "i\n",
+      "d\n",
+      "a\n",
+      "y\n"
+     ]
+    }
+   ],
+   "source": [
+    "# print each letter of the string using for loop\n",
+    "# letter is a new variable that is the value of each iteration\n",
+    "for letter in day:\n",
+    "    print(letter)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'b' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[21], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# the 2nd variable must be defined\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m# 2nd var b undefined\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m \u001b[43mb\u001b[49m: \n\u001b[1;32m      4\u001b[0m     \u001b[38;5;28mprint\u001b[39m(a)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'b' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "# the 2nd variable must be defined\n",
+    "# 2nd var b undefined\n",
+    "for a in b: \n",
+    "    print(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "F\n",
+      "r\n",
+      "i\n",
+      "d\n",
+      "a\n",
+      "y\n"
+     ]
+    }
+   ],
+   "source": [
+    "# print each letter of the string using for loop with range built-in function call\n",
+    "# range enables us to iterate over every index in the string\n",
+    "\n",
+    "for idx in range(len(day)):\n",
+    "    print(day[idx])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "r\n",
+      "d\n",
+      "y\n"
+     ]
+    }
+   ],
+   "source": [
+    "# range built-in function: an optional 3rd number is the increment\n",
+    "# let's print every other character in the string\n",
+    "\n",
+    "for idx in range(1, len(day), 2):  \n",
+    "    print(day[idx])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "N\n",
+      "C\n",
+      "A\n",
+      "A\n",
+      "NCAA\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Practice: Write a for loop to generate a string that makes an acronym\n",
+    "\n",
+    "phrase = \"National Collegiate Athletic Association 2022\"\n",
+    "acro = \"\"\n",
+    "for letter in phrase:\n",
+    "    if letter.upper() == letter and letter.isalpha():\n",
+    "        print(letter)\n",
+    "        \n",
+    "        # How can we make sure you don't consider spaces and numbers?\n",
+    "        # TODO: try isalpha method (update if condition)\n",
+    "        # TODO: now instead of printing the letter, concatenate the letter to acro\n",
+    "        acro += letter\n",
+    "print(acro)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Other string methods: https://www.w3schools.com/python/python_ref_string.asp. Methods in Python have very intuitive names. Please don't memorize the methods."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Wordle\n",
+    "### Self-practice example\n",
+    "- read through the below program, to understand its functionality"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_wordle_results(guess):\n",
+    "    wordle_result = \"\"\n",
+    "    for i in range(len(guess)):\n",
+    "        if guess[i] == word_of_the_day[i]:\n",
+    "            wordle_result += \"O\"\n",
+    "        elif word_of_the_day.find(guess[i]) != -1:\n",
+    "            wordle_result += \"_\"\n",
+    "        else:\n",
+    "            wordle_result += \"X\"\n",
+    "    return wordle_result\n",
+    "\n",
+    "max_num_guesses = 6\n",
+    "current_num_guesses = 1\n",
+    "word_of_the_day = \"CRANE\"\n",
+    "\n",
+    "print(\"Welcome to PyWordle!\")\n",
+    "print(\"You have 6 guesses to guess a 5 character word.\")\n",
+    "print(\"X\\tThe letter is not in the word.\")\n",
+    "print(\"_\\tThe letter is in the word, but in the wrong place.\")\n",
+    "print(\"O\\tThe letter is in the correct place!\")\n",
+    "\n",
+    "while current_num_guesses <= max_num_guesses:\n",
+    "    guess = input(\"Guess the word: \")\n",
+    "    guess = guess.upper()\n",
+    "\n",
+    "    wordle_results = get_wordle_results(guess)\n",
+    "    print(\"{}\\t{}\".format(guess, wordle_results))\n",
+    "    if guess == word_of_the_day:\n",
+    "        break\n",
+    "    current_num_guesses += 1\n",
+    "    \n",
+    "if current_num_guesses > max_num_guesses:\n",
+    "    print(\"Better luck next time!\")\n",
+    "    print(\"The word was: {}\".format(word_of_the_day))\n",
+    "else:\n",
+    "    print(\"You won in {} guesses!\".format(current_num_guesses))"
+   ]
+  }
+ ],
+ "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.10.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
-- 
GitLab