add some more classes things to functions_and_classes along with misc to other lessons, add solutions.py to write easily

Author: ProbablyComputingSquid

.idea/misc.xml

@@ -161,7 +161,7 @@
    "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",
+    "alex_yin_shopping_list = (\"violin\", \"robux for deepwoken\", \"hershey bar\", \"4 count monster energy\")\n",
     "\n",
     "combined_shopping_list = my_shopping_list + alex_yin_shopping_list\n",
     "print(\"Our shopping list:\", my_shopping_list)"
@@ -230,7 +230,7 @@
    "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) # 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",

Data_Structures.ipynb

@@ -1,8 +1,9 @@
 {
  "cells": [
   {
-   "metadata": {},
    "cell_type": "markdown",
+   "id": "718e27f5bfe0fec6",
+   "metadata": {},
    "source": [
     "# functions and classes\n",
     "\n",
@@ -12,16 +13,16 @@
     "\n",
     "each function can take in parameters, which are inputs that the function uses to perform its task. It can also return a value, which is the output of the function. This allows you to pass data into the function and get results back. you declare a function using the `def` keyword, followed by the function name and parentheses containing any parameters. The body of the function is indented below the definition. when the indentation goes back to its previous level, that means the definition of the function is over.\n",
     "take a look at a few examples below :"
-   ],
-   "id": "718e27f5bfe0fec6"
+   ]
   },
   {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "initial_id",
    "metadata": {
     "collapsed": true
    },
-   "cell_type": "code",
    "outputs": [],
-   "execution_count": null,
    "source": [
     "# the most basic function, some code under a header\n",
     "def print_hello():\n",
@@ -38,38 +39,27 @@
     "print_hello()\n",
     "greet() # put your name here!!\n",
     "exponentiate(9,3)"
-   ],
-   "id": "initial_id"
+   ]
   },
   {
-   "metadata": {},
    "cell_type": "markdown",
+   "id": "863527bde78d346d",
+   "metadata": {},
    "source": [
     "### practice exercise!! - greatest commmon divisor\n",
     "write a function that takes in two numbers and returns their greatest common divisor (gcd). the gcd is the largest number that divides both numbers without leaving a remainder. for example, the gcd of 12 and 15 is 3, because 3 is the largest number that will cleanly factor into 12 and 15.\n"
-   ],
-   "id": "863527bde78d346d"
+   ]
   },
   {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "ff295ae2bf57e0a3",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2025-08-21T16:36:49.522342Z",
      "start_time": "2025-08-21T16:36:49.517259Z"
     }
    },
-   "cell_type": "code",
-   "source": [
-    "## write your code for the gcd function here\n",
-    "\n",
-    "# your code here!!\n",
-    "\n",
-    "assert gcd(12, 15) == 3\n",
-    "assert gcd(54, 24) == 6\n",
-    "assert gcd(101, 10) == 1\n",
-    "assert gcd(100, 25) == 25\n",
-    "print(\"all unit tests are passing\")"
-   ],
-   "id": "ff295ae2bf57e0a3",
    "outputs": [
     {
      "name": "stdout",
@@ -80,34 +70,175 @@
      ]
     }
    ],
