HW7 with py, testpy, and two txt

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+geckodriver.log
+.gitignore
+*.pyc
+*/__pycache__

.vscode/launch.json

@@ -7,6 +7,13 @@
             "program": "simulation/SimulationRunner.py",
             "justMyCode": true,
             "args": "./HotdogSimulation.py"
+        },
+        {
+            "name": "Python: File",
+            "type": "python",
+            "request": "launch",
+            "program": "${file}",
+            "justMyCode": true
         }
     ]
 }

Leon_Submissions/Homework1.py

@@ -0,0 +1,28 @@
+# Question 1: 
+# The international standard for floating-point representation is 
+# called the "IEEE 754 Standard for Floating-Point Arithmetic."
+
+# Question 2: 
+# 32-bit and 64-bit formats are the most widely used ones in practice.
+
+# Question 3: 
+# My computer supports all these formats
+import numpy as np
+
+supported_formats = np.finfo(np.float32).bits, np.finfo(np.float64).bits
+print(f"Your computer supports the following floating-point formats: {supported_formats}")
+
+
+# Question 4:
+# Using the Pandas multiplication operator (df['Number1'] * df['Number2'])
+# , the result is automatically converted to a floating-point data type. 
+# On the other hand, when I multiply the numbers using the normal Python
+# multiplication operator (num1 * num2), the result remains an integer 
+# data type.
+
+# Question 5:
+# The size of a floating-point number in memory is primarily determined 
+# by the data type and not the actual value it represents. So the size 
+# of a Python floating-point number does not change as it gets larger.
+import sys
+print(sys.getsizeof(70))

Leon_Submissions/Homework2.py

@@ -0,0 +1,30 @@
+# Question 7:
+# 1. Strings in Python are sequences of Unicode characters, while bytes 
+# are sequences of raw binary data.
+# 2. Strings in Python are immutable, bytes objects are mutable 
+# 3. Strings in Python are encoded using a specific character encoding, 
+# bytes objects do not have an inherent encoding and represent raw binary 
+# data.
+import sys
+
+string_example = "Hello"
+bytes_example = b"Hello"
+
+string_size = sys.getsizeof(string_example)
+bytes_size = sys.getsizeof(bytes_example)
+
+print("Size of string:", string_size)
+print("Size of bytes:", bytes_size)
+
+# Emojis are represented using Unicode characters, which require more 
+# bytes to store compared to ASCII characters. Therefore, if you have 
+# a string that contains emojis, its size will be larger than a string 
+# without emojis. 
+
+def print_string_as_numbers(input_string):
+    for char in input_string:
+        print(ord(char), end=' ')
+
+# Example usage
+input_string = "Hello, World!"
+print_string_as_numbers(input_string)

Leon_Submissions/Homework3.py

@@ -0,0 +1,36 @@
+# Question 8: It assumes that the CSV file being read 
+# (tomato_sales_error.csv) has a column named "Tomato_Sales." 
+# If the column doesn't exist in the CSV file or if there is an issue 
+# with the file itself, an error will be raised.
+
+# Question 9: 
+import pandas as pd
+
+def read_tomato_sales(file_name):
+    data = pd.read_csv(file_name)
+
+    # Ensure required columns exist
+    required_columns = ["Store", "Region", "Tomato_Sales"]
+    missing_columns = set(required_columns) - set(data.columns)
+    if missing_columns:
+        raise ValueError(f"Invalid CSV format: Missing columns: {', '.join(missing_columns)}")
+
+    # Validate Tomato_Sales column
+    tomato_sales = data["Tomato_Sales"]
+    if not tomato_sales.dtype == int and not tomato_sales.dtype == float:
+        raise ValueError("Invalid CSV format: 'Tomato_Sales' column must contain numerical values.")
+
+    # Calculate total tomato sales
+    total_sales = tomato_sales.sum()
+    print(f"Total tomato sales: {total_sales}")
+
+# Question 10: Bytes represent raw binary data, while strings represent 
+# textual data. Using bytes allows us to handle various character 
+# encodings. By working with bytes, we can ensure that the data remains in 
+# its raw encoded form, allowing for accurate handling of different 
+# encodings.
+
+# In the interactive Python REPL (Read-Eval-Print Loop), the "_" variable 
+# is a special variable that is automatically assigned the result of the 
+# last expression evaluated. The type of the "_" variable reflects the 
+# type of the last expression evaluated in the REPL.

Leon_Submissions/leon.py

@@ -0,0 +1 @@
+print('Hi')

Scott_Submissions/A_BrainTeaser_byScott.py

@@ -0,0 +1,100 @@
+# A quick brain teaser
+print('What has a head and a tail but no body?')
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+# A coin

Scott_Submissions/BoundedInt.py

@@ -0,0 +1,46 @@
+class BoundedInt():
+    def __init__(self, i, min, max):
+        """
+        Create a bounded integer.
+
+        Args:
+            i (int): The initial value of the integer.
+            min (int): The minimum value of the integer.
+            max (int): The maximum value of the integer.
+        """
+        self.i = i
+        self.min = min
+        self.max = max
+    
+    def __int__(self):
+        """ 
+        Convert the bounded integer to int.
+
+        Returns:
+            int: The value of the bounded integer.
+        """
+        return self.i
+
+    def __add__(self, other):
+        if isinstance(other, BoundedInt):
+            if self.i + other.i > self.max:
+                raise ValueError("Addition exceeds maximum value")
+            return BoundedInt(self.i + other.i, self.min, self.max)
+        elif isinstance(other, int):
+            if self.i + other > self.max:
+                raise ValueError("Addition exceeds maximum value")
+            return BoundedInt(self.i + other, self.min, self.max)
+        else:
+            raise TypeError("Unsupported operand type")
+
+    def __sub__(self, other):
+        if isinstance(other, BoundedInt):
+            if self.i - other.i < self.min:
+                raise ValueError("Subtraction exceeds minimum value")
+            return BoundedInt(self.i - other.i, self.min, self.max)
+        elif isinstance(other, int):
+            if self.i - other < self.min:
+                raise ValueError("Subtraction exceeds minimum value")
+            return BoundedInt(self.i - other, self.min, self.max)
+        else:
+            raise TypeError("Unsupported operand type")

Scott_Submissions/BoundedIntTester.py

@@ -0,0 +1,67 @@
+from BoundedInt import BoundedInt
+
+class BoundedIntTester:
+    def __init__(self):
+        pass
+
+    def test1(self):
+        bi1 = BoundedInt(0xdeadbeef, min = (0xdeadbeef-1), max = (0xdeadbeef+1))
+        if int(bi1) == 0xdeadbeef:
+            print(f"✅ Test 1 passed!")
+        else:
+            print(f"❌ Test 1 failed, int(bi1) = {int(bi1)}, expected 0xdeadbeef")
+
+    def test2(self):
+        """
+        Test that addition works for two BoundedInts, and throws an error if the bounds are exceeded.
+        """
+        bi2 = BoundedInt(1, min = 0, max = 1)
+        bi3 = BoundedInt(1, min = 0, max = 1)
+        try:
+            bi4 = bi2 + bi3 # 1 + 1 = 2, which is more than max = 1
+            print(f"❌ Test 2 failed!")
+        except ValueError as err:
+            print(f"✅ Test 2 passed!")
+
+    def test3(self):
+        """
+        Test that addition works for two BoundedInts, and throws an error if the bounds are exceeded.
+        """
+        bi4 = BoundedInt(1, min = 0, max = 1)
+        bi5 = BoundedInt(2, min = 0, max = -1)
+        try:
+            bi6 = bi4 - bi5 # 1 - 2 = (-1), which is less than min = 0
+            print(f"❌ Test 3 failed!")
+        except ValueError as err:
+            print(f"✅ Test 3 passed!")
+
+    def test4(self):
+        """
+        Test that addition works for a BoundedInt and a regular int, and throws an error if the bounds are exceeded.
+        """
+        bi7 = BoundedInt(1, min = 0, max = 1)
+        bi8 = 2
+        try:
+            bi9 = bi7 + bi8
+            print(f"❌ Test 4 failed!")
+        except ValueError as err:
+            print(f"✅ Test 4 passed!")
+
+    def test5(self):
+        """
+        Test that subtraction works for a BoundedInt and a regular int, and throws an error if the bounds are exceeded.
+        """
+        bi10 = BoundedInt(1, min = 0, max = 1)
+        bi11 = 2
+        try:
+            bi12 = bi10 - 11
+            print(f"❌ Test 5 failed!")
+        except ValueError as err:
+            print(f"✅ Test 5 passed!")
+
+tester = BoundedIntTester()
+tester.test1()
+tester.test2()
+tester.test3()
+tester.test4()
+tester.test5()

