rstructure first lesson to be wayy simpler for beginners

Author: ProbablyComputingSquid

Intro_To_Python.ipynb

@@ -58,13 +58,33 @@
    "source": "print(\"I'm lazy and can't change this small block of text!\")",
    "id": "1f40c56b228dc899"
   },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Now try printing out something of your own choice, like your name, and your favorite ice cream flavor. Print these out on different print statements and see what happens.",
+   "id": "948e4f11d356ff99"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "# try printing it out here",
+   "id": "f491bccb1ea66088"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "You're seeing this because Python automatically adds a new line after every print statement. You'll learn how to change this in a later lesson.",
+   "id": "21b19b44eb850e8f"
+  },
   {
    "metadata": {},
    "cell_type": "markdown",
    "source": [
     "## Python Syntax\n",
     "\n",
-    "As mentioned earlier, Python relies strongly on indentation and whitespace to define code blocks. For an example, we will be using `if` statements, which we will be discussing in more detail later. An `if` statement is a conditional statement that allows you to execute a block of code only if a certain condition is met. Here is an example of an `if` statement in Python:"
+    "As mentioned earlier, Python relies strongly on indentation and whitespace to define code blocks instead of semicolons and curly braces. For an example, we will be using `if` statements, which we will be discussing in more detail later. An `if` statement is a conditional statement that allows you to execute a block of code only if a certain condition is met. Here is an example of an `if` statement in Python:"
    ],
    "id": "b1031d38b70e2065"
   },
@@ -74,8 +94,8 @@
    "outputs": [],
    "execution_count": null,
    "source": [
-    "if 2 + 2 > 3:\n",
-    "    print(\"1 + 1 is greater than 3\")"
+    "if 2 + 2 > 3: # if 2 plus 2 is greater than 3\n",
+    "    print(\"2 + 2 is greater than 3\")"
    ],
    "id": "54b20809fb8db9df"
   },
@@ -117,6 +137,12 @@
    ],
    "id": "8e23c5c5a5850055"
   },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Now, write an if statement that checks if 3 + 9 is greater than 7, and if so, print out something. Afterwards, print out another equation. Make sure to indent it correctly!",
+   "id": "d89d2f8bff2057b3"
+  },
   {
    "metadata": {},
    "cell_type": "markdown",
@@ -233,231 +259,115 @@
    "metadata": {},
    "cell_type": "markdown",
    "source": [
-    "### Variable Scoping\n",
-    "\n",
-    "Variables have a thing called \"scope\" which determines where the variable can be accessed in your code. In Python, there are two main types of scope: global and local.\n",
-    "- **Global variables** are defined outside any function and can be accessed from anywhere in your code. They are created by simply assigning a value to a variable name at the top level of your script. You can also use the `global` keyword inside a function to modify a global variable.\n",
-    "- **Local variables** are defined inside a function and can only be accessed within that function. They are created by assigning a value to a variable name inside a function.\n",
-    "\n",
-    "Sometimes, this can lead to confusion, especially if you have a global variable with the same name as a local variable. In that case, the local variable will take precedence over the global variable within the function. This is called *shadowing* and should be avoided at all costs because it leads to very painful debugging.\n",
-    "\n",
-    "The reason why scoping exists is to prevent naming conflicts and to ensure that variables are only accessible where they are needed and make sense to be used.\n",
+    "## Comments in Python\n",
     "\n",
-    "run the following code blocks to see examples of variable scoping"
+    "Comments are like adding notes to your code, just like how my English teacher marks up my essays for grammar mistakes! They are not executed by the interpreter, but they can be very useful for explaining what your code does or for leaving reminders for yourself. You can also \"comment out\" code that you don't want to run.\n",
+    "In Python, you can create a comment by using the `#` symbol. For example:"
    ],
-   "id": "843ff65ed733de10"
+   "id": "eedd4c11032bb426"
   },
   {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2025-08-20T14:13:02.782326Z",
-     "start_time": "2025-08-20T14:13:02.777681Z"
-    }
-   },
+   "metadata": {},
    "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
    "source": [
-    "x = 10  # Global variable, because it's declared at the highest level (least indentation) of the script\n",
-    "def function():\n",
-    "    x = 5  # Local variable\n",
-    "    print(\"Inside the function, x =\", x)\n",
-    "function()\n",
-    "print(\"Outside the function, x =\", x)  # This will print the global variable x"
-   ],
-   "id": "ef1341d373acff81",
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Inside the function, x = 5\n",
-      "Outside the function, x = 10\n"
-     ]
-    }
+    "# The following code prints out 2\n",
+    "print (1 + 1)"
    ],