-   "execution_count": 2
+   "source": [
+    "## write your code for the gcd function here\n",
+    "\n",
+    "# your code here!!\n",
+    "\n",
+    "assert gcd(12, 15) == 3\n",
+    "assert gcd(54, 24) == 6\n",
+    "assert gcd(101, 10) == 1\n",
+    "assert gcd(100, 25) == 25\n",
+    "print(\"all unit tests are passing\")"
+   ]
   },
   {
-   "metadata": {},
    "cell_type": "markdown",
+   "id": "2f14750a7071b0c",
+   "metadata": {},
    "source": [
     "## recursive functions\n",
     "\n",
     "a recursive function is a function that calls itself. this is useful for problems that can be broken down into smaller subproblems, like calculating factorials or traversing trees. the key to a recursive function is to have a base case that stops the recursion, otherwise it will run indefinitely and cause a stack overflow error.\n",
     "take a look at the example below, which calculates a factorial, which is the product of each number smaller than itself to 1. for example, 5! = 5 * 4 * 3 * 2 * 1 = 120. the base case is when n is 0 or 1, in which case the factorial is 1. otherwise, the function calls itself with n - 1 until it reaches the base case."
-   ],
-   "id": "2f14750a7071b0c"
+   ]
   },
   {
-   "metadata": {},
    "cell_type": "code",
-   "outputs": [],
    "execution_count": null,
+   "id": "91a29a6bd518edd3",
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "def factorial (n):\n",
+    "def factorial(n):\n",
     "    if n == 0 or n == 1:  # base case\n",
     "        return 1\n",
     "    else:\n",
     "        return n * factorial(n - 1)  # recursive case\n",
     "\n",
     "print(factorial(6))"
-   ],
-   "id": "91a29a6bd518edd3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c89e89256f37f3c",
+   "metadata": {},
+   "source": [
+    "### practice exercise with recursion - sum of digits\n",
+    "\n",
+    "to practice writing recursive functions, write a function that takes in a non-zero positive integer and returns the sum of its digits. for example, if the number is 69420, 6 + 9 + 4 + 2 + 0 = 21, so the function should be returning 21. Here's a hint, try using logarithms or floor division `(a // b)` :3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cf1b20cd535d144a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# your code here!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c5802f40a4ceeab",
+   "metadata": {},
+   "source": [
+    "## type hinting\n",
+    "Sometimes, you will be writing functions for other people to use. Type hinting is a way to specify what kind of paramaters are accepted by a function, and will make a function easier to use and understand. It is not requires, but it is good practice to use type hinting when writing functions exported outside of your code.\n",
+    "For exampl, if you have a function that adds two integer outputs, you can specify that the function takes in two integers and returns an integer. This helps others understand how to properly use said function, and helps with debugging if the function is incorrectly used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d14af50469ef768a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def add_three_numbers(a: int, b: int, c: int) -> int:\n",
+    "    \"\"\"Adds three integers and returns the result.\"\"\"\n",
+    "    return a + b + c"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a43ee4a9a4eaed79",
+   "metadata": {},
+   "source": [
+    "You can also see that I added a string with three quotation marks in the first line of the function. This is called a docstring, and it is a way to document what a function does. Some IDEs will show this docstring when you hover over the function name, which is useful for understanding what a function does without having to read the function again every single time.\n",
+    "\n",
+    "The syntax for type hinting is to put a colon after the parameter name, followed by the type. The return type is specified after the closing parenthesis of the parameter list, followed by an arrow `->` and the return type. You can think of it like the function is pointing to the return type of the function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d86ef23ae0ea20",
+   "metadata": {},
+   "source": [
+    "## Classes!\n",
+    "\n",
+    "Classes are a type of data structure that allow you to create your own data types. These can bind data and functions together, allowing you to create objects with both properties and methods.\n",
+    "These are good for organizing your code and making it more modular. You can think of a class as a blueprint for an object, and an object is an instance of a class. Classes are the cornerstone of object-oriented programming (OOP). After using classes, you will find yourself saying \"OOPs, why did i make everything an object lmao\".\n",
+    "Classes are a good way to make data types in games, like weapons, items, or players. Or, if you're making something like a web app, you can use classes to represent users, posts, or comments. You can also use classes to represent more complex data structures, like trees or graphs.\n",
+    "\n",
+    "look at the code below for an example of a class that represents a student."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3514cd46e732de63",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Student:\n",
+    "    def __init__(self, name: str, age: int, major: str):\n",
+    "        self.name = name\n",
+    "        self.age = age\n",
+    "        self.major = major\n",
+    "\n",
+    "    def introduce(self):\n",
+    "        print(f\"Hello, my name is {self.name}, I'm {self.age} years old and I major in {self.major}.\")\n",
+    "    def birthday(self):\n",
+    "        self.age += 1\n",
+    "        print(f\"Happy birthday {self.name}! You are now {self.age} years old.\")\n",
+    "    def change_major(self, new_major):\n",
+    "        self.major = new_major\n",
+    "        print(f\"{self.name} has changed their major to {self.major}.\")\n",
+    "jeremy = Student(\"Jeremy\", 20, \"Computer Science\") # create an instance of the Student class\n",
+    "jeremy.introduce()\n",
+    "jeremy.birthday()\n",
+    "jeremy.change_major(\"Mathematics\")\n",
+    "jeremy.introduce()\n",
+    "# we can see here that even though the class methods take in the `self` parameter, we do not need to pass it when we call the methods.\n",
+    "\n",
+    "# now, try creating your own instance of the student class under your name!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b058e3873cc4a21d",
+   "metadata": {},
+   "source": [
+    "In this example, we have a Student class that represents a student. The `__init__` method is a special method, called the constructor. This gets called every time you create an object, hence its name. It initializes the object's properties, which are name, age, and major in this case. The `self` parameter refers to the instance of the class itself, and is used to access the object's properties and methods.\n",
+    "\n",
+    "Due to the peculiarities of Python, the `self` parameter is required in every method of a class, and is always the first parameter. However, when you call an object's method, you do not need to pass in the `self` parameter, as Python will do this automatically.\n",
+    "\n",
+    "### special class methods\n",
+    "\n",
+    "There are a few other special class methods that we can use to do things for us automatically. All of these special methods are denoted by a double underscore in their method name, like `__init__`. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "83e689a7",
+   "metadata": {},
+   "source": [
+    "## exercise - writing your own Car class\n",
+    "\n",
+    "yeah yeah you might say, making a car class is soooooo basic. but hey, it's a tried and true method of learning how to use classes. \n",
+    "\n",
+    "For your car, it's going to want to have a few properties. We're going to want to describe the `make` (brand, e.g. Honda), `model` (e.g. Corolla), `year`, `color`, and `mpg` (miles per gallon). These should all go in the constructor. Make sure to initialize an extra property called `gallons`, which is the gallons left in tank, to zero. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4331927360a7115",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

Functions_and_Classes.ipynb

@@ -13,8 +13,7 @@
     "\n",
     "## Your First Python Script\n",
     "\n",
-    "For now, let's start with the basics. The first \"tool\" under your toolbelt will be printing output to the console. While you will not find a lot of command-line applications for popular use written in Python (except tools for other developers!), printing is still an essential tool for debugging your programs and in the first stages of development. To print to the console, type (or run the following code cell):\n",
-    "\n"
+    "For now, let's start with the basics. The first \"tool\" under your toolbelt will be printing output to the console. While you will not find a lot of command-line applications for popular use written in Python (except tools for other developers!), printing is still an essential tool for debugging your programs and in the first stages of development. To print to the console, type (or run the following code cell):\n"
    ],
    "id": "5cfc0bb57c4e4fb9"
   },
@@ -46,7 +45,7 @@
    "metadata": {},
    "cell_type": "markdown",
    "source": [
-    "## Python syntax\n",
+    "## 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:"
    ],

Intro_To_Python.ipynb

@@ -0,0 +1,8 @@
+TODO:
+
+- dictionaries about different terms
+- add more "fix this code" examples
+- step daily challenges
+- _write_ daily challenges
+- seriousness, serious topics
+- make sure that its light

TODO.md

@@ -135,13 +135,25 @@
    ],
    "id": "d76d86b3a3a9271f"
   },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "## sum of digits using recursion",
+   "id": "3b269a1989dbb936"
+  },
   {
    "metadata": {},
    "cell_type": "code",
    "outputs": [],
    "execution_count": null,
-   "source": "",
-   "id": "134824d4f7570878"
+   "source": [
+    "def sum_digits(n):\n",
+    "    if n == 0:\n",
+    "        return 0\n",
+    "    else:\n",
+    "        return n % 10 + sum_digits(n // 10)"
+   ],
+   "id": "fa1fbdb2a45856ed"
   }
  ],
  "metadata": {

solutions.ipynb

@@ -0,0 +1,31 @@
+class Car:
+    def __init__(self, make, model, year, color, mpg):
+        self.make = make
+        self.model = model
+        self.year = year
+        self.mpg = mpg
+        self.color = color
+        self.fuel_level = 0.0  # in gallons
+
+    def __str__(self):
+        return f"{self.year} {self.make} {self.model}. Fuel level: {self.fuel_level} gallons. Gets {self.mpg} miles per gallon."
+    def add_fuel(self, gallons):
+        self.fuel_level += gallons
+    def check_tank():
+        return gallons
+    def drive(self, miles) -> float:
+        possible_miles = self.fuel_level * self.mpg
+        if miles > possible_miles:
+            miles = possible_miles
+        self.fuel_level -= miles / self.mpg
+        return miles
+    def repaint(self, color):
+        self.color = color
+
+
+ol_reliable = Car("Toyota", "Sienna", 2017, "Silver", 30.3)
+ol_reliable.add_fuel(12.3)
+print(f"There are {ol_reliable.check_tank()} gallons left in the {ol_reliable}")
+print(f"Let's try to drive 100 miles! We drove {drive(1000)} miles, and now there is {ol_reliable.check_tank()} gallons left in the tank.")
+ol_reliable.repaint("Lime Green")
+print(f"We've repainted our car! {ol_reliable}")