Scott_Submissions/Floating_Point_Formats.py

@@ -0,0 +1,2 @@
+import sys
+print(sys.float_info)

Scott_Submissions/HW1_Scott.rtf

@@ -0,0 +1,37 @@
+{\rtf1\ansi\ansicpg1252\cocoartf2580
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fnil\fcharset0 HelveticaNeue;\f1\fnil\fcharset0 Menlo-Regular;}
+{\colortbl;\red255\green255\blue255;\red0\green0\blue0;\red0\green0\blue0;}
+{\*\expandedcolortbl;;\cssrgb\c0\c0\c0\c87059;\cssrgb\c0\c0\c0\c3922;}
+\margl1440\margr1440\vieww11520\viewh8400\viewkind0
+\deftab720
+\pard\pardeftab720\partightenfactor0
+
+\f0\fs32 \cf2 \expnd0\expndtw0\kerning0
+1. What is the name of the international standard for floating-point representation?\
+	\
+	The IEEE-754 standard describes floating-point formats, a way to represent real numbers in hardware.\
+\
+\
+2. How many bits are the floating point numbers defined by that standard allowed to be?\
+\
+	The floating-point numbers defined by the international standard can be allowed to be of different lengths depending on the specific interchange format. For binary interchange, the formats can be 16 bits, 32 bits, 64 bits, and any multiple of 32 bits \uc0\u8805  128. For decimal interchange, the formats can be any multiple of 32 bits.\
+\
+\
+3. Does your computer support all those formats? Can you think of an easy way to check with only one line of Python?\
+\
+import sys\
+print(sys.float_info)\
+\
+scott@MacBook-Pro-6 python-bootcamp % python3 Floating_Point_Formats.py \
+sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)\
+\
+\
+\pard\pardeftab720\sa320\partightenfactor0
+\cf2 4. Why doesn't this code give the same answers to the two multiplications?\
+	Because they are different operations. The normal Python multiplication operator will multiply two numbers together and return the product. The Pandas multiplication operator, on the other hand, performs element-wise multiplication on the corresponding columns in a DataFrame. In other words, it multiplies the first element in the first column with the first element in the second column, the second element in the first column with the second element in the second column, and so on. \
+	Floating-point arithmetic has a limited precision due to the finite number of bits used to represent floating-point numbers in binary format. This can lead to rounding errors and loss of precision in arithmetic operations, particularly with very large or very small numbers.\
+\
+5. You can use 
+\f1\fs27\fsmilli13600 \cf2 \cb3 sys.getsizeof
+\f0\fs32 \cf2 \cb1  to see how large a Python object is. Does the size of a Python floating-point number change as it gets larger? Why or why not?\
+	The size of a Python floating-point number does not change as it gets larger. This is because Python uses a fixed number of bytes to represent floating-point numbers, regardless of their value.}

Scott_Submissions/HW2.py

@@ -0,0 +1,54 @@
+# Name three practical differences between Python strings and bytes. 
+# Using sys.getsizeof, see how the sizes may be different. 
+# Do emoji change this answer?
+
+# Encoding
+# Strings are created using Unicode character points. 
+# While bytes are used to represent actual bytes in memory, which can be encoded using ASCII or UTF-8.
+
+# Usage
+# Strings are usually used to represent text.
+# While bytes are used to represent binary data.
+
+# Memory Size 
+# Strings take up more memory than bytes, because they are Unicode-based and can contain any character.
+# While bytes are limited to binary data.
+
+
+print("---------------------------------------------")
+print("This is the Memory Size test print out:")
+
+
+import sys
+
+my_string = "Hello, world!"
+my_bytes = b'\x48\x65\x6c\x6c'
+
+print(sys.getsizeof(my_string)) # Prints 62
+print(sys.getsizeof(my_bytes)) # Prints 37
+
+print()
+print('Test the emoji:')
+
+x = 'pizza' # Prints 54
+y = b'pizza' # Prints 38
+z = '🍕' #Prints 80
+
+print(sys.getsizeof(x))
+print(sys.getsizeof(y))
+print(sys.getsizeof(z))
+
+
+print("---------------------------------------------")
+
+print("This is the String to Sequence of Numbers print out:")
+
+def String_to_SequenceofNumbers():
+    my_string = input("Enter a string: ")
+    num_sequence = [ord(c) for c in my_string]
+    print(num_sequence)
+
+if __name__ == "__main__":
+    String_to_SequenceofNumbers()
+
+print("---------------------------------------------")

Scott_Submissions/HW3.py

@@ -0,0 +1,63 @@
+# 1. Why does ord("😀") give a different number than 0xf09f9880, which is what the hexdump of the same character yields?
+# 
+#   The ord() function returns the Unicode code point of a character as an integer, which is 128512 for the smiley face.
+#   However, the hexdump command, returns the UTF-8 encoding of character.
+#   The hexadecimal representation of 128512 is 0x1F600.
+#   The UTF-8 encoding of the "😀" character is represented by the sequence of bytes F0 9F 98 80 in hexadecimal.
+#   UTF-8 is one of the encoding schemes used to represent Unicode characters as binary data.
+#
+#
+# 8. Hypothetical Situation: If the dataframe is not formatted or cleaned, while the column storing the tomoto sales data isn't named exactly same as 'Tomato_Sales'
+#       It will raise a KeyError instead.
+#
+#
+# 9. The solution of the hypothetical situation from my question 8:
+
+def read_tomato_sales(file_name):
+    data = pd.read_csv(file_name)
+    if not pd.api.types.is_numeric_dtype(data["Tomato_Sales"]):
+        raise TypeError("Tomato_Sales column should contain only numeric values")
+    total_sales = data.iloc[:, -1].sum()  # This is the key
+    print(f"Total tomato sales: {total_sales}")
+# read_tomato_sales("tomato_sales_error.csv")
+
+
+# 10. Different human languages can use various character encodings such as UTF-8, UTF-16, or ASCII. 
+#   While using bytes, you can work with raw data without worrying about specific encodings. 
+#   This allows us to avoid encoding-related errors and ensures compatibility across different language texts.
+
+def encode_decode_data():
+    print('-' * 20)
+    data = input("Enter a sentence using any language: ")
+    print('-' * 20)
+    print("The sentence you entered is: {}".format(data))
+    print('-' * 20)
+    encoded_data = data.encode('utf-8')
+    print("This sentence after encoded is: {}".format(encoded_data))
+    print('-' * 20)
+    byte_length = len(encoded_data)
+    print("The byte length of this sentence is: {}".format(byte_length))
+    print('-' * 20)
+    decoded_data = encoded_data.decode()
+    print("This sentence after decoded is: {}".format(decoded_data))
+    print('-' * 20)
+
+if __name__ == "__main__":
+    run_function = 'function1'
+
+    if run_function == 'function1':
+        encode_decode_data()
+    elif run_function == 'function2':
+        read_tomato_sales(file_name)
+
+
+# 2.5. REPL stands for Read-Eval-Print Loop. 
+#   A REPL is an interactive programming environment that allows you to read input, evaluate expressions or statements, print output, and repeat the process. 
+#   It provides a quick way to experiment with code, test small snippets, and get immediate feedback. 
+#   The Python REPL allows you to interactively enter Python code and see the results immediately without needing to write a full script and execute it separately.
+
+
+# 3. The '_' is a convention that holds the value of the last printed expression or the result of the last evaluated expression. 
+#   The actual type of the "_" variable depends on the value assigned to it.
+
+