-   "execution_count": 1
+   "id": "3f44a0cb05c950dd"
   },
   {
    "metadata": {},
-   "cell_type": "markdown",
-   "source": "However, if we wanted to modify the global variable `x` inside a function, we would need to use the `global` keyword. This tells Python that we want to use the global variable instead of creating a new local variable with the same name.\n",
-   "id": "4381133f3eae8cb1"
-  },
-  {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2025-08-20T14:29:37.745033Z",
-     "start_time": "2025-08-20T14:29:37.738420Z"
-    }
-   },
    "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
    "source": [
-    "n = 3.14\n",
-    "def modify_global():\n",
-    "    global n  # This tells Python that we want to use the global variable n\n",
-    "    n = 2.71  # This modifies the global variable n\n",
-    "    print(\"Inside the function, n =\", n)\n",
-    "modify_global()\n",
-    "print(\"Outside the function, n =\", n)"
-   ],
-   "id": "c2fbbd0b8bd5b4fb",
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Inside the function, n = 2.71\n",
-      "Outside the function, n = 2.71\n"
-     ]
-    }
+    "# try commenting out the line below by adding a `#` at the beginning of the line\n",
+    "# print(\"This line is commented out and will not be executed.\")\n",
+    "print(\"Comment out this line!\")"
    ],
-   "execution_count": 2
-  },
-  {
-   "metadata": {},
-   "cell_type": "markdown",
-   "source": "### Types in Python",
-   "id": "a9646bc085e9b372"
+   "id": "b18a664c7e3bdf06"
   },
   {
    "metadata": {},
    "cell_type": "markdown",
    "source": [
-    "Here's a list of the different types a variable can be in python. Each type has its own characteristics and uses, so it's important to understand them when writing Python code.\n",
-    "- Text Type: `str` (string, a sequence of characters)\n",
-    "- Numeric Types: `int`, `float`, `complex` (whole numbers, decimal numbers, and complex numbers)\n",
-    "- Sequence Types: `list`, `tuple`, `range` (ordered collections of items)\n",
-    "  - `list`: mutable (can be changed), ordered collection of items\n",
-    "  - `tuple`: immutable (cannot be changed), ordered collection of items\n",
-    "  - `range`: represents a sequence of numbers, often used in loops\n",
-    "- Mapping Type: `dict` (key-value pairs)\n",
-    "- Set Types: `set`, `frozenset` (unordered collections of unique items)\n",
-    "  - `set`: mutable (can be changed), unordered collection of unique items\n",
-    "  - `frozenset`: immutable (cannot be changed), unordered collection of unique items\n",
-    "- Boolean Type: `bool` (`True`/`False`)\n",
-    "- Binary Types: `bytes`, `bytearray`, `memoryview` (we will not be covering these)\n",
-    "- None Type: `NoneType` (`None`, used to represent the absence of a value)\n",
+    "## Math in Python\n",
+    "Python can be used as a calculator, and it supports all the basic arithmetic operations like addition, subtraction, multiplication, and division.\n",
+    "Most of the operation are the same as normal math. However, there isn't a division sign on the standard keyboard, so we use one forward slash (`/`) for division, two asterisks for exponentiating (because you're multiplying multiple times).\n",
+    "\n",
     "\n",
-    "If you ever want to check the type of a variable, you can use the `type()` function. For example:"
+    "Here's the list of every operator you'll need to ever use."
    ],
-   "id": "34cedd8a8575b74b"
+   "id": "7a7153dec817dae3"
   },
   {
    "metadata": {},
    "cell_type": "code",
    "outputs": [],
    "execution_count": null,
    "source": [
-    "print(type(5))  # This will print <class 'int'>\n",
-    "print(type(\"3.14\"))  # This will print <class 'str'>"
-   ],
-   "id": "84cf565e5b64f5ab"
-  },
-  {
-   "metadata": {},
-   "cell_type": "markdown",
-   "source": [
-    "If you want to change the type of a variable, you can use type conversion functions like `int()`, `float()`, and `str()`. However, not all conversions will work. You cannot turn the sentence `\"Reggie the Regent\"` into a number (although it would probably be 1, because West is the Best).\n",
-    "For example of type conversion, you can convert a string to an integer like this:"
-   ],
-   "id": "e63d1426ca778288"
-  },
-  {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2025-08-14T16:46:31.590578Z",
-     "start_time": "2025-08-14T16:46:31.586635Z"
-    }
-   },
-   "cell_type": "code",
-   "source": [
-    "print(int(\"5\"))  # This will print 5 as an integer\n",
-    "print(type(int(\"5\"))) # This will print <class 'type'>, which is the type of the int class itself"
-   ],
-   "id": "29b4d8bb4505105f",
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "5\n",
-      "<class 'int'>\n"
-     ]
-    }
+    "print(5 + 3)  # Addition\n",
+    "print(5 - 3)  # Subtraction\n",
+    "print(5 * 3)  # Multiplication\n",
+    "print(5 / 3)  # Division\n",
+    "print(5 // 3) # Floor Division\n",
+    "print(5 % 3)  # Modulus\n",
+    "print(5 ** 3) # Exponentiation (raising to the power of)\n",
+    "print(5 + 3 * 2)  # Order of operations"
    ],
