import atexit

# Register the exit_handler function
@atexit.register
def exit_handler():
 print("Exiting the program. Cleanup tasks can be performed here.")

# Rest of the program
def main():
 print("Inside the main function.")
 # Your program logic goes here.

if __name__ == "__main__":
 main()

Inside the main function.
Exiting the program. Cleanup tasks can be performed here.

from dataclasses import dataclass

@dataclass
class Point:
 x: int
 y: int


point = Point(x=3, y=2)
# Printing object
print(point)

# Checking for the equality of two objects
point1 = Point(x=1, y=2)
point2 = Point(x=1, y=2)
print(point1 == point2)

輸出：
Point(x=3, y=2)
True

from enum import Enum, unique

@unique
class VehicleType(Enum):
 CAR = 1
 TRUCK = 2
 MOTORCYCLE = 3
 BUS = 4

# Attempting to create an enumeration with a duplicate value will raise a ValueError
try:
 @unique
 class DuplicateVehicleType(Enum):
 CAR = 1
 TRUCK = 2
 MOTORCYCLE = 3
 # BUS and MOTORCYCLE have duplicate values
 BUS = 3
except ValueError as e:
 print(f"Error: {e}")

Error: duplicate values found in : BUS -> MOTORCYCLE

from functools import partial

# Original function
def power(base, exponent):
 return base ** exponent

# Creating a partial function with the exponent fixed to 2
square = partial(power, expnotallow=2)

# Using the partial function
result = square(3)
print("Output:",result)

Output: 9

from functools import singledispatch

# Decorator
@singledispatch
def display_info(arg):
 print(f"Generic: {arg}")

# Registering specialized implementations for different types
@display_info.register(int)
def display_int(arg):
 print(f"Received an integer: {arg}")

@display_info.register(float)
def display_float(arg):
 print(f"Received a float: {arg}")

@display_info.register(str)
def display_str(arg):
 print(f"Received a string: {arg}")

@display_info.register(list)
def display_sequence(arg):
 print(f"Received a sequence: {arg}")

# Using the generic function with different types
display_info(39) 
display_info(3.19) 
display_info("Hello World!")
display_info([2, 4, 6]) 

Received an integer: 39
Received a float: 3.19
Received a string: Hello World!
Received a sequence: [2, 4, 6]

class Student:
 total_students = 0

 def __init__(self, name, age):
 self.name = name
 self.age = age
 Student.total_students += 1

 @classmethod
 def increment_total_students(cls):
 cls.total_students += 1
 print(f"Class method called. Total students now: {cls.total_students}")

# Creating instances of the class
student1 = Student(name="Tom", age=20)
student2 = Student(name="Cruise", age=22)

# Calling the class method
Student.increment_total_students() #Total students now: 3

# Accessing the class variable
print(f"Total students from student 1: {student1.total_students}")
print(f"Total students from student 2: {student2.total_students}")

Class method called. Total students now: 3
Total students from student 1: 3
Total students from student 2: 3

class MathOperations:
 @staticmethod
 def add(x, y):
 return x + y

 @staticmethod
 def subtract(x, y):
 return x - y

# Using the static methods without creating an instance of the class
sum_result = MathOperations.add(5, 4)
difference_result = MathOperations.subtract(8, 3)

print("Sum:", sum_result) 
print("Difference:", difference_result)

Sum: 9
Difference: 5

class Circle:
 def __init__(self, radius):
 self._radius = radius

 @property
 def radius(self):
 # Getter method for the radius.
 return self._radius

 @property
 def area(self):
 # Getter method for the area.
 return 3.14 * self._radius**2

# Creating an instance of the Circle class
my_circle = Circle(radius=5)

# Accessing properties using the @property decorator
print("Radius:", my_circle.radius) 
print("Area:", my_circle.area) 

Radius: 5
Area: 78.5