from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Bark"

class Cat(Animal):
    def make_sound(self):
        return "Meow"

# Создание экземпляров конкретных классов
dog = Dog()
cat = Cat()

print(dog.make_sound())  # Выведет: Bark
print(cat.make_sound())  # Выведет: Meow

# Попытка создания экземпляра абстрактного класса приведет к ошибке
# animal = Animal()  # TypeError: Can't instantiate abstract class Animal with abstract methods make_sound

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Bark"

class Cat(Animal):
    def make_sound(self):
        return "Meow"

def make_animal_sound(animal):
    print(animal.make_sound())

# Использование полиморфизма подтипов
dog = Dog()
cat = Cat()

make_animal_sound(dog)  # Выведет: Bark
make_animal_sound(cat)  # Выведет: Meow

def add(a, b):
    return a + b

print(add(1, 2))         # Выведет: 3 (работает с числами)
print(add("Hello, ", "World!"))  # Выведет: Hello, World! (работает со строками)

class Duck:
    def quack(self):
        return "Quack"

class Person:
    def quack(self):
        return "I can imitate a duck"

def make_it_quack(duck_like):
    print(duck_like.quack())

duck = Duck()
person = Person()

make_it_quack(duck)   # Выведет: Quack
make_it_quack(person) # Выведет: I can imitate a duck

def apply_function(func, value):
    return func(value)

def square(x):
    return x * x

def double(x):
    return x * 2

print(apply_function(square, 4))  # Выведет: 16
print(apply_function(double, 4))  # Выведет: 8

# Создание списка
my_list = [1, 2, 3, 4, 5]

# Создание итератора из списка
my_iterator = iter(my_list)

# Перебор элементов с помощью итератора
print(next(my_iterator))  # Выведет: 1
print(next(my_iterator))  # Выведет: 2
print(next(my_iterator))  # Выведет: 3
print(next(my_iterator))  # Выведет: 4
print(next(my_iterator))  # Выведет: 5

# Следующий вызов next() вызовет исключение StopIteration
# print(next(my_iterator))  # StopIteration

my_string = "hello"
my_iterator = iter(my_string)

print(next(my_iterator))  # Выведет: h
print(next(my_iterator))  # Выведет: e
print(next(my_iterator))  # Выведет: l
print(next(my_iterator))  # Выведет: l
print(next(my_iterator))  # Выведет: o

my_tuple = (10, 20, 30)
my_iterator = iter(my_tuple)

print(next(my_iterator))  # Выведет: 10
print(next(my_iterator))  # Выведет: 20
print(next(my_iterator))  # Выведет: 30

my_set = {1, 2, 3}
my_iterator = iter(my_set)

print(next(my_iterator))  # Выведет один из элементов множества (порядок не гарантирован)
print(next(my_iterator))  # Выведет другой элемент множества
print(next(my_iterator))  # Выведет оставшийся элемент множества

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_iterator = iter(my_dict)

print(next(my_iterator))  # Выведет: a
print(next(my_iterator))  # Выведет: b
print(next(my_iterator))  # Выведет: c

class MyIterator:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.end:
            self.current += 1
            return self.current - 1
        else:
            raise StopIteration

# Использование пользовательского итератора
my_iter = MyIterator(1, 5)

for num in my_iter:
    print(num)  # Выведет: 1 2 3 4

class MyRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.end:
            current = self.current
            self.current += 1
            return current
        else:
            raise StopIteration

# Использование класса MyRange
my_range = MyRange(1, 5)

for number in my_range:
    print(number)  # Выведет: 1 2 3 4

class MyListIterator:
    def init(self, my_list):
        self.my_list = my_list
        self.index = 0

    def iter(self):
        return self

    def next():
        if self.index < len(self.my_list):
            result = self.my_list[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

# Использование класса MyListIterator
my_list = [10, 20, 30, 40]
my_iterator = MyListIterator(my_list)

for item in my_iterator:
    print(item)  # Выведет: 10 20 30 40

class ResettableRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end
        self.current = start

    def __iter__(self):
        self.current = self.start  # Сброс текущего значения при начале новой итерации
        return self

    def __next__(self):
        if self.current < self.end:
            current = self.current
            self.current += 1
            return current
        else:
            raise StopIteration

# Использование класса ResettableRange
resettable_range = ResettableRange(1, 5)

# Первый цикл
for number in resettable_range:
    print(number)  # Выведет: 1 2 3 4

# Второй цикл
for number in resettable_range:
    print(number)  # Снова выведет: 1 2 3 4

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