Level 1: Python Playground!

# Let's create some variables! 
name = "Alice" 
age = 30 
height = 1.65 
is_student = False 
grades = [85, 90, 78] 
student_info = {"name": name, "age": age} 

# And let's see what's inside these containers! 
print(f"Name: {name}, Age: {age}, Height: {height}, Is Student: {is_student}") 
print(f"Grades: {grades}") 
print(f"Student Info: {student_info}")

Code Explanation

The code initializes several Python variables with different data types:

• name: A string variable assigned the value “Alice”.
• age: An integer variable assigned the value 30.
• height: A float variable assigned the value 1.65.
• is_student: A boolean variable assigned the value False.
• grades: A list variable containing three integer values: 85, 90, and 78.
• student_info: A dictionary variable containing key-value pairs. The keys are “name” and “age”, and the values are the values of the name and age variables.

The code then uses f-strings to print the values of these variables to the console, providing a formatted output.

score = 75
if score >= 90:
    print("Excellent!")
elif score >= 80:
    print("Very Good!")
else:
    print("Good.")

Code Explanation

The code evaluates a student’s score and prints a corresponding message:

• score = 75: A variable score is initialized with the value 75.
• if score >= 90:: The code checks if the score is greater than or equal to 90. Since 75 is not greater than or equal to 90, this condition is false.
• elif score >= 80:: The code checks if the score is greater than or equal to 80. Since 75 is not greater than or equal to 80, this condition is also false.
• else:: If none of the previous conditions are true, the code executes the statements within the else block.
• print("Good."): The code prints “Good.” to the console.

In summary, the code will print “Good.” because the score is 75, which does not meet the criteria for “Excellent!” or “Very Good!”.

for i in range(5):
    print(f"Iteration: {i}")

Code Explanation

The code uses a for loop to iterate and print a message five times:

• for i in range(5):: This loop iterates over a sequence of numbers from 0 to 4 (inclusive). The variable i takes on each value in this range during each iteration of the loop.
• print(f"Iteration: {i}"): Inside the loop, this line prints a formatted string. The f before the string indicates an f-string, which allows you to embed variables directly within the string. In this case, the current value of the loop counter `i` is inserted into the string.

The output of this code will be:

Iteration: 0
Iteration: 1
Iteration: 2
Iteration: 3
Iteration: 4

count = 0
while count < 3:
    print(f"Count is: {count}")
    count += 1

Code Explanation

The code uses a while loop to iterate and print a message three times:

• count = 0: A variable count is initialized with the value 0. This variable will keep track of how many times the loop has executed.
• while count < 3:: This is the condition that the while loop checks. As long as the value of count is less than 3, the code inside the loop will continue to execute.
• print(f"Count is: {count}"): This line prints a formatted string. The f before the string indicates an f-string, which allows you to embed the current value of the count variable directly within the string.
• count += 1: This line increments the value of count by 1. This is crucial; without it, the value of count would never change, and the loop would continue forever (an infinite loop).

The output of this code will be:

Count is: 0
Count is: 1
Count is: 2

def greet(person_name):
    """This function greets the person passed in as a parameter."""
    print(f"Hello, {person_name}!")

greet("Bob")

Code Explanation

The code defines a function and then calls it:

• def greet(person_name):: This line defines a function named greet. It takes one argument, person_name, which is a variable that will hold the name of the person to be greeted.
• """This function greets the person passed in as a parameter.""": This is a docstring, which is a multi-line string used to document the function. It explains what the function does.
• print(f"Hello, {person_name}!"): This line is inside the function. It prints a greeting message. The f before the string indicates an f-string, which allows you to embed the value of the person_name variable directly within the string.
• greet("Bob"): This line calls the greet function, passing the string "Bob" as the argument. When the function is called, the value "Bob" is assigned to the person_name parameter, and the function's code is executed.

The output of this code will be:

Hello, Bob!

def add(x, y):
    """This function returns the sum of two numbers."""
    return x + y

sum_result = add(5, 3)
print(f"The sum is: {sum_result}")

Code Explanation

The code defines a function to add two numbers and then calls it:

• def add(x, y):: This line defines a function named add. It takes two arguments, x and y, which represent the two numbers to be added.
• """This function returns the sum of two numbers.""": This is a docstring, explaining the purpose of the function.
• return x + y: This line calculates the sum of x and y and returns the result.
• sum_result = add(5, 3): This line calls the add function with the arguments 5 and 3. The returned value (which is 8) is assigned to the variable sum_result.
• print(f"The sum is: {sum_result}"): This line prints the value of sum_result (which is 8) to the console, using an f-string for formatting.

The output of this code will be:

The sum is: 8

numbers = [1, 2, 3, 4, 5, 6]
squared_even = [num**2 for num in numbers if num % 2 == 0]
print(f"Squared even numbers: {squared_even}")

Code Explanation

The code demonstrates a concise way to create a new list by filtering and transforming elements from an existing list:

