move data struture stuff from loops to data structures

Author: ProbablyComputingSquid

Data_Structures.ipynb

@@ -461,6 +461,39 @@
    ],
    "id": "522a670b3425c220"
   },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Looping through Data Structures\n",
+    "\n",
+    "There are several ways to loop through data structures in Python, some of which make a decent amount of sense, others which are a bit more confusing. The most common way to loop through data structures is a `for` loop. You  can use a `for` loop to iterate over the elements of a list, tuple, dictionary or string. The formula for this is `for item in data_structure:` where `data_structure` is the list, tuple, dictionary, or string you want to loop through. The `item` variable will take on the value of each element in the data structure as you iterate through it. Remember, you can only use this variable in its scope, which is in the loop.\n",
+    "\n",
+    "\n",
+    "Run the code block below to see how it works with with a list, tuple, and string."
+   ],
+   "id": "b1fd5bf54b16365d"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "for char in \"hello\":\n",
+    "    print(char)  # This will print each character in the string \"hello\", because strings are like arrays of characters\n",
+    "\n",
+    "backpack = [\"laptop\", \"slightly broken TV\", \"water cooler\", \"monster energy\", \"a pencil stub that has only an eraser left\", \"Ace of Spades\", \"Rules Card\"]\n",
+    "\n",
+    "for item in backpack:\n",
+    "    print(item)  # loops through each item in the backpack list and prints it\n",
+    "\n",
+    "PANTONE_448_C = (74, 65, 42) # the ugliest color in the world, used on cigarette packaging\n",
+    "for color in PANTONE_448_C:\n",
+    "    print(color)  # loops through each element in the tuple and prints it\n"
+   ],
+   "id": "48fa92706c02d466"
+  },
   {
    "metadata": {},
    "cell_type": "markdown",
@@ -469,6 +502,132 @@
     "\n"
    ],
    "id": "95449c903c6b4dc1"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Looping through Dictionaries\n",
+    "Dictionaries are a bit different from lists and tuples, as they are key-value pairs. You can either loop through the keys, the values, or both. Here's how you can do that:"
+   ],
+   "id": "fda4609996d1db8"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "shop = {\n",
+    "    \"apples\": 1.5,\n",
+    "    \"bananas\": 0.5,\n",
+    "    \"oranges\": 0.75,\n",
+    "    \"milk\": 2.0,\n",
+    "    \"eggs\": 999, # eggs are expensive these days, all the tariffs :pensive:\n",
+    "}\n",
+    "\n",
+    "# Looping through keys\n",
+    "for item in shop:\n",
+    "    print(item)  # This will print each key in the dictionary\n",
+    "# Looping through values\n",
+    "for price in shop.values():\n",
+    "    print(price)  # This will print each value in the dictionary\n",
+    "# alternative way to loop through prices\n",
+    "for item in shop:\n",
+    "    print(shop[item]) # access the price for each item using the key\n",
+    "\n",
+    "# Looping through both keys and values\n",
+    "for item, price in shop.items():\n",
+    "    print(f\"{item}: ${price}\")  # This will print each key-value pair in the dictionary"
+   ],
+   "id": "dc42f1c14d649a5a"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "In the last few lines in the code cell above, you can see that we used two loop variables and the shop.items() method. This method returns a tuple of the key-value pairs, which we can then unpack into two variables, `item` and `price`. This is a useful way to loop through dictionaries when you need both the key and the value.",
+   "id": "1289bd77c7fc2130"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## List Comprehension\n",
+    "\n",
+    "List comprehension is probably one of the most confusing yet useful things that you'll come accross in python.  If you've ever used a filter in another language, it's pretty much that. List comprehension lets you create a new list by applying an expression to each item in an existing iterable (like a list or a string) in a single line of code. The syntax is `new_iterable = [expression for item in iterable if condition]`. The `if condition` part is optional, but it allows you to filter the items in the iterable based on a condition.\n",
+    "\n",
+    "Let's say I wanted to create a list of the squares of the numbers from 0 to 9. I could do it with list comprehension like this:"
+   ],
+   "id": "703e7267cc4a55a6"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "squares = [x**2 for x in range(10)]\n",
+    "print(squares)"
+   ],
+   "id": "f316e36ecfa9e63c"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "However, lets say I only wanted the squares of the even numbers. I could add a condition to the list comprehension like this:",
+   "id": "f4c28e448480ec5a"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "even_squares = [x**2 for x in range(10) if x % 2 == 0]\n",
+    "print(even_squares)\n",
+    "\n",
+    "odd_squares = [x**2 for x in range(10) if x % 2]\n",
+    "print(odd_squares)"
+   ],
+   "id": "1f1f4726034ef609"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "Wondering why the second one works lmao? In Python, any non-zero number is considered `True`, and zero is considered `False`. So, when we use `if x % 2`, it evaluates to `True` for odd numbers (which give a remainder of 1 when divided by 2) and `False` for even numbers (which give a remainder of 0). the list comprehension `[x**2 for x in range(10) if x % 2]` filters out the even numbers and only includes the squares of the odd numbers.\n",
+    "\n",
+    "### some other handy oneliners\n",
+    "\n",
+    "if you want to apply a single function to all of a list, or even just part of a list you can do something like this:\n",
+    "\n",
+    "`[expression for item in items if condition]`\n",
+    "\n",
+    "If you want an if/else clause, put that first in the list comprehension like this:\n",
+    "\n",
+    "`[expression if condition else other_expression for item in items]`\n",
+    "\n",
+    "here's a few examples:"
+   ],
+   "id": "eefafe9c0546c6bd"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "words = [\"hello\", \"world\", \"this\", \"is\", \"a\", \"test\"]\n",
+    "uppercased_words = [word.upper() for word in words]\n",
+    "print(\" \".join(uppercased_words))\n",
+    "\n",
+    "inputs = [\"five\", \"seventy two\", None, \"twenty three\", \"forty two\"]\n",
+    "inputs = [x for x in inputs if x is not None] # completely strip out the None values\n",
+    "\n",
+    "inputs = [\"five\", \"seventy two\", None, \"twenty three\", \"forty two\"]\n",
+    "inputs = [x if x is not None else \"invalid\" for x in inputs] # replace None values with invalid\n"
+   ],
+   "id": "4343bd7ddb8fcfb7"
   }
  ],
  "metadata": {