Scott_Submissions/HW4.py

@@ -0,0 +1,147 @@
+# 1. Annotate the following python expressions with the specific types of each literal, as well as the overall return value:
+# i = 3
+# f = 3.0
+# c = 3+3j
+# b = b'abcdefg'
+# s = 'abcdefg'
+# s = "abcdefg"
+
+i = 3
+f = 3.0
+c = 3+3j
+b = b'abcdefg'
+s1 = 'abcdefg'
+s2 = "abcdefg"
+
+def check_the_datatype():
+    print()
+    print('This is the answer for Q1:')
+    print()
+    variable_names = ['i', 'f', 'c', 'b', 's1', 's2']
+    data_list = [i, f, c, b, s1, s2]
+    for variable, data in zip(variable_names, data_list):
+        print("The type of this assigned value {} = {} is: {}".format(variable, data, type(data).__name__))
+
+
+
+# 2. For each of the types string, bytestring, integer, floating point, and imaginary literals, 
+#   construct a 5x5 table showing what happens when the character "0" or number 0 is compared to each other type
+
+from tabulate import tabulate
+from termcolor import colored
+
+from tabulate import tabulate
+from termcolor import colored
+
+def tablesQ2():
+    print()
+    print('-' * 20)
+    print()
+    print('This is the answer for Q2:')
+    print()
+    types = ["String", "Byte String", "Integer", "Floating Point", "Imaginary"]
+    literals = ['"0"', 'b"0"', '0', '0.0', '0j']
+
+    table_data = []
+
+    for type_ in types:
+        
+        row = [type_]
+
+        for literal in literals:
+            
+            if type_ == "String":
+                result = literal == '"0"'
+            elif type_ == "Byte String":
+                result = literal.encode() == b"0"
+            elif type_ == "Integer":
+                try:
+                    result = int(literal) == 0
+                except ValueError:
+                    result = False
+            elif type_ == "Floating Point":
+                try:
+                    result = float(literal) == 0.0
+                except ValueError:
+                    result = False
+            elif type_ == "Imaginary":
+                result = literal.replace('j', 'j0') == "0j"
+            color = 'green' if result else 'red'
+            colored_result = colored(result, color)
+            row.append(colored_result)
+
+        table_data.append(row)
+
+    table = tabulate(table_data, headers=["Type"] + literals, tablefmt="pipe")
+    print(table)
+
+
+
+# 3. Now do the same thing for the + and == operators for each pair of types in two other 5x5 tables.
+
+def tablesQ3():
+    print()
+    print('-' * 20)
+    print()
+    print('This is the answer for Q3:')
+    print()
+
+    operators = ["+", "=="]
+    types = ["str", "bytes", "int", "float", "complex"]
+    literals = ['"0"', 'b"0"', '0', '0.0', '0+0j']
+
+    for operator in operators:
+        print(f"Table for {operator} Operator:")
+        table_data = []
+
+        for type_ in types:
+            row = [type_]
+
+            for literal in literals:
+                try:
+                    result = eval(f"{literal} {operator} {type_}({literal})")
+                    color = 'green'
+                except TypeError:
+                    result = False
+                    color = 'red'
+
+                colored_result = colored(result, color)
+                row.append(colored_result)
+
+            table_data.append(row)
+
+        table = tabulate(table_data, headers=["Type"] + literals, tablefmt="pipe")
+        print(table)
+        print()
+
+
+
+# Write a small program that uses the AST module to open the lexer/parser example, and dumps the resulting AST. 
+# See if there are any arguments to the parse method which make the output easier to read.
+
+# By default, ast.dump() prints the AST in a compact format. 
+# However, there are two optional arguments that can enhance the readability:
+# indent: Specifies the number of spaces to use for indentation. Setting it to a positive integer (e.g., 4) indents each level of the AST by that amount.
+# annotate_fields: When set to True, adds field names as comments to the output, making it easier to identify each part of the AST.
+
+import ast
+
+def dump_ast(filename):
+    with open(filename, 'r') as file:
+        source_code = file.read()
+
+    try:
+        tree = ast.parse(source_code)
+        ast_dump = ast.dump(tree, indent=4, annotate_fields=True)
+        print(ast_dump)
+    except SyntaxError as e:
+        print(f"Syntax error in {filename}: {e}")
+
+
+
+
+if __name__ == "__main__":
+    check_the_datatype()
+    tablesQ2()
+    tablesQ3()
+    print()

Scott_Submissions/HW5.py

@@ -0,0 +1,91 @@
+# 5. What does this do? print("\007") Can you figure out why?
+
+    # It is a ASCII Bell character.
+    # It generates a beep sound or a system alert depending on the platform and environment where the code is executed.
+    # It is often used to trigger attention or alert the user in certain situations or as a way to generate a simple sound signal in text-based interfaces.
+
+    # BUT NOTHING HAPPENED ON MAC.
+
+
+
+# 6. What does this do? print("abcdefg\rhijklmnop") Can you figure out why?
+
+    # '\r' is a carriage return character
+    # When the string is printed, the carriage return character '\r' causes the cursor to return to the beginning of the line. 
+    # So when "hijklmnop" is printed, the cursor moves back to the start of the line, and the subsequent text "abcdefg" overwrites the initial characters.
+
+    # The output is gonna be 'hijklmnop'.
+
+
+
+# 7. To shut down the HTTP server afterward, using Ctrl + C to interrupt the execution of the Python program.
+
+import http.server
+import socketserver
+from urllib.parse import urlparse, parse_qs
+
+class MyRequestHandler(http.server.SimpleHTTPRequestHandler):
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header('Content-type', 'text/plain')
+        self.end_headers()
+        output_string = "abcdefg\rhijklmnop"
+        self.wfile.write(output_string.encode())
+
+PORT = 8000
+Handler = MyRequestHandler
+httpd = socketserver.TCPServer(("", PORT), Handler)
+print(f"Serving on port {PORT}")
+
+httpd.serve_forever()
+
+    # The HTTP server sends the response over the network to the client, which is typically a web browser.
+    # In this function, the server sends an HTTP response with a status code of 200 and a content type of "text/plain". 
+    # The response body is set to the string "abcdefg\rhijklmnop" encoded as bytes.
+    # When the client receives this response, it interprets the \r character as a normal character and displays the entire string "abcdefg\rhijklmnop" as it is.
+
+    # The '\r' character is a carriage return character, which is a control character used to return the cursor to the beginning of the current line.
+    # The behavior of the carriage return character '\r' can depend on the platform and how the output is handled.
+
+    # For example:
+    # In Safari and Chrome, the "http://localhost:8000" shows:
+        # abcdefg
+        # hijklmnop
+    # In Macbook Terminal, the "curl http://localhost:8000" shows:
+        # hijklmnop%    
+
+
+
+# 8. Think of a way someone might try to commit a crime or hide an embezzlement scheme using the answers to the above two questions.
+
+    # The key is by manipulating or altering the output displayed on a web page versus what is actually happening in the system.
+
+    # Case 1:
+        # Show the false financial transactions to earn the cut.
+    # Case 2:
+        # Delivey the heist planning details and hide any suspicious activity.
+    # Case 3:
+        # Overwrite the previously displayed information for the false testimony purpose.
+
+
+
+# 9. Think of how you would do input validation to prevent such a crime. Replace the code REPLACE ME here so the tests pass:
+
+def validate(input_str):
+    if '\r' in input_str or '\n' in input_str:
+        raise ValueError("Crime detected!")
+
+try:
+    validate("abcdefg")
+    print("✅ test1 pass!")
+except ValueError:
+    print("❌ test1 fail!")
+
+try:
+    validate("abcdefg\rhijklmnop")
+    print("❌ test2 fail!")
+except ValueError:
+    print("✅ test2 pass!")
+
+    # Test 1 pass means there is no ValueError
+    # Test 2 pass means the ValueError has been detected