• numbers = [1, 2, 3, 4, 5, 6]: A list named numbers is initialized with the integers from 1 to 6.
• squared_even = [num**2 for num in numbers if num % 2 == 0]: This line uses a list comprehension, a powerful feature in Python. It creates a new list called squared_even.
  • for num in numbers: This part iterates through each number (`num`) in the numbers list.
  • if num % 2 == 0: This is a filter condition. It checks if the number is even (i.e., the remainder when divided by 2 is 0).
  • num**2: This is the transformation expression. If a number passes the filter (is even), it is squared (`num**2`).
• print(f"Squared even numbers: {squared_even}"): This line prints the squared_even list, which now contains the squares of the even numbers from the original list.

The output of this code will be:

Squared even numbers: [4, 16, 36]

student_grades = {
    "Alice": [85, 92, 78],
    "Bob": [76, 88, 95],
    "Charlie": [90, 82, 88]
}

for student, grades in student_grades.items():
    average_grade = sum(grades) / len(grades)
    print(f"{student}'s average grade: {average_grade:.2f}")

Code Explanation

The code calculates the average grade for each student from a dictionary:

• student_grades = { ... }: A dictionary called student_grades is created. The keys are student names ("Alice", "Bob", "Charlie"), and the values are lists of their grades.
• for student, grades in student_grades.items():: This loop iterates through the student_grades dictionary.
  • student: In each iteration, this variable holds the name of the student (e.g., "Alice").
  • grades: This variable holds the list of grades for that student (e.g., `[85, 92, 78]`).
  • student_grades.items(): This method returns key-value pairs (student name and grades list) from the dictionary.
• average_grade = sum(grades) / len(grades): This line calculates the average grade for the current student:
  • sum(grades): Calculates the sum of the grades in the list.
  • len(grades): Gets the number of grades in the list.
  • The result is the average.
• print(f"{student}'s average grade: {average_grade:.2f}"): This line prints the student's name and their average grade, formatted to two decimal places.

The output of this code will be:

Alice's average grade: 85.00
Bob's average grade: 86.33
Charlie's average grade: 86.67

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("Error: Cannot divide by zero!")
        return None

result1 = safe_divide(10, 2)
result2 = safe_divide(5, 0)

print(f"Result 1: {result1}, Result 2: {result2}")

Code Explanation

The code defines a function that performs division and handles a potential error:

• def safe_divide(a, b):: This defines a function named safe_divide that takes two arguments, a (the numerator) and b (the denominator).
• try:: This block of code attempts to perform the division a / b.
• return a / b: If the division is successful (i.e., b is not zero), the function returns the result of the division.
• except ZeroDivisionError:: This block of code handles the specific error that occurs when you try to divide by zero.
• print("Error: Cannot divide by zero!"): If a ZeroDivisionError occurs, this line prints an error message to the console.
• return None: The function returns None to indicate that the division could not be performed.
• result1 = safe_divide(10, 2): This line calls safe_divide with a = 10 and b = 2. The division is successful, and the result (5.0) is stored in result1.
• result2 = safe_divide(5, 0): This line calls safe_divide with a = 5 and b = 0. This time, a ZeroDivisionError occurs. The function prints an error message and returns None, which is stored in result2.
• print(f"Result 1: {result1}, Result 2: {result2}"): This line prints the values of result1 and result2.

The output of this code will be:

Error: Cannot divide by zero!
Result 1: 5.0, Result 2: None

numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers))
odd_numbers = list(filter(lambda x: x % 2 != 0, numbers))

print(f"Doubled numbers: {doubled}")
print(f"Odd numbers: {odd_numbers}")

Code Explanation

The code demonstrates the use of map and filter functions with lambda expressions:

• numbers = [1, 2, 3, 4, 5]: A list named numbers is initialized with the integers from 1 to 5.
• doubled = list(map(lambda x: x * 2, numbers)):
  • map(lambda x: x * 2, numbers): The map function applies a given function to each item in an iterable (in this case, the numbers list).
    • lambda x: x * 2: This is a lambda expression, which is a small, anonymous function. It takes one argument (`x`) and returns that argument multiplied by 2.
  • list(...): The result of `map` is a map object, which is then converted into a list. The doubled list will contain each number from the numbers list, doubled.
• odd_numbers = list(filter(lambda x: x % 2 != 0, numbers)):
  • filter(lambda x: x % 2 != 0, numbers): The filter function creates a new iterable containing only the items from the original iterable for which a given function returns `True`.
    • lambda x: x % 2 != 0: This lambda expression takes one argument (`x`) and returns `True` if `x` is odd (i.e., the remainder when divided by 2 is not 0), and `False` otherwise.
  • list(...): The result of `filter` is a filter object, which is converted into a list. The odd_numbers list will contain only the odd numbers from the numbers list.
• print(f"Doubled numbers: {doubled}"): This line prints the doubled list.
• print(f"Odd numbers: {odd_numbers}"): This line prints the odd_numbers list.

The output of this code will be:

Doubled numbers: [2, 4, 6, 8, 10]
Odd numbers: [1, 3, 5]