seperate loops and logic into data structures adding lesson on data structures, start the function and classes doc, add more to intro about variable scoping

Author: ProbablyComputingSquid

Data_Sturctures.ipynb

@@ -0,0 +1,352 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Data Structures\n",
+    "\n",
+    "A \"Data Structure\" is just a fancy way of saying, \"I put some information in a container.\" Conveniently, it makes me seem more professional and fancy. Python has a few types of Data Structures, but the most common ones are lists, tuples, and dictionaries. These structures let you store and organize data in different ways, making it easier to work with.\n",
+    "\n",
+    "### Lists\n",
+    "Lists are ordered collections of items that can be changed (mutable). You can think of them as a shopping list where you can add, remove, or change items. Lists are defined using square brackets `[]`, and you can access items using their index (starting from 0), like this: `list[n]`. Each item in a list is called an \"element.\" You can have as many elements as you can fit in your array without running out of memory. By the way, this is called a \"Stack Overflow\" error, and it happens when you try to use more memory than your computer has available in the RAM. It's like trying to fit two gallons of milk into a one-gallon milk jug, it just doesn't work.\n",
+    " Anyone who thinks that lists should be 1-indexed is insane or uses Lua. The two are not mutually exclusive.\n",
+    "Anyways, here's an example of a list:\n"
+   ],
+   "id": "7f5460c23543de90"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "list_of_fruits = [\"apple\", \"banana\", \"cherry\"]\n",
+    "print(list_of_fruits[0])  # Access the first item\n",
+    "print(list_of_fruits[-1])"
+   ]
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "Now, you might be thinking, \"What the heck, Jay? There are no negative elements in the list!\" Well, you're right. However, Python allows you to access elements from the front _and_ the back of a list. In Java, if you wanted to access the last element of a list, you would have to do `list.get(list.size() - 1)`. What excessive bloat for just accessing the last element of a list.\n",
+    "\n",
+    "But in Python, you can just do `list[-1]` to get the last element. This is because Python allows negative indexing, where `-1` refers to the last item, `-2` refers to the second-to-last item, and so on. Now, in JavaScript, you can straight up have negative indexes in your list, but that's a whole different topic.\n",
+    "\n",
+    "You can also add items to a list using the `append(element)` method, remove items using the `remove(element)` or `pop(index)` methods, and sort the list using the `sort()` method. Here's an example:"
+   ],
+   "id": "1df39f3d09ca66d9"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "students = [\"Jay\", \"Reuben\", \"Alex\"]\n",
+    "# trying appending your name here!\n",
+    "students.append(\"Noah\")\n",
+    "print(students)  # Output: ['Jay', 'Reuben', 'Alex', 'Noah']\n",
+    "students.remove(\"Reuben\")\n",
+    "print(students)  # Output: ['Jay', 'Alex', 'Noah']\n",
+    "students.sort()  # Sorts the list in alphabetical order\n",
+    "print(students)  # Output: ['Alex', 'Jay', 'Noah']"
+   ],
+   "id": "f691020fa9c6d982"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Python also has a few built-in functions that work with lists, such as `len(list)` to get the number of elements in a list, the <i>len</i>gth `min(list)` to get the smallest element (*min*imum), and `max(list)` to get the largest element (*max*imum). Try running the following code block:",
+   "id": "4da42bee367d6db5"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "my_grades=[69,42, 21, 67, 100, 98,  82]\n",
+    "print(\"I have\", len(my_grades), \"grades.\")\n",
+    "print(\"My lowest grade is a\", min(my_grades)) # worse than not doing your assignment bru\n",
+    "print(\"My highest grade is a\", max(my_grades))"
+   ],
+   "id": "2b47c43356770265"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "### Exercise: Average of a List\n",
+    "\n",
+    "In the following code block, try calculating the average of the numbers in the list `data`. If you're in high school, surely you know how to calculate an average, right? If not, here's a quick reminder: To find a list of numbers' average, you add up all the numbers and then divide by the count of numbers in the list."
+   ],
+   "id": "b47bfd40ce8f6513"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "data = [3.6, 3.14, 2.9, 6.33, 4.1, 8.9, 5.3, 7.3, 1.56, 8.1]\n",
+    "average = 0.0\n",
+    "#\n",
+    "#\n",
+    "# your code here!\n",
+    "#\n",
+    "#\n",
+    "print(\"The average is:\", average) # you should get sm around 5.123"
+   ],
+   "id": "129eb26d7df4c0c7"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Tuples\n",
+    "A tuple is similar to a list, but it is immutable. That means you cannot change the contents of the list once you've declared it. Tuples are defined using parentheses `()`, and you can access items using their index, just like lists. Tuples are often used to store ordered, related pieces of data that should not change, like coordinates or RGB color values. Here's an example:"
+   ],
+   "id": "75ec9bf50b678774"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "GREEN = (0, 255, 0)  # RGB color value for green\n",
+    "ORIGIN = (0,0) # Coordinates for the origin point\n",
+    "print(\"The RGB value for green is:\", GREEN)\n",
+    "print(\"The origin point is:\", ORIGIN)"
+   ],
+   "id": "1886431322da6920"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Tuples can have duplicates, along with multiple types of data. For example, you can have a tuple that contains a string, an integer, and a float. You can also have a tuple that contains only one element, but you must include a comma at the end to differentiate it from a regular parenthesis.",
+   "id": "52d58a40a70cdca3"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "single_element_tuple = (42,)  # A tuple with one element\n",
+    "mixed_tuple = (\"apple\", 3, 4.5, (6.9,2))  # A tuple with some different data types\n",
+    "# and yes, you can have nested tuples, like if you needed a set of coordinate points for a polygon"
+   ],
+   "id": "9e7746b2f36ef157"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "### Some fun tuple methods\n",
+    "\n",
+    "Haven't you ever wanted to...uh...add two tuples together? I sure haven't, but there's got to be a use case for it. You can add tuples together like strings using the `+` operator. This will concatenate the two tuples together, creating a new tuple that contains all the elements from both tuples."
+   ],
+   "id": "7655ca21de2974bb"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "my_shopping_list = (\"laptop\", \"mouse\", \"kitten\", \"4 count monster energy\")\n",
+    "alex_yin_shopping_list = (\"violin\", \"robux for deepwoken\", \"hershey bar\")\n",
+    "\n",
+    "combined_shopping_list = my_shopping_list + alex_yin_shopping_list\n",
+    "print(\"Our shopping list:\", my_shopping_list)"
+   ],
+   "id": "95669f08f5064b95"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "I've also recently been informed that there exists a way to multiply tuples. Why you would need to use this, I have no idea. I have racked my brain for a use case, but it's even harder to think of than finding a use case for adding two tuples together. Anyways, multiplying a tuple by an integer will repeat the elements of the tuple that n times, creating a new tuple.",
+   "id": "c23759f95b095c9"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "tuple1 = (\"ha\",)\n",
+    "tuple2 = tuple1 * 5\n",
+    "print(tuple2)  # Output: ('ha', 'ha', 'ha', 'ha', 'ha')\n",
+    "# see, i am not laughing because this tuple multiplication is so funny (its not)"
+   ],
+   "id": "55822ee0c748aafb"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "### unpacking tuples\n",
+    "\n",
+    "tuples can be \"unpacked\" from their little casing into different variables. let's say that you had a tuple that stored the x and y coordinates of a point, like `(6,7)`. You can unpack this tuple into two separate variables like this:"
+   ],
+   "id": "6d125c0a65c90ae7"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "coordinate1 = (6,7)\n",
+    "x, y = coordinate1  # Unpacking the tuple into x and y variables\n",
+    "print(\"The x coordinate is:\", x)\n",
+    "print(\"The y coordinate is:\", y)"
+   ],
+   "id": "18a93f41ce1fe553"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "### Exercise with tuples: distance between two points\n",
+    "\n",
+    "The distance between two points in a 2d space can be calculated using the pythagorean theorem. You can think about it like a triangle, where the bottom leg is the difference in the x coordinates, and the side leg is the difference in y coordinates, and the hypotenuse is the distance.\n",
+    "\n",
+    "You can use `math.sqrt()` for a square root function, and `x**2` for squaring a number.\n",
+    "In the code block below, write some code that will calculate the distance of two points as a tuple."
+   ],
+   "id": "13c38b7388024f2a"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "n=6\n",
+    "print(n^2) # MAKE SURE NOT TO DO THIS!! this is a bitwise XOR operation, not squaring a number!!\n",
+    "print(n ** 2) # this is the correct way to do exponentiation\n",
+    "\n",
+    "point_1=(3, 4) # x1 and y1 coordinates\n",
+    "point_2=(-8, 5)\n",
+    "# your code here!!"
+   ],
+   "id": "9d7a07cd1d46ae14"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Dictionaries\n",
+    "Dictionaries are ordered collections of key-value pairs. They are like a real-life dictionary, where you look up a word (the key) to find its definition (the value). Dictionaries are defined using curly braces `{}`, and you can access values using their keys, like this: `dict[key]`. This is very helpful when you are storing data that has a specific relationship between keys and values, like a phone book or a contact list. Instead of making two lists called `names` and `phone_numbers`, you can just make a dictionary called `contacts` that has the names as keys and the phone numbers as values."
+   ],
+   "id": "d7ec5d0487a48e84"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "contacts = {\n",
+    "    \"Jay\": \"123-456-7890\",\n",
+    "    \"Reuben\": \"987-654-3210\",\n",
+    "    \"Alex\": \"555-555-5555\",\n",
+    "    \"bbno$\" : \"1-800-HIT-MY-LINE\",\n",
+    "}"
+   ],
+   "id": "1c04423957675e8f"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Dictionaries can have keys and values of different data types, including strings, integers, floats, lists, and even other dictionaries. However, the biggest thing you need to remember is that dictionaries cannot have duplicate keys. If you try to add a key that already exists in the dictionary, it will overwrite the existing value with the new value. It's just like how you can't have two people with the same name in your class, you'll never be able to tell them apart.",
+   "id": "359cda4ca364e0b6"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-08-20T13:52:57.750298Z",
+     "start_time": "2025-08-20T13:52:57.742823Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "classroom = {\n",
+    "    \"Benn\": 101,\n",
+    "    \"Frederick\": 102,\n",
+    "    \"Sir John Marshall Harlan Bunting XIVV Junior\": 103,\n",
+    "    \"Steve\": 104,\n",
+    "    \"John\": 105, # notice how this gets overwritten\n",
+    "    \"John\": 106,\n",
+    "}\n",
+    "print(classroom)"
+   ],
+   "id": "83e61f1027bad569",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Benn': 101, 'Frederick': 102, 'Sir John Marshall Harlan Bunting XIVV Junior': 103, 'Steve': 104, 'John': 106}\n"
+     ]
+    }
+   ],
+   "execution_count": 2
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Methods for Data Structures\n",
+    "\n",
+    "- `in` operator: Checks if an item is in a list or tuple.\n",
+    "- `index(item)`: Returns the index of the first occurrence of an item in a list.\n",
+    "- `count(item)`: Returns the number of occurrences of an item in a list.\n",
+    "- `join()`: Joins elements of a list into a string\n"
+   ],
+   "id": "1825c37cce7b82d7"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "students = [\"Benn\", \"Frederick\", \"Jarquantavius\", \"Steve\", \"John\", \"John\", \"John\"]\n",
+    "print(\"Class Roster: \", \", \".join(students))  # Joins the list into a string\n",
+    "print(\"Is Benn a student?\", \"Benn\" in students)  # Checks if \"Benn\" is in the list\n",
+    "print(\"Index of Steve:\", students.index(\"Steve\"))  # Gets the index of \"Steve\"\n",
+    "print(\"Number of times 'John' appears:\", students.count(\"John\"))  # how many times john is in the list"
+   ],
+   "id": "1f326905b82a434b"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Functions_and_Classes.ipynb

@@ -0,0 +1,37 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    ""
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}