class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        if self.file:
            self.file.close()

# Использование класса FileManager в конструкции with
with FileManager('example.txt', 'w') as file:
    file.write('Hello, world!')

# После выхода из блока with файл будет закрыт автоматически

1️⃣

Конструктор

elf.file.cl

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        if self.file:
            self.file.close()
        if exc_type is not None:
            print(f"An exception occurred: {exc_value}")
            return True  # Подавляет исключение

# Использование класса FileManager с исключением
try:
    with FileManager('example.txt', 'w') as file:
        file.write('Hello, world!')
        raise ValueError("An intentional error")
except ValueError:
    print("ValueError caught")

# После выхода из блока with файл будет закрыт автоматически

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Создание экземпляра класса Person
person1 = Person("Alice", 30)
print(person1.name)  # Выведет: Alice
print(person1.age)   # Выведет: 30

class Car:
    def __init__(self, brand, model, year):
        self.brand = brand
        self.model = model
        self.year = year

    def display_info(self):
        print(f"{self.brand} {self.model}, {self.year}")

# Создание экземпляров класса Car
car1 = Car("Toyota", "Corolla", 2020)
car2 = Car("Honda", "Civic", 2019)

car1.display_info()  # Выведет: Toyota Corolla, 2020
car2.display_info()  # Выведет: Honda Civic, 2019

class MyClass:
    class_attribute = 0

    @classmethod
    def increment_class_attribute(cls):
        cls.class_attribute += 1

# Вызов метода класса
MyClass.increment_class_attribute()
print(MyClass.class_attribute)  # Выведет: 1

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_birth_year(cls, name, birth_year):
        age = 2024 - birth_year
        return cls(name, age)

# Создание экземпляров класса Person
person1 = Person("Alice", 30)
person2 = Person.from_birth_year("Bob", 1990)

print(person1.name, person1.age)  # Выведет: Alice 30
print(person2.name, person2.age)  # Выведет: Bob 34

class MyClass:
    def __init__(self, value):
        self.value = value

    def instance_method(self):
        return self.value

# Создание экземпляра и вызов метода
obj = MyClass(10)
print(obj.instance_method())  # Выведет: 10

class MyClass:
    class_value = 0

    @classmethod
    def class_method(cls):
        return cls.class_value

# Вызов метода класса
print(MyClass.class_method())  # Выведет: 0

class MyClass:
    class_attribute = 0

    def __init__(self, value):
        self.value = value

    def instance_method(self):
        return self.value

    @classmethod
    def class_method(cls):
        return cls.class_attribute

# Создание экземпляра и вызов методов
obj = MyClass(10)
print(obj.instance_method())     # Выведет: 10 (использует атрибут экземпляра)
print(MyClass.class_method())    # Выведет: 0 (использует атрибут класса)

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.speak())  # Выведет: Buddy says Woof!
print(cat.speak())  # Выведет: Whiskers says Meow!

class Bird(Animal):
    def __init__(self, name, can_fly):
        super().__init__(name)
        self.can_fly = can_fly

    def speak(self):
        return f"{self.name} says Tweet!"

class Flyer:
    def fly(self):
        return "Flying high!"

class Swimmer:
    def swim(self):
        return "Swimming fast!"

class Duck(Animal, Flyer, Swimmer):
    def speak(self):
        return f"{self.name} says Quack!"

animals = [Dog("Buddy"), Cat("Whiskers"), Duck("Donald")]

for animal in animals:
    print(animal.speak())

# Выведет:
# Buddy says Woof!
# Whiskers says Meow!
# Donald says Quack!

class Address:
    def __init__(self, street, city):
        self.street = street
        self.city = city

    def display(self):
        return f"{self.street}, {self.city}"

class Person:
    def __init__(self, name, address):
        self.name = name
        self.address = address  # Агрегация

    def display(self):
        return f"{self.name} lives at {self.address.display()}"

# Создание объектов Address и Person
address = Address("123 Main St", "New York")
person = Person("John Doe", address)

print(person.display())  # Выведет: John Doe lives at 123 Main St, New York

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

class Car:
    def __init__(self, model, engine):
        self.model = model
        self.engine = engine  # Агрегация

engine = Engine(150)
car = Car("Toyota", engine)

# Удаление объекта car не удаляет объект engine
del car
print(engine.horsepower)  # Выведет: 150

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

class Car:
    def __init__(self, model, horsepower):
        self.model = model
        self.engine = Engine(horsepower)  # Композиция

car = Car("Toyota", 150)

# Удаление объекта car также удаляет объект engine
del car
# Теперь доступ к engine невозможен

      class Service:
       def do_something(self):
           return "Service is doing something."

   class Client:
       def __init__(self, service):
           self.service = service

       def perform_action(self):
           return self.service.do_something()

   # Внедрение зависимости через конструктор
   service = Service()
   client = Client(service)
   print(client.perform_action())  # Выведет: Service is doing something.
   

      class Client:
       def set_service(self, service):
           self.service = service

       def perform_action(self):
           return self.service.do_something()

   # Внедрение зависимости через сеттер
   service = Service()
   client = Client()
   client.set_service(service)
   print(client.perform_action())  # Выведет: Service is doing something.
   

class OrderService:
    def process_order(self, order_id):
        return f"Processing order {order_id}"

class OrderController:
    def __init__(self, order_service):
        self.order_service = order_service

    def handle_request(self, order_id):
        return self.order_service.process_order(order_id)

# Внедрение зависимости через конструктор
order_service = OrderService()
order_controller = OrderController(order_service)
print(order_controller.handle_request(123))  # Выведет: Processing order 123