class MagicToyBox(type):
    def __init__(cls, name, bases, attrs):
        cls._toy_counter = 0
        super().__init__(name, bases, attrs)

    def __call__(cls, *args, **kwargs):
        cls._toy_counter += 1
        return super().__call__(*args, **kwargs)

class Toy(metaclass=MagicToyBox):
    def __init__(self, fun_shape):
        self.fun_shape = fun_shape

toy1 = Toy("🚗")
toy2 = Toy("🐻")
toy3 = Toy("🦕")

print(f"How many toys in the box? {Toy._toy_counter}")

# Import the necessary libraries if needed (in this case, none are needed).

# Define a metaclass called MagicToyBox using Python's built-in 'type' metaclass.
# A metaclass in Python is a class of a class that defines how classes behave.
class MagicToyBox(type):
    # The __init__ method of the metaclass is similar to an ordinary class's __init__ method.
    # It initializes the metaclass itself and is called when a new class using this metaclass is created.
    def __init__(cls, name, bases, attrs):
        # 'cls' refers to the newly created class using this metaclass.
        # Initialize a class attribute _toy_counter to zero to count how many instances of the class are created.
        cls._toy_counter = 0
        # Call the base class (type)'s __init__ method to complete the initialization.
        super().__init__(name, bases, attrs)

    # The __call__ method is invoked when an instance of a class (that uses MagicToyBox as a metaclass) is created.
    def __call__(cls, *args, **kwargs):
        # Increment the toy counter every time a new toy instance is created.
        cls._toy_counter += 1
        # Call the parent class's __call__ method to proceed with creating the new instance.
        return super().__call__(*args, **kwargs)

# Define a class called Toy that uses MagicToyBox as its metaclass.
# The line "metaclass=MagicToyBox" means any class behavior defined in the metaclass will apply to Toy.
class Toy(metaclass=MagicToyBox):
    # The __init__ method is called whenever an instance of Toy is created.
    def __init__(self, fun_shape):
        # 'fun_shape' is a parameter that represents the shape of the toy, such as a car, bear, or dinosaur.
        # It is stored as an instance attribute, meaning each Toy instance can have a different fun_shape.
        self.fun_shape = fun_shape

# Create different instances of the Toy class, passing different emoji shapes as arguments.
toy1 = Toy("🚗")  # An instance of Toy representing a toy car.
toy2 = Toy("🐻")  # An instance of Toy representing a toy bear.
toy3 = Toy("🦕")  # An instance of Toy representing a toy dinosaur.

# Output the total number of Toy instances created. The _toy_counter class attribute keeps track of this.
# By accessing Toy._toy_counter, we get the total count of toy instances created so far.
print(f"How many toys in the box? {Toy._toy_counter}")

dict1 = {"a": 1, "b": 2}
dict2 = {"a": 1, "b": 3}
print(dict1 != dict2)

# Define the first dictionary named `dict1`
# This dictionary has two key-value pairs: 
# Key "a" with value 1
# Key "b" with value 2
dict1 = {"a": 1, "b": 2}

# Define the second dictionary named `dict2`
# This dictionary also has two key-value pairs:
# Key "a" with value 1
# Key "b" with a different value, 3
dict2 = {"a": 1, "b": 3}

# Use the inequality operator (!=) to compare dict1 and dict2
# The `!=` operator checks if the two dictionaries are not equal
# Two dictionaries are considered equal if they have the same key-value pairs
# Since dict1 and dict2 differ in the value associated with the key "b", they are not equal
result = dict1 != dict2

# Print the result of the comparison
# Since dict1 and dict2 have different values for key "b" (2 in dict1, 3 in dict2),
# the result of the comparison is True
print(result)  # Output: True

x = ['🥦', '🥕', '🌽']
y = x[:]
y.append('🍅')
print(x)

# Create a list 'x' containing three emoji elements representing vegetables.
x = ['🥦', '🥕', '🌽']

# Create a new list 'y' by slicing the entire list 'x'.
# The colon (:) slice operation creates a shallow copy of 'x'.
# This means 'y' is a new list with the same elements as 'x',
# but 'y' and 'x' are separate objects in memory.
y = x[:]

# Append the emoji '🍅' (representing a tomato) to the end of the list 'y'.
# This modifies the list 'y' by adding one more element to it.
y.append('🍅')

# Print out the original list 'x'.
# Even though we modified 'y', the list 'x' remains unchanged because
# 'y' is a separate copy due to the slicing operation used earlier.
print(x)

from collections import deque

my_deque = deque(['a', 'b', 'c'])

my_deque.append('d')
my_deque.appendleft('z')
my_deque.pop()

print(list(my_deque))

# Importing the deque class from the collections module.
# The collections module provides alternatives to Python’s general-purpose built-in containers like dict, list, set, and tuple.
from collections import deque

# Creating a deque (double-ended queue) object named my_deque with an initial list ['a', 'b', 'c'].
# A deque allows for fast and efficient appends and pops from both ends.
my_deque = deque(['a', 'b', 'c'])

# Append 'd' to the right end of the deque.
# After this operation, my_deque becomes: deque(['a', 'b', 'c', 'd'])
my_deque.append('d')

# Append 'z' to the left end of the deque.
# After this operation, my_deque becomes: deque(['z', 'a', 'b', 'c', 'd'])
my_deque.appendleft('z')

# Pop an element from the right end of the deque and return it.
# The element 'd' will be removed.
# After this operation, my_deque becomes: deque(['z', 'a', 'b', 'c'])
my_deque.pop()

# Convert the deque to a list and print it.
# The result will be: ['z', 'a', 'b', 'c']
# Lists are commonly used in Python, and converting a deque to a list can be helpful for certain operations.
print(list(my_deque))

def check_numbers(nums):
    for num in nums:
        if num < 0:
            print("Found a negative number:", num)
            break
    else:
        print("All numbers are non-negative.")

nums = [1, 2, 3, 4]
check_numbers(nums)

# Define a function named 'check_numbers' which takes one parameter 'nums'
# 'nums' should be a list of numbers.
def check_numbers(nums):

    # Start a for-loop to iterate over each element (number) in the 'nums' list.
    for num in nums:

        # Check if the current number 'num' is less than 0 (negative).
        if num < 0:
            # If a negative number is found, print a message with the negative number.
            print("Found a negative number:", num)
            # Break out of the loop since we found a negative number; no need to check further.
            break

    # The else block associated with a for-loop only executes if the loop completes
    # without hitting a break statement. This means no negative numbers were found.
    else:
        # Since the loop completed without finding a negative number, print a message
        # indicating all numbers are non-negative.
        print("All numbers are non-negative.")

# Create a list 'nums' with positive numbers.
nums = [1, 2, 3, 4]

# Call the 'check_numbers' function with the 'nums' list.
# This will check each number in the list for negativity and respond accordingly.
check_numbers(nums)