-   "execution_count": 4
+   "id": "a997cca30aa3c69e"
   },
   {
    "metadata": {},
    "cell_type": "markdown",
-   "source": [
-    "## Comments in Python\n",
-    "\n",
-    "Comments are like adding notes to your code, just like how my English teacher marks up my essays for grammar mistakes! They are not executed by the interpreter, but they can be very useful for explaining what your code does or for leaving reminders for yourself. You can also \"comment out\" code that you don't want to run.\n",
-    "In Python, you can create a comment by using the `#` symbol. For example:"
-   ],
-   "id": "eedd4c11032bb426"
+   "source": "Let's try out some basic math! Try adding 6 and 7 and printing out the result.",
+   "id": "d37d0a73164529a7"
   },
   {
    "metadata": {},
    "cell_type": "code",
    "outputs": [],
    "execution_count": null,
-   "source": [
-    "# The following code prints out 2\n",
-    "print (1 + 1)"
-   ],
-   "id": "3f44a0cb05c950dd"
+   "source": "# write your code here\n",
+   "id": "4590c080d86514cb"
   },
   {
    "metadata": {},
-   "cell_type": "code",
-   "outputs": [],
-   "execution_count": null,
-   "source": [
-    "# try commenting out the line below by adding a `#` at the beginning of the line\n",
-    "# print(\"This line is commented out and will not be executed.\")\n",
-    "print(\"Comment out this line!\")"
-   ],
-   "id": "b18a664c7e3bdf06"
+   "cell_type": "markdown",
+   "source": "Then, try multiplying 62 and 81 and printing it out.",
+   "id": "e1a59fe53e17a797"
   },
   {
    "metadata": {},
    "cell_type": "code",
    "outputs": [],
    "execution_count": null,
-   "source": "",
-   "id": "f7c25dd39f9be227"
+   "source": "# multiply!\n",
+   "id": "b8d81989b035fbfc"
   },
   {
    "metadata": {},
    "cell_type": "markdown",
-   "source": [
-    "## Math in Python\n",
-    "Python can be used as a calculator, and it supports all the basic arithmetic operations like addition, subtraction, multiplication, and division. Here are some examples:"
-   ],
-   "id": "7a7153dec817dae3"
+   "source": "Now, try adding 2 and 8, multiplying that by 9, and dividing it all by 3. Print that out.",
+   "id": "ddd1cdc66e99ab3b"
   },
   {
    "metadata": {},
    "cell_type": "code",
    "outputs": [],
    "execution_count": null,
-   "source": [
-    "print(5 + 3)  # Addition\n",
-    "print(5 - 3)  # Subtraction\n",
-    "print(5 * 3)  # Multiplication\n",
-    "print(5 / 3)  # Division\n",
-    "print(5 // 3) # Floor Division\n",
-    "print(5 % 3)  # Modulus\n",
-    "print(5 ** 3) # Exponentiation\n",
-    "print(5 + 3 * 2)  # Order of operations"
-   ],
-   "id": "a997cca30aa3c69e"
+   "source": "# here!\n",
+   "id": "96d57b3c206187ad"
   },
   {
    "metadata": {},
    "cell_type": "markdown",
    "source": [
+    "\n",
+    "\n",
+    "\n",
     "Python also has shorthand operators that allow you to perform an operation and assign the result to a variable in a single step. For example, instead of writing `x = x + 5`, you can write `x += 5`. This shorthand also works with strings, where applicable.\n",
     "Here are some examples of shorthand operators:"
    ],
@@ -486,10 +396,33 @@
    "source": [
     "## Practice - Ask a user for their info, and format it\n",
     "\n",
-    "Let's put all of this together and create a simple \"Registration\" program that asks the user for their name, age, and password, and then prints out a formatted sentence with that information. You can use the `input()` function to get input from the user, and then use string formatting to create the final output. We have little under our toolbelt yet, so let's keep it simple.  "
+    "Let's put all of this together and create a simple \"Registration\" program that asks the user for their name, age, and date of enrollment, and then prints out a formatted sentence with that information. assign these valuables to variables that you create, and print them all out.\n",
+    "\n",
+    "At the end, you should have a short code snippet which should neatly print the users name, age, and password. We have little under our toolbelt right now, so let's keep it simple."
    ],
    "id": "3230f4039fd83fb7"
   },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-09-19T01:33:43.976676Z",
+     "start_time": "2025-09-19T01:33:40.533750Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "",
+   "id": "cbe0fa25649c85c3",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "joe\n"
+     ]
+    }
+   ],
+   "execution_count": 1
+  },
   {
    "metadata": {},
    "cell_type": "markdown",