Scott_Submissions/HW6.py

@@ -0,0 +1,76 @@
+########## This file only contains the question 2, 4, and 10. The rest is in the BoundedInt.py. ##########
+
+
+
+# 2. Modify the template to pass test 1, which checks that int() called on your class will return the value of i.
+
+# class BoundedInt():
+#     def __init__(self, i, min, max):
+#         """
+#         Create a bounded integer.
+
+#         Args:
+#             i (int): The initial value of the integer.
+#             min (int): The minimum value of the integer.
+#             max (int): The maximum value of the integer.
+#         """
+#         self.i = i
+#         self.min = min
+#         self.max = max
+    
+#     def __int__(self):
+#         """
+#         Convert the bounded integer to int.
+
+#         Returns:
+#             int: The value of the bounded integer.
+#         """
+#         return self.i
+
+
+
+# 4. In that reading material, there's a sentence that starts with "For instance, to evaluate the expression x + y, "... 
+# What do you think the types of x and y are? Guess, without checking first. 
+# What are they, actually? You can use the debugger's local window to find out.
+
+    # x might be an instance of a class that has defined the __add__() method
+    # And y is the object that is compatible with the x instance for the addition operation.
+
+class MyClass:
+    def __init__(self, value):
+        self.value = value
+
+    def __add__(self, other):
+        if isinstance(other, MyClass):
+            return MyClass(self.value + other.value)
+        elif isinstance(other, int):
+            return MyClass(self.value + other)
+        else:
+            raise TypeError("Unsupported operand type.")
+
+# Example usage
+obj1 = MyClass(5)
+obj2 = MyClass(10)
+result1 = obj1 + obj2  # Calls obj1.__add__(obj2)
+print(result1.value)  # Output: 15
+
+result2 = obj1 + 3  # Calls obj1.__add__(3)
+print(result2.value)  # Output: 8
+
+
+
+# 10. Think about how you would change the template so it could allow adding a BoundedInt to an emoji, 
+#       if there was a hypothetical function sentiment(emoji) which returned a floating point number from -10.0 to 10.0 
+#       which indicated whether the emoji was happy or sad. e.g. BoundedInt(1, min = 1, max = 10) + 😁 would raise ValueError.
+
+    # By adding the conceptional function 'sentiment(emoji)' in the '__add__()' method
+    # The sentiment will analyze the happy level of the input emoji and return a floating number from a number range
+        # For example:
+            # 10 for a 😊 smiley face
+            # -10 for a frowny face
+            # 0 for a 🍕
+    # The protential code can be like this:
+'''
+        elif isinstance(other, str) and sentiment(other) < 0:
+            aise ValueError("Cannot add a BoundedInt to a sad emoji")   
+        '''

Scott_Submissions/HW7.py

@@ -0,0 +1,77 @@
+########## Some commands in pdb ##########
+# help: Display a list of available pdb commands or get help on a specific command.
+# break or b: Set a breakpoint at a specific line or function.
+# continue or c: Continue execution until the next breakpoint or the program finishes.
+# step or s: Step into the next line of code, diving into function calls.
+# next or n: Step over the next line of code, without diving into function calls.
+# return or r: Continue execution until the current function returns.
+# list or l: Show the current line of code and surrounding lines.
+# print or p: Evaluate and print the value of an expression or variable.
+# watch: Set a watchpoint on an expression or variable. The debugger will break when the value changes.
+# quit or q: Quit the debugger and stop execution.
+
+
+########## There is a main() function at the end ##########
+
+
+# 2. Provide an example script where setting a breakpoint on a particular line
+#       Then using either step over or step into will yield the same result.
+
+class Same_StepOverStepInto_Result:
+    def calculation2(self, a, b):
+        result = a + b
+        product = self.multiply(a, b)  # Step into this method call
+
+        breakpoint()  # Set a breakpoint here
+
+        print(f"The sum is: {result}")
+        print(f"The product is: {product}")
+
+    def multiply(self, x, y):
+        return x * y
+
+
+# calculator2 = Same_StepOverStepInto_Result()
+# calculator2.calculation2(6, 7)
+
+
+
+# 3. Here is another example which will provide different results from 'step' and 'next' commands
+
+class Diff_StepOverStepInto_Result:
+    def multiply(self, a, b):
+        return a * b
+
+    def calculation3(self, a, b):
+        result = a + b
+
+        breakpoint()  # Set a breakpoint here
+
+        product = self.multiply(a, b)
+
+        print(f"The sum is: {result}")
+        print(f"The product is: {product}")
+
+
+# calculator3 = Diff_StepOverStepInto_Result()
+# calculator3.calculation3(6, 7)
+
+
+
+# Choose wich Class to run
+def main():
+    choice = input("Enter 2 to run Q2 class for same result, 3 to run Q3 class for different result: ")
+
+    if choice == '2':
+        print('Here is the sample task for Question 2:')
+        calculator2 = Same_StepOverStepInto_Result()
+        calculator2.calculation2(6, 7)
+    elif choice == '3':
+        print('Here is the sample task for Question 3:')
+        calculator3 = Diff_StepOverStepInto_Result()
+        calculator3.calculation3(6, 7)
+    else:
+        print("Please only choose between 2 and 3")
+
+if __name__ == "__main__":
+    main()

Scott_Submissions/HW7_test.py

@@ -0,0 +1,79 @@
+class Vector_1:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+    
+    def __add__(self, other):
+        if isinstance(other, Vector_1):
+            # Add the corresponding coordinates of both vectors
+            new_x = self.x + other.x
+            new_y = self.y + other.y
+            return Vector_1(new_x, new_y)
+        else:
+            raise TypeError("Unsupported operand type: +")
+    
+    def __str__(self):
+        return f"Vector({self.x}, {self.y})"
+
+# # Create two Vector instances
+# vector1 = Vector_1(2, 3)
+# vector2 = Vector_1(4, 5)
+
+# # Add two Vector instances using the + operator
+# result1 = vector1 + vector2
+
+# # Print the result
+# print(result1)
+
+
+
+class Vector_2:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+    
+    def __add__(self, other):
+        if isinstance(other, Vector_2):
+            # Add the corresponding coordinates of both vectors
+            new_x = self.x + other.x
+            new_y = self.y + other.y
+            return Vector_2(new_x, new_y)
+        else:
+            raise TypeError("Unsupported operand type: +")
+    
+    # def __str__(self):
+    #     return f"Vector({self.x}, {self.y})"
+
+# # Create two Vector instances
+# vector3 = Vector_2(2, 3)
+# vector4 = Vector_2(4, 5)
+
+# # Add two Vector instances using the + operator
+# result2 = vector3 + vector4
+
+# # Print the result
+# print(result2)
+
+
+def main():
+    # Create two Vector instances
+    vector1 = Vector_1(2, 3)
+    vector2 = Vector_1(4, 5)
+    # Add two Vector instances using the + operator
+    result1 = vector1 + vector2
+    # Print the result
+    print("This is printout of the Class using __str__() method:")
+    print(result1)
+
+    # Create two Vector instances
+    vector3 = Vector_2(2, 3)
+    vector4 = Vector_2(4, 5)
+    # Add two Vector instances using the + operator
+    result2 = vector3 + vector4
+    # Print the result
+    print("This is printout of the Class without using __str__() method:")
+    print(result2) 
+
+
+if __name__ == "__main__":
+    main()

Scott_Submissions/PDB_inVSC.rtf

@@ -0,0 +1,56 @@
+{\rtf1\ansi\ansicpg1252\cocoartf2580
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+{\*\expandedcolortbl;;}
+\margl1440\margr1440\vieww11520\viewh8400\viewkind0
+\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\pardirnatural\partightenfactor0
+
+\f0\fs24 \cf0 scott@MacBook-Pro-6 Scott_Submissions % python3 HW7.py\
+Enter 2 to run Q2 class for same result, 3 to run Q3 class for different result: 1\
+Please only choose between 2 and 3\
+scott@MacBook-Pro-6 Scott_Submissions % python3 HW7.py\
+Enter 2 to run Q2 class for same result, 3 to run Q3 class for different result: 2\
+Here is the sample task for Question 2:\
+> /Users/scott/Desktop/GTSP/python-bootcamp/Scott_Submissions/HW7.py(27)calculation2()\
+-> print(f"The sum is: \{result\}")\
+(Pdb) step\
+The sum is: 13\
+> /Users/scott/Desktop/GTSP/python-bootcamp/Scott_Submissions/HW7.py(28)calculation2()\
+-> print(f"The product is: \{product\}")\
+(Pdb) c\
+The product is: 42\
+scott@MacBook-Pro-6 Scott_Submissions % python3 HW7.py\
+Enter 2 to run Q2 class for same result, 3 to run Q3 class for different result: 2\
+Here is the sample task for Question 2:\
+> /Users/scott/Desktop/GTSP/python-bootcamp/Scott_Submissions/HW7.py(27)calculation2()\
+-> print(f"The sum is: \{result\}")\
+(Pdb) next\
+The sum is: 13\
+> /Users/scott/Desktop/GTSP/python-bootcamp/Scott_Submissions/HW7.py(28)calculation2()\
+-> print(f"The product is: \{product\}")\
+(Pdb) c\
+The product is: 42\
+scott@MacBook-Pro-6 Scott_Submissions % python3 HW7.py\
+Enter 2 to run Q2 class for same result, 3 to run Q3 class for different result: 3\
+Here is the sample task for Question 3:\
+> /Users/scott/Desktop/GTSP/python-bootcamp/Scott_Submissions/HW7.py(50)calculation3()\
+-> product = self.multiply(a, b)\
+(Pdb) step\
+--Call--\
+> /Users/scott/Desktop/GTSP/python-bootcamp/Scott_Submissions/HW7.py(42)multiply()\
+-> def multiply(self, a, b):\
+(Pdb) c\
+The sum is: 13\
+The product is: 42\
+scott@MacBook-Pro-6 Scott_Submissions % python3 HW7.py\
+Enter 2 to run Q2 class for same result, 3 to run Q3 class for different result: 3\
+Here is the sample task for Question 3:\
+> /Users/scott/Desktop/GTSP/python-bootcamp/Scott_Submissions/HW7.py(50)calculation3()\
+-> product = self.multiply(a, b)\
+(Pdb) next\
+> /Users/scott/Desktop/GTSP/python-bootcamp/Scott_Submissions/HW7.py(52)calculation3()\
+-> print(f"The sum is: \{result\}")\
+(Pdb) c\
+The sum is: 13\
+The product is: 42\
+scott@MacBook-Pro-6 Scott_Submissions % }

Scott_Submissions/Q4.py

@@ -0,0 +1,18 @@
+import pandas as pd
+import numpy as np
+
+# Generate two random 64-bit integers
+num1 = np.random.randint(0, 10 - 1)
+num2 = np.random.randint(0, 10 - 1)
+
+# Multiply them together using the normal Python multiplication operator
+print(f"num1 * num2 = {num1 * num2}")
+
+# Create a Pandas DataFrame with the generated numbers
+data = {'Number1': [num1], 'Number2': [num2]}
+df = pd.DataFrame(data)
+
+# Multiply the numbers together using the Pandas multiplication operator
+df['Product'] = df['Number1'] * df['Number2']
+
+print(df)

Scott_Submissions/Q5.py

@@ -0,0 +1,4 @@
+import sys
+num = 99999999999
+size = sys.getsizeof(num)
+print(f"The size of the float is {size} bytes.")

Scott_Submissions/Reading_Material_Notes.rtf

@@ -0,0 +1,51 @@
+{\rtf1\ansi\ansicpg1252\cocoartf2580
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fnil\fcharset0 LucidaGrande-Bold;\f1\fnil\fcharset0 LucidaGrande;}
+{\colortbl;\red255\green255\blue255;\red26\green26\blue26;\red255\green255\blue255;}
+{\*\expandedcolortbl;;\cssrgb\c13333\c13333\c13333;\cssrgb\c100000\c100000\c100000;}
+\margl1440\margr1440\vieww11520\viewh8400\viewkind0
+\deftab720
+\pard\pardeftab720\parhyphenfactor20\partightenfactor0
+
+\f0\b\fs32 \cf2 \cb3 \expnd0\expndtw0\kerning0
+CPython implementation detail:
+\f1\b0  CPython currently uses a reference-counting scheme with (optional) delayed detection of cyclically linked garbage, which collects most objects as soon as they become unreachable, but is not guaranteed to collect garbage containing circular references.\
+	\
+	What is a r\cf2 eference-counting scheme?\
+		It refers to a memory management technique where each object in a programming language implementation, such as CPython, keeps track of the number of references pointing to it. \
+		Whenever a reference is created to an object, its reference count is increased, and when a reference is deleted or goes out of scope, the reference count is decreased. \
+	\
+	What is a reference?\
+		In the context of memory management, a "reference" refers to an identifier or value that allows access to an object in a programming language. \
+		It is a way to refer to or point to the memory location where an object is stored.\
+	\
+	What is the advantage of reference-counting scheme?\
+		The advantage of the reference-counting scheme is that it allows objects to be deallocated immediately when they are no longer needed. \
+		It ensures efficient memory management because objects can be freed as soon as their reference count reaches zero, without the need for more complex garbage collection algorithms.\
+	\
+	What is a garbage?\
+		In the context of memory management, "garbage" refers to objects that are no longer reachable or used by the program but still occupy memory. \
+		This typically occurs when objects are created dynamically during program execution but are not properly deallocated or no longer accessible. \
+		Garbage collection is the process of identifying and reclaiming memory occupied by such unused objects, making it available for reuse. \
+		The reference-counting scheme used by CPython helps in automatically deallocating most objects as soon as they become unreachable. \
+		However, in the case of circular references, where objects refer to each other in a loop, additional mechanisms are required to detect and collect such cyclically linked garbage. It\'92s called "delayed detection of cyclically linked garbage" to collect and deallocate objects that are involved in cyclic references.\
+\
+\
+\
+What is a __blabla__(): method?\
+	In Python, the following are special attributes (also known as dunder attributes) that can be accessed on objects or functions.\
+	These special attributes provide additional information or access to specific properties of objects in Python. \
+\
+What is the advantages of the dunder method?\
+	Overall, dunder attributes provide flexibility, customization, and enhanced functionality to Python objects and classes. \
+	They contribute to the expressive nature of the language and enable powerful features like operator overloading and introspection.\
+\
+	Convention: Dunder attributes follow a specific naming convention, starting and ending with double underscores (__). This convention makes them easily recognizable and distinguishes them from regular attributes.\
+	Customization: Dunder attributes allow you to customize and define the behavior of objects and classes. By implementing specific dunder methods, you can change how objects behave in certain situations, such as arithmetic operations, string representation, comparisons, and more.\
+	Operator Overloading: Dunder attributes enable operator overloading, allowing objects to participate in built-in operations like addition (+), subtraction (-), equality (==), and more. This makes it possible to define meaningful operations for custom classes.\
+	Introspection: Dunder attributes provide a way to introspect and access information about objects and classes. For example, name and doc allow you to retrieve the name and documentation of an object. This introspection capability is useful for debugging, documentation generation, and code analysis.\
+	Integration with Language Features: Dunder attributes seamlessly integrate with various language features, such as iteration (with iter), context managers (with enter and exit), attribute access (with getattr, setattr), and more. This allows you to leverage the full power of the Python language in your classes.\
+	Code Readability: By following the conventions for dunder attributes, your code becomes more readable and understandable by other Python developers. They can easily recognize and understand the purpose of these special attributes.\
+\
+\
+\
+## The attached file HW7_test.py provides an example on how dunder method works. Don\'92t forget to check it out.}

Scott_Submissions/cr-example.py

@@ -0,0 +1,7 @@
+import time
+
+i=0
+while True:
+    print(f"\015{i=}", end='')
+    i += 1
+    time.sleep(0.2)

Scott_Submissions/pdb_test.py

@@ -0,0 +1,28 @@
+import pdb
+
+def calculate_average(numbers):
+    total = sum(numbers)
+    average = total / len(numbers)
+    return average
+
+def main():
+    data = [1, 2, 3, 4, 5]
+
+    pdb.set_trace()
+    result = calculate_average(data)
+    print("The average is:", result)
+
+    pdb.set_trace()  # Set a breakpoint at this line
+
+    print("Program execution resumed.")
+    # ... continue with the rest of your code
+
+if __name__ == '__main__':
+    main()
+
+
+# n or next: Execute the next line of code.
+# s or step: Step into a function call.
+# c or continue: Continue execution until the next breakpoint or the program's end.
+# p or print: Print the value of a variable.
+# q or quit: Quit the debugger and exit the program.

Scott_Submissions/test.py

@@ -0,0 +1,5 @@
+char1 = "u"
+result1 = ord(char1)
+print("ASCII value of the character {} is {}.".format(char1, result1))
+
+

http-performance/Webpage.ipynb

@@ -0,0 +1,78 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0593e529",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from urllib.parse import urlparse\n",
+    "\n",
+    "class JPEGRequestHandler:\n",
+    "    def __init__(self, app):\n",
+    "        self.app = app\n",
+    "\n",
+    "    def __call__(self, environ, start_response):\n",
+    "        url = urlparse(environ['REQUEST_URI'])\n",
+    "        path = url.path\n",
+    "\n",
+    "        if path.endswith('.jpg'):\n",
+    "            file_path = path[1:]\n",
+    "\n",
+    "            if os.path.isfile(file_path):\n",
+    "                with open(file_path, 'rb') as file:\n",
+    "                    response_body = file.read()\n",
+    "                    status = '200 OK'\n",
+    "                    headers = [('Content-type', 'image/jpeg'),\n",
+    "                               ('Content-Length', str(len(response_body)))]\n",
+    "\n",
+    "                    start_response(status, headers)\n",
+    "                    return [response_body]\n",
+    "            else:\n",
+    "                status = '404 Not Found'\n",
+    "                headers = [('Content-type', 'text/plain'),\n",
+    "                           ('Content-Length', '0')]\n",
+    "\n",
+    "                start_response(status, headers)\n",
+    "                return []\n",
+    "        else:\n",
+    "            status = '403 Forbidden'\n",
+    "            headers = [('Content-type', 'text/plain'),\n",
+    "                       ('Content-Length', '0')]\n",
+    "\n",
+    "            start_response(status, headers)\n",
+    "            return []\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    from werkzeug.serving import run_simple\n",
+    "    from werkzeug.middleware.dispatcher import DispatcherMiddleware\n",
+    "\n",
+    "    app = DispatcherMiddleware(JPEGRequestHandler(app), {'/': app})\n",
+    "    run_simple('0.0.0.0', 8000, app, use_reloader=True)"
+   ]
+  }
+ ],
+ "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.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

http-performance/app.py

@@ -0,0 +1,44 @@
+import os
+from urllib.parse import urlparse
+
+class JPEGRequestHandler:
+    def __init__(self, app):
+        self.app = app
+
+    def __call__(self, environ, start_response):
+        url = urlparse(environ['REQUEST_URI'])
+        path = url.path
+
+        if path.endswith('.jpg'):
+            file_path = path[1:]
+
+            if os.path.isfile(file_path):
+                with open(file_path, 'rb') as file:
+                    response_body = file.read()
+                    status = '200 OK'
+                    headers = [('Content-type', 'image/jpeg'),
+                               ('Content-Length', str(len(response_body)))]
+
+                    start_response(status, headers)
+                    return [response_body]
+            else:
+                status = '404 Not Found'
+                headers = [('Content-type', 'text/plain'),
+                           ('Content-Length', '0')]
+
+                start_response(status, headers)
+                return []
+        else:
+            status = '403 Forbidden'
+            headers = [('Content-type', 'text/plain'),
+                       ('Content-Length', '0')]
+
+            start_response(status, headers)
+            return []
+
+if __name__ == '__main__':
+    from werkzeug.serving import run_simple
+    from werkzeug.middleware.dispatcher import DispatcherMiddleware
+
+    app = DispatcherMiddleware(JPEGRequestHandler(app), {'/': app})
+    run_simple('0.0.0.0', 8000, app, use_reloader=True)

lexer_parser.py

@@ -0,0 +1,76 @@
+from enum import Enum
+
+class Tokens(Enum):
+    QUOTE = 1,
+    CHAR = 2,
+    NEWLINE = 3,
+    SPACE = 4
+
+class Lexer:
+    tokens = list()
+    def __init__(self):
+        pass
+    def lex(self, str):
+        for c in str:
+            if c == "'" or c == '"':
+                self.tokens.append(Tokens.QUOTE)
+                print("Token: QUOTE")
+            elif c == "\n":
+                self.tokens.append(Tokens.NEWLINE)
+                print("Token: NEWLINE")
+            elif c == " ":
+                self.tokens.append(Tokens.SPACE)
+                print("Token: SPACE")
+            else:
+                self.tokens.append(Tokens.CHAR)
+                print("Token: CHAR")
+    def __str__(self):
+        return ",".join(Tokens(token).name for token in self.tokens)
+
+class States(Enum):
+    INITIAL = 0,
+    BEGINQUOTE = 1
+    
+class Parser:
+    def __init__(self):
+        self.state = States.INITIAL
+        self.line = 1
+
+    def transition(self, state):
+        print(f"{States(self.state).name} -> {States(state).name}")
+        self.state = state
+
+    def parse(self, tokens):
+        for token in tokens:
+            if self.state == States.INITIAL:
+                if token == Tokens.QUOTE:
+                    self.transition(States.BEGINQUOTE)
+                elif token == Tokens.NEWLINE:
+                    self.line += 1
+                continue
+            if self.state == States.BEGINQUOTE:
+                if token == Tokens.QUOTE:
+                    self.transition(States.INITIAL)
+                elif token == Tokens.CHAR or token == Tokens.SPACE:
+                    pass                    
+                elif token == Tokens.NEWLINE:
+                    raise ValueError(f"Unterminated string on line {self.line}")
+                continue
+
+if __name__ == "__main__":
+    test1 = """abcdefg
+    "abcde
+    'a'
+    bareword
+"""
+
+    lexer = Lexer()
+    lexer.lex(test1)
+    # print(lexer)
+    parser = Parser()
+    try:
+        parser.parse(lexer.tokens)
+    except ValueError as error:
+        print(error)
+
+

max submission/5_26_HW.py

@@ -0,0 +1,20 @@
+# Question7:
+# Difference: 
+# 1. Byte objects are sequence of Bytes, whereas Strings are sequence of characters. 
+# 2. Byte objects are in machine readable form internally; Strings are only in human readable form. 
+# 3. strings (str) support various character encodings, such as UTF-8, ASCII, and more. Bytes (bytes), on the other hand, represent raw binary data and can hold any byte values. 
+## Emojis can affect the size difference.
+import sys
+string_size = sys.getsizeof("Hello")
+bytes_size = sys.getsizeof(b"Hello")
+emoji_size = sys.getsizeof("😀")
+print(f"String size: {string_size} bytes")
+print(f"Bytes size: {bytes_size} bytes")
+print(f"emoji size: {emoji_size} bytes")
+
+# python routine:
+def print_string_as_numbers(string):
+    for char in string:
+        print(ord(char))
+input_string = "Hello, world!"
+print_string_as_numbers(input_string)

max submission/5_31.HW.py

@@ -0,0 +1,38 @@
+# question 8: 	If the column or data type is invalid, and we take them into calculations without noticing this, wrong number will be produced.
+# question 9：	
+def read_tomato_sales(file_name):
+        data = pd.read_csv(file_name)
+        if "Tomato_Sales" in data.columns and data["Tomato_Sales"].dtype == "int64":
+            total_sales = data["Tomato_Sales"].sum()
+            print(f"Total tomato sales: {total_sales}")
+        else:
+            raise ValueError("Invalid column or data type.")
+# question 10:	Reasons: 
+# 1. Different languages may have different character encodings, which define how characters are represented 
+# as binary data. By using bytes, you can handle various character encodings, such as UTF-8, UTF-16, or others. 
+# 2. Bytes are language-agnostic and treat text as raw binary data. 
+# 3. Bytes can handle any kind of binary data, including text data in different languages, as well as
+#  non-textual data such as images, audio, or video.
+def process_multilingual_data(data):
+    # Convert string to bytes using UTF-8 encoding
+    byte_data = data.encode('utf-8')
+
+    # Convert bytes back to string for display or further processing
+    processed_data = byte_data.decode('utf-8')
+
+    return processed_data
+
+# Example usage
+text = "This is shunan zhao"
+processed_text = process_multilingual_data(text)
+print(processed_text)
+# 1: ord("😀") gives you the Unicode code point of the character, while 0xf09f9880 represents the byte 
+# sequence in UTF-8 encoding used to represent that character.
+# 2.5: A REPL  is an interactive programming environment that allows you to enter commands or expressions, 
+# which are then evaluated and the results are printed or displayed. 
+# 3: the "_" variable is a special variable that holds the result of the last executed expression or 
+# statement. It is often referred to as the "underscore variable."
+#The type can vary based on the context and the value assigned to  in the current REPL session. For example:
+# If the last executed expression was an integer, the type of "_" would be int.
+# If the last executed expression was a string, the type of "_" would be str.
+# If the last executed expression was a list, the type of "_" would be list.

max submission/6_5_HW.py

@@ -0,0 +1,53 @@
+#question 1:
+# i = 3 Literal Type: Integer, and its value is 3.
+
+# f = 3.0 Literal Type: Float, and its value is 3.0.
+
+# c = 3+3j Literal Type: Complex, and its value is 3+3j.
+
+# b = b'abcdefg' Literal Type: Bytes, and its value is b'abcdefg'.
+
+# s = 'abcdefg' Literal Type: String, and its value is 'abcdefg'.
+
+# s = "abcdefg" Literal Type: String, and its value is "abcdefg".
+
+#question 2: 
+'''
+	'0'  	   b'0'	     0	        0.0        0j
+'0'	Equal	  |Not equal |Not equal	|Not equal |Not equal
+b'0'Not equal |Equal	 |Not equal	|Not equal |Not equal
+0	Not equal |Not equal |Equal	    |Equal	   |Equal
+0.0	Not equal |Not equal |Equal	    |Equal	   |Not Equal
+0j	Not equal |Not equal |Equal	    |Not equal |Equal
+'''
+#question 3:
+##The "+" operator case:
+'''
+	 '0'	   b'0'	      0	         0.0	    0j
+'0'	 '00'	   |TypeError |TypeError |TypeError |TypeError
+b'0' TypeError |b'00'	  |TypeError |TypeError	|TypeError
+0	 TypeError |TypeError |0         |0.0	    |0j
+0.0	 TypeError |TypeError |0.0	     |0.0	    |TypeError
+0j	 TypeError |TypeError |0j	     |TypeError	|0j
+'''
+##The "==" operator case:
+'''
+	 '0'	b'0'	0	    0.0	    0j
+'0'	 True	|False	|False	|False	|False
+b'0  False	|False	|False	|False	|False
+0	 False	|False	|False	|True	|True
+0.0	 False	|False	|True	|True	|False
+0j	 False	|False	|True	|False	|True
+'''
+#question4:
+import ast
+
+# Open the lexer/parser example file
+with open('lexer_parser_example.py', 'r') as file:
+    source_code = file.read()
+
+# Parse the source code into an AST
+tree = ast.parse(source_code)
+
+# Dump the AST
+print(ast.dump(tree, indent=4))

max submission/6_6_HW.py

@@ -0,0 +1,34 @@
+# question 5:
+# The statement print("\007") outputs an ASCII escape sequence \007, which represents the Bell control character. The reason why print("\007") 
+# produces a sound or visual alert is that when the string "\007" is printed, it is interpreted by the terminal or system as a signal to generate 
+# an audible or visual alert, as defined by the specific implementation.
+
+# question 6:
+# The code print("abcdefg\rhijklmnop") will output "hijklmnopg"
+# In Python, the '\r' character is a carriage return character, which instructs the console or terminal to move the cursor back to the beginning 
+# of the current line, without advancing to the next line. This means that anything printed after the '\r' will overwrite whatever was printed earlier 
+# on the same line.
+
+# question 7:
+# In this case, the carriage return character \r is treated as a regular character within the response content. It does not have the same effect as 
+# in the previous example where it was used in a print statement.
+
+# qustion 8:
+# If a hacker attacks a credit card system. When the customer came to buy a can of Coke, he paid 2 knives to the store, but the display in the 
+# background was "2/r500".
+
+# question 9:
+def validate(input_string):
+    if "\r" in input_string:
+        raise ValueError("Crime detected!")
+try:
+    validate("abcdefg")
+    print("✅ test1 pass!")
+except:
+    print("❌ test1 fail!")
+
+try:
+    validate("abcdefg\rhijklmnop")
+    print("❌ test2 fail!")
+except ValueError as err:
+    print("✅ test2 pass!")

max submission/6_7_HW.py

@@ -0,0 +1,77 @@
+class BoundedInt():
+    def __init__(self, i, min_val, max_val):
+        self.i = i
+        self.min = min_val
+        self.max = max_val
+
+    def __int__(self):
+        return self.i
+
+    def __sub__(self, other):
+        if isinstance(other, BoundedInt):
+            result = self.i - other.i
+        else:
+            result = self.i - other
+        if result < self.min:
+            raise ValueError("Result exceeds min value")
+        return BoundedInt(result, self.min, self.max)
+
+    def __add__(self, other):
+        if isinstance(other, BoundedInt):
+            result = self.i + other.i
+        else:
+            result = self.i + other
+        if result > self.max:
+            raise ValueError("Result exceeds max value")
+        return BoundedInt(result, self.min, self.max)
+
+    def test1(self):
+        bi1 = BoundedInt(0xdeadbeef, min_val=(0xdeadbeef - 1), max_val=(0xdeadbeef + 1))
+        if int(bi1) == 0xdeadbeef:
+            print(f"✅ Test 1 passed!")
+        else:
+            print(f"❌ Test 1 failed, int(bi1) = {int(bi1)}, expected 0xdeadbeef")
+
+    def test2(self):
+        bi2 = BoundedInt(1, min_val=0, max_val=1)
+        bi3 = BoundedInt(1, min_val=0, max_val=1)
+        try:
+            bi4 = bi2 + bi3  # 1 + 1 = 2, which exceeds max_val = 1
+            print(f"❌ Test 2 failed!")
+        except ValueError as err:
+            print(f"✅ Test 2 passed!")
+
+    def test3(self):
+        bi4 = BoundedInt(1, min_val=0, max_val=1)
+        bi5 = BoundedInt(2, min_val=0, max_val=-1)
+        try:
+            bi6 = bi4 - bi5  # 1 - 2 = -1, which is less than min_val = 0
+            print(f"❌ Test 3 failed!")
+        except ValueError as err:
+            print(f"✅ Test 3 passed!")
+
+    def test4(self):
+        bi7 = BoundedInt(1, min_val=0, max_val=1)
+        bi8 = 2
+        try:
+            bi9 = bi7 + bi8
+            print(f"❌ Test 4 failed!")
+        except ValueError as err:
+            print(f"✅ Test 4 passed!")
+
+    def test5(self):
+        bi10 = BoundedInt(1, min_val=0, max_val=1)
+        bi11 = 2
+        try:
+            bi12 = bi10 - 11
+            print(f"❌ Test 5 failed!")
+        except ValueError as err:
+            print(f"✅ Test 5 passed!")
+
+
+tester = BoundedInt(0, 0, 0)
+tester.test1()
+tester.test2()
+tester.test3()
+tester.test4()
+tester.test5()

max submission/6_9_HW.py

@@ -0,0 +1,110 @@
+# question 1: 
+ #boolean context:
+ #In programming, a boolean context refers to a situation where a condition or expression is evaluated as either true or false. 
+ #A boolean context typically occurs in control flow statements, such as if statements or while loops, where the condition determines whether 
+ #a certain block of code should be executed or repeated.
+
+ #Ellipsis:
+ #an ellipsis (...) is a special token that represents an ellipsis object. It is often used as a placeholder in code or data structures where 
+ #you intend to fill in additional functionality or content later.
+
+ #machine-level double precision floating point numbers
+ #Machine-level double precision floating-point numbers, often referred to as double, are a common representation of real numbers in computer systems.
+ #They are a binary format used to store and manipulate floating-point values with higher precision compared to single precision.
+
+ #Callable types:
+ #callable types refer to objects that can be called as functions. These objects are capable of executing code when invoked with parentheses, just 
+ #like a regular function.
+
+ #cell_contents:
+ #the term "cell contents" refers to the value stored in a cell of a closure. A closure is a function object that retains references to variables 
+ #in its enclosing lexical scope, even when the outer function has finished executing.
+ #When a closure is created, each variable it references is stored in a cell, which is an internal data structure associated with the closure.
+ #The cell contents refer to the value stored within the cell associated with a particular variable in a closure. It represents the value of the 
+ #variable as seen by the closure, regardless of any changes made to the variable in the outer scope.
+
+ #example for "When an instance method object is created by retrieving a user-defined function object from a class via one of its instances, 
+ #its __self__ attribute is the instance, and the method object is said to be bound. The new method’s __func__ attribute is the original function 
+ #object."
+class MyClass:
+    def my_method(self):
+        print("Hello, world!")
+
+# Creating an instance of MyClass
+my_instance = MyClass()
+
+# Retrieving the method object from the instance
+method_object = my_instance.my_method
+
+# Accessing the attributes of the method object
+print(method_object.__self__)  # Output: <__main__.MyClass object at 0x...>
+print(method_object.__func__)  # Output: <function MyClass.my_method at 0x...>
+
+# Calling the method through the method object
+method_object()  # Output: Hello, world!
+
+ #async def:
+ # the async def syntax is used to define an asynchronous function, also known as a coroutine. An asynchronous function allows concurrent
+ # execution of multiple tasks by allowing the program to proceed to other tasks while waiting for certain operations to complete.
+import asyncio
+
+async def my_coroutine():
+    print("Coroutine started")
+    await asyncio.sleep(1)  # Simulating an asynchronous operation
+    print("Coroutine completed")
+
+# Calling the coroutine
+asyncio.run(my_coroutine())
+ 
+ #Static method and class method:
+ #In Python, static methods and class methods are two types of methods that can be defined within a class.
+ #Static methods:
+ #Static methods are defined using the @staticmethod decorator or by declaring them inside the class without any special decorator.
+ #Static methods are not bound to a specific instance or the class itself. They behave like regular functions but are defined within the class for organizational purposes.
+ #Static methods do not have access to the instance or class attributes and cannot modify them directly.
+ #Static methods can be called on the class itself or on an instance of the class.
+ #Class methods:
+ #Class methods are defined using the @classmethod decorator.
+ #Class methods are bound to the class itself rather than the instances. They receive the class as the first argument (usually named cls) instead of the instance (self).
+ #Class methods have access to the class attributes and can modify them if needed.
+ #Class methods can be called on the class itself or on an instance of the class.
+
+# question 2:
+def add_numbers(a, b):
+    result = a + b
+    return result
+
+def multiply_numbers(x, y):
+    result = x * y
+    return result
+
+def main():
+    number1 = 5
+    number2 = 10
+    sum_result = add_numbers(number1, number2)
+    product_result = multiply_numbers(sum_result, number2)
+    print("Product:", product_result)
+
+if __name__ == "__main__":
+    main()
+
+# question 3:
+def foo():
+    a = 10
+    b = 20
+    return a + b
+
+def bar():
+    x = 5
+    y = 7
+    return x * y
+
+result = foo() + bar()
+print(result)
+# In this example, using "Step Over" and "Step Into" may not yield different results, but the behavior is 
+# dependent on the implementation of the functions being called.
+
+
+
+
+

max submission/hw1 1-5.py

@@ -0,0 +1,21 @@
+# question 1: The international standard for floating-point representation is called IEEE 754.
+
+# question 2: The IEEE 754 standard allows floating-point numbers to be represented with different bit sizes. The most commonly used formats specified by the standard are single precision (32 bits) and double precision (64 bits).
+
+# question 3: 	
+import sys
+print(sys.float_info)
+sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)
+
+# question 4: 	In the first multiplication (num1 * num2), you are using the normal Python multiplication 
+# operator, which operates on native Python integers. Python integers have arbitrary precision, meaning they can
+#  represent very large numbers accurately. However, when the result exceeds the limit of a 64-bit signed integer 
+# (2^63 - 1), an overflow may occur, and the result may not be accurate.
+# In the second multiplication (df['Number1'] * df['Number2']), you are using the Pandas multiplication operator 
+# on the columns of a DataFrame. By default, Pandas uses NumPy for numerical computations, and NumPy uses 
+# fixed-size data types. In this case, the integers in the DataFrame are most likely represented as 64-bit 
+# signed integers (int64), which have a maximum value of 2^63 - 1. If the result of the multiplication exceeds 
+# this limit, it will overflow and wrap around, leading to incorrect results.
+
+# Question5: 5.	The size of a Python floating-point number is determined by the implementation and is not influenced by the magnitude of the value it represents. So it does not change as the value of the number gets larger.
+