obj.attr        # чтение
obj.attr = 10   # запись
del obj.attr    # удаление

__get__()
__set__()
__delete__()

class AgeDescriptor:
    def __get__(self, instance, owner):
        return instance._age

    def __set__(self, instance, value):
        if value < 0:
            raise ValueError("Возраст не может быть отрицательным")
        instance._age = value


class User:
    age = AgeDescriptor()

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


user = User(20)

print(user.age)  # вызывается __get__

user.age = 25    # вызывается __set__

user.age = -5    # ValueError

user.age

AgeDescriptor.__get__(...)

user.age = 25

AgeDescriptor.__set__(...)

class User:
    age = AgeDescriptor()

user.age = AgeDescriptor()

def __get__(self, instance, owner):
    ...

user.age

def __set__(self, instance, value):
    ...

user.age = 30

def __delete__(self, instance):
    ...

del user.age

class Descriptor:
    def __get__(self, instance, owner):
        ...

    def __set__(self, instance, value):
        ...

class Descriptor:
    def __get__(self, instance, owner):
        ...

class User:
    def __init__(self, age):
        self._age = age

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, value):
        if value < 0:
            raise ValueError("Возраст не может быть отрицательным")
        self._age = value

user.age

user.age = 30

class User:
    def say_hello(self):
        print("Hello")


user = User()
user.say_hello()

user.say_hello

User.say_hello(user)

- @property
- @classmethod
- @staticmethod
- обычные методы класса
- ORM-поля в Django / SQLAlchemy
- валидация атрибутов
- ленивые вычисления
- контроль доступа к данным

class User:
    name = StringField()
    age = IntegerField()

class PositiveNumber:
    def __set_name__(self, owner, name):
        self.private_name = "_" + name

    def __get__(self, instance, owner):
        return getattr(instance, self.private_name)

    def __set__(self, instance, value):
        if value <= 0:
            raise ValueError("Значение должно быть положительным")
        setattr(instance, self.private_name, value)


class Product:
    price = PositiveNumber()

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


product = Product(100)

print(product.price)  # 100

product.price = 200
print(product.price)  # 200

product.price = -50   # ValueError

__set_name__(self, owner, name)

obj.attr
obj.attr = value
del obj.attr

descriptor.__get__(instance, owner)

class Descriptor:
    def __get__(self, instance, owner):
        print("__get__ вызван")
        return 100


class User:
    age = Descriptor()


user = User()

print(user.age)

__get__ вызван
100

user.age

descriptor.__set__(instance, value)

class Descriptor:
    def __get__(self, instance, owner):
        return instance._age

    def __set__(self, instance, value):
        print("__set__ вызван")
        instance._age = value


class User:
    age = Descriptor()


user = User()

user.age = 20
print(user.age)

__set__ вызван
20

user.age = 20

Descriptor.__set__(...)

descriptor.__delete__(instance)

class Descriptor:
    def __get__(self, instance, owner):
        return instance._age

    def __set__(self, instance, value):
        instance._age = value

    def __delete__(self, instance):
        print("__delete__ вызван")
        del instance._age


class User:
    age = Descriptor()


user = User()
user.age = 20

del user.age

__delete__ вызван

class User:
    age = Descriptor()

user = User()
user.age = Descriptor()

user.age

user.age

User.age

class Descriptor:
    def __get__(self, instance, owner):
        print(instance)
        print(owner)
        return 100


class User:
    age = Descriptor()


print(User.age)

class LoggedAttribute:
    def __get__(self, instance, owner):
        print("Чтение атрибута")
        return instance._value

    def __set__(self, instance, value):
        print("Запись атрибута")
        instance._value = value

    def __delete__(self, instance):
        print("Удаление атрибута")
        del instance._value


class Example:
    value = LoggedAttribute()


obj = Example()

obj.value = 10      # Запись атрибута
print(obj.value)    # Чтение атрибута
del obj.value       # Удаление атрибута

def __get__(self, instance, owner):
    ...

obj.attr

Class.attr

def __get__(self, instance, owner):
    ...

class Descriptor:
    def __get__(self, instance, owner):
        print("self:", self)
        print("instance:", instance)
        print("owner:", owner)
        return "value"


class User:
    name = Descriptor()


user = User()

print(user.name)

user.name

User.__dict__["name"].__get__(user, User)

self      -> Descriptor()
instance  -> user
owner     -> User

class Descriptor:
    def __get__(self, instance, owner):
        return "Чтение через объект"


class User:
    name = Descriptor()


user = User()

print(user.name)

Чтение через объект

class Descriptor:
    def __get__(self, instance, owner):
        print(instance)
        print(owner)
        return "Чтение через класс"


class User:
    name = Descriptor()


print(User.name)

None
<class '__main__.User'>
Чтение через класс

User.__dict__["name"].__get__(None, User)

class Descriptor:
    def __get__(self, instance, owner):
        if instance is None:
            return self

        return instance.__dict__["value"]

class Field:
    def __get__(self, instance, owner):
        if instance is None:
            return self

        return instance.__dict__["value"]


class User:
    name = Field()


user = User()
user.__dict__["value"] = "Alex"

print(user.name)  # Alex
print(User.name)  # <__main__.Field object ...>

class NameDescriptor:
    def __get__(self, instance, owner):
        if instance is None:
            return self

        return instance.__dict__["name"]

    def __set__(self, instance, value):
        instance.__dict__["name"] = value


class User:
    name = NameDescriptor()


user = User()

user.name = "Alex"

print(user.name)

user.name = "Alex"

NameDescriptor.__set__(user, "Alex")

print(user.name)

NameDescriptor.__get__(user, User)

class User:
    name = NameDescriptor()

class BadDescriptor:
    def __get__(self, instance, owner):
        return self.value

    def __set__(self, instance, value):
        self.value = value

class User:
    name = BadDescriptor()


user1 = User()
user2 = User()

user1.name = "Alex"
user2.name = "Bob"

print(user1.name)  # Bob
print(user2.name)  # Bob

class GoodDescriptor:
    def __get__(self, instance, owner):
        return instance.__dict__["name"]

    def __set__(self, instance, value):
        instance.__dict__["name"] = value

class Field:
    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, instance, owner):
        if instance is None:
            return self

        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        instance.__dict__[self.name] = value


class User:
    name = Field()
    age = Field()


user = User()

user.name = "Alex"
user.age = 20

print(user.name)  # Alex
print(user.age)   # 20

class PositiveNumber:
    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, instance, owner):
        if instance is None:
            return self

        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if value <= 0:
            raise ValueError("Значение должно быть положительным")

        instance.__dict__[self.name] = value


class Product:
    price = PositiveNumber()

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


product = Product(100)

print(product.price)  # 100

product.price = -10   # ValueError

product.price

product.price = 100

class User:
    def say_hello(self):
        print("Hello")


user = User()

user.say_hello()

user.say_hello

user.say_hello()

User.say_hello(user)

class SomeClass:
    def __del__(self):
        ...

class User:
    def __init__(self, name):
        self.name = name
        print(f"Создан объект {self.name}")

    def __del__(self):
        print(f"Удаляется объект {self.name}")


user = User("Alex")

del user

Создан объект Alex
Удаляется объект Alex

del user

class User:
    def __del__(self):
        print("Объект удалён")


user1 = User()
user2 = user1

del user1

print("После del user1")

del user2

print("После del user2")

После del user1
Объект удалён
После del user2

user1 = User()
user2 = user1

del user1

del user2

class FileWrapper:
    def __init__(self, path):
        self.file = open(path)

    def __del__(self):
        self.file.close()

with open("file.txt") as file:
    data = file.read()

class FileWrapper:
    def __init__(self, path):
        self.path = path
        self.file = None

    def __enter__(self):
        self.file = open(self.path)
        return self.file

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


with FileWrapper("file.txt") as file:
    data = file.read()

class Node:
    def __init__(self):
        self.other = None

    def __del__(self):
        print("Node удалён")


a = Node()
b = Node()

a.other = b
b.other = a

del a
del b

a -> b
b -> a

class User:
    def __del__(self):
        print("Объект уничтожается")

class Descriptor:
    def __delete__(self, instance):
        print("Атрибут удаляется")

class User:
    def __delattr__(self, name):
        print(f"Удаляется атрибут {name}")
        super().__delattr__(name)


user = User()
user.name = "Alex"

del user.name

Удаляется атрибут name

class User:
    def __del__(self):
        print("Удаляется объект")

logger = get_logger()

class Service:
    def __del__(self):
        logger.info("Service destroyed")

class Connection:
    def close(self):
        print("Соединение закрыто")

    def __del__(self):
        try:
            self.close()
        except Exception:
            pass

connection.close()

with connection:
    ...

obj.attr = value

def __set__(self, instance, value):
    ...

def __set__(self, instance, value):
    ...

class AgeDescriptor:
    def __set__(self, instance, value):
        print("__set__ вызван")
        instance.__dict__["age"] = value


class User:
    age = AgeDescriptor()


user = User()

user.age = 20

user.age = 20

User.__dict__["age"].__set__(user, 20)

__set__ вызван

class User:
    age = AgeDescriptor()

user.age = AgeDescriptor()

class PositiveNumber:
    def __set__(self, instance, value):
        if value <= 0:
            raise ValueError("Значение должно быть положительным")

        instance.__dict__["number"] = value


class Product:
    price = PositiveNumber()


product = Product()

product.price = 100
print(product.__dict__)

product.price = -50

{'number': 100}ValueError: Значение должно быть положительным

product.price = 100

class PositiveNumber:
    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, instance, owner):
        if instance is None:
            return self

        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if value <= 0:
            raise ValueError(f"{self.name} должно быть положительным")

        instance.__dict__[self.name] = value


class Product:
    price = PositiveNumber()
    quantity = PositiveNumber()


product = Product()

product.price = 100
product.quantity = 5

print(product.price)     # 100
print(product.quantity)  # 5

class Descriptor:
    def __get__(self, instance, owner):
        return "значение из дескриптора"

    def __set__(self, instance, value):
        instance.__dict__["attr"] = value


class Example:
    attr = Descriptor()


obj = Example()

obj.__dict__["attr"] = "значение из __dict__"

print(obj.attr)

значение из дескриптора

obj.__dict__["attr"]

class WriteOnly:
    def __set__(self, instance, value):
        print(f"Записано: {value}")


class User:
    name = WriteOnly()


user = User()

user.name = "Alex"

Записано: Alex

print(user.name)

__get__
__set__

class Descriptor:
    def __set__(self, instance, value):
        ...

user.age = 20

class User:
    def __setattr__(self, name, value):
        ...

user.name = "Alex"
user.age = 20
user.email = "a@example.com"

class User:
    def __setattr__(self, name, value):
        print(f"Записывается атрибут {name}")
        super().__setattr__(name, value)


user = User()
user.name = "Alex"
user.age = 20

Записывается атрибут name
Записывается атрибут age

class StringField:
    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, instance, owner):
        if instance is None:
            return self

        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if not isinstance(value, str):
            raise TypeError(f"{self.name} должно быть строкой")

        instance.__dict__[self.name] = value


class User:
    username = StringField()


user = User()

user.username = "user"
print(user.username)

user.username = 123

user
TypeError: username должно быть строкой

obj = MyClass(...)

obj = MyClass.__new__(MyClass, ...)
MyClass.__init__(obj, ...)

__new__  → создаёт объект
__init__ → настраивает уже созданный объект

class User:
    def __init__(self, username: str, age: int):
        self.username = username
        self.age = age


user = User("Alex", 20)

print(user.username)  # Alex
print(user.age)       # 20

class User:
    def __init__(self):
        return "created"

TypeError: __init__() should return None

class User:
    def __new__(cls, *args, **kwargs):
        print("__new__: создаём объект")
        obj = super().__new__(cls)
        return obj

    def __init__(self, username):
        print("__init__: инициализируем объект")
        self.username = username


user = User("Alex")

__new__: создаём объект
__init__: инициализируем объект

def __new__(cls, *args, **kwargs):
    ...

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

class Product:
    def __init__(self, title, price):
        self.title = title
        self.price = price

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)

        return cls._instance


a = Singleton()
b = Singleton()

print(a is b)  # True

class Test:
    def __new__(cls):
        print("__new__")
        return "not Test object"

    def __init__(self):
        print("__init__")


obj = Test()

print(obj)

__new__
not Test object

class UpperStr(str):
    def __new__(cls, value):
        return super().__new__(cls, value.upper())


text = UpperStr("hello")

print(text)        # HELLO
print(type(text))  # <class '__main__.UpperStr'>

class User:
    def __new__(cls, *args, **kwargs):
        print("Создание объекта")
        return super().__new__(cls)

    def __init__(self, name):
        print("Инициализация объекта")
        self.name = name

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

    def __str__(self):
        return f"User: {self.name}"

    def __repr__(self):
        return f"User(name={self.name!r})"


user = User("Alex")

print(str(user))   # User: Alex
print(repr(user))  # User(name='Alex')

class Product:
    def __init__(self, price):
        self.price = price

    def __lt__(self, other):
        return self.price < other.price

    def __eq__(self, other):
        return self.price == other.price


a = Product(100)
b = Product(200)

print(a < b)   # True
print(a == b)  # False

class Money:
    def __init__(self, amount):
        self.amount = amount

    def __add__(self, other):
        return Money(self.amount + other.amount)


a = Money(100)
b = Money(50)

result = a + b

print(result.amount)  # 150

a + b

type(a).__add__(a, b)

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

    def __radd__(self, other):
        return self.value + other


x = Number(10)

print(5 + x)  # 15

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

    def __iadd__(self, other):
        self.value += other
        return self


counter = Counter(10)
counter += 5

print(counter.value)  # 15

class Balance:
    def __init__(self, amount):
        self.amount = amount

    def __neg__(self):
        return Balance(-self.amount)


balance = Balance(100)
negative = -balance

print(negative.amount)  # -100

class Cart:
    def __init__(self, items):
        self.items = items

    def __bool__(self):
        return len(self.items) > 0


cart = Cart([])

if cart:
    print("Корзина не пустая")
else:
    print("Корзина пустая")

class Users:
    def __init__(self):
        self._users = ["Alex", "Bob", "John"]

    def __len__(self):
        return len(self._users)

    def __getitem__(self, index):
        return self._users[index]

    def __contains__(self, user):
        return user in self._users


users = Users()

print(len(users))      # 3
print(users[0])        # Alex
print("Bob" in users)  # True

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

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration

        value = self.current
        self.current -= 1
        return value


for number in Countdown(3):
    print(number)

3
2
1

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, value):
        return value * self.factor


double = Multiplier(2)

print(double(10))  # 20

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

    def __getattr__(self, name):
        return f"Атрибут {name} не найден"


user = User("Alex")

print(user.name)     # Alex
print(user.age)      # Атрибут age не найден

__getattribute__ вызывается всегда
__getattr__ вызывается только если атрибут не найден

class PositiveNumber:
    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, instance, owner):
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if value <= 0:
            raise ValueError("Значение должно быть положительным")

        instance.__dict__[self.name] = value


class Product:
    price = PositiveNumber()


product = Product()
product.price = 100

print(product.price)  # 100

class FileManager:
    def __enter__(self):
        print("Открываем ресурс")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Закрываем ресурс")


with FileManager():
    print("Работаем с ресурсом")

Открываем ресурс
Работаем с ресурсом
Закрываем ресурс

class AsyncContext:
    async def __aenter__(self):
        print("Вход")
        return self

    async def __aexit__(self, exc_type, exc, tb):
        print("Выход")


async with AsyncContext():
    print("Работа внутри async with")

class Point:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x = x
        self.y = y


point = Point(1, 2)

point.z = 3  # AttributeError

class Base:
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        print(f"Создан подкласс: {cls.__name__}")


class Child(Base):
    pass

Создан подкласс: Child

len(obj)      # вызывает __len__
obj[key]      # вызывает __getitem__
obj + other   # вызывает __add__
for x in obj  # вызывает __iter__ и __next__
with obj:     # вызывает __enter__ и __exit__
obj()         # вызывает __call__

__init__
__str__
__repr__
__eq__
__hash__
__len__
__getitem__
__setitem__
__iter__
__next__
__enter__
__exit__
__getattr__
__setattr__
__call__

class User:
    pass


print(type(User))  # <class 'type'>

__prepare__
__new__
__init__
__call__

__prepare__ → тело класса → __new__ → __init__

class Meta(type):
    @classmethod
    def __prepare__(mcls, name, bases, **kwargs):
        print("__prepare__")
        return {}

    def __new__(mcls, name, bases, namespace, **kwargs):
        print("__new__")
        return super().__new__(mcls, name, bases, namespace)

    def __init__(cls, name, bases, namespace, **kwargs):
        print("__init__")
        super().__init__(name, bases, namespace)


class User(metaclass=Meta):
    age = 20

__prepare__
__new__
__init__

class User:
    pass

User = type("User", (), {})

class Meta(type):
    def __new__(mcls, name, bases, namespace):
        print("Создаём класс")
        return super().__new__(mcls, name, bases, namespace)

    def __init__(cls, name, bases, namespace):
        print("Инициализируем класс")
        super().__init__(name, bases, namespace)


class User(metaclass=Meta):
    pass

user = User()

user = type.__call__(User)

User.__new__(User, ...)
User.__init__(obj, ...)

class Meta(type):
    def __call__(cls, *args, **kwargs):
        print("Вызвали класс как функцию")
        return super().__call__(*args, **kwargs)


class User(metaclass=Meta):
    def __init__(self, name):
        self.name = name


user = User("Alex")

Вызвали класс как функцию

isinstance(obj, SomeClass)
issubclass(Child, Parent)

class Meta(type):
    def __instancecheck__(cls, instance):
        print("__instancecheck__")
        return True


class User(metaclass=Meta):
    pass


print(isinstance(123, User))

__instancecheck__True

for name in sorted(type.__dict__):
    if name.startswith("__") and name.endswith("__"):
        print(name)

__abstractmethods__
__annotations__
__base__
__bases__
__basicsize__
__call__
__delattr__
__dict__
__dictoffset__
__dir__
__doc__
__flags__
__getattribute__
__init__
__instancecheck__
__itemsize__
__module__
__mro__
__name__
__new__
__or__
__prepare__
__qualname__
__repr__
__ror__
__setattr__
__sizeof__
__subclasscheck__
__subclasses__
__text_signature__
__type_params__
__weakrefoffset__

__name__
__qualname__
__bases__
__mro__
__dict__
__doc__
__module__

class User:
    pass


user = User()

print(type(user))  # <class '__main__.User'>
print(type(User))  # <class 'type'>

user → объект
User → класс user
type → метакласс класса User

len(obj)
obj[key]
obj + other
obj()

obj[key]

type(obj).__getitem__(obj, key)

магические методы объекта ищутся на его классе
магические методы класса ищутся на его метаклассе

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

    def __str__(self):
        return f"User: {self.name}"

    def __call__(self):
        return f"Called {self.name}"


user = User("Alex")

print(user)     # User: Alex
print(user())   # Called Alex

str(user) → User.__str__(user)
user()    → User.__call__(user)

user = User()

type.__call__(User, ...)

User.__new__(User, ...)
User.__init__(obj, ...)

class Meta(type):
    def __call__(cls, *args, **kwargs):
        print("Метакласс перехватил вызов класса")
        return super().__call__(*args, **kwargs)


class User(metaclass=Meta):
    def __init__(self, name):
        self.name = name


user = User("Alex")

class User:
    def __call__(self):
        print("Вызвали экземпляр")


user = User()

user()  # работает
User()  # просто создаёт объект

class Meta(type):
    def __call__(cls, *args, **kwargs):
        print("Вызвали класс")
        return super().__call__(*args, **kwargs)


class User(metaclass=Meta):
    pass


User()

print(isinstance(user, User))    # True
print(isinstance(User, type))    # True
print(issubclass(User, object))  # True
print(issubclass(type, object))  # True

class User:
    name = "Alex"

User = type("User", (object,), {"name": "Alex"})

выбор метакласса
подготовка namespace через __prepare__
выполнение тела класса
создание объекта класса через метакласс

class Meta(type):
    @classmethod
    def __prepare__(mcls, name, bases):
        print("__prepare__")
        return {}

    def __new__(mcls, name, bases, namespace):
        print("__new__")
        return super().__new__(mcls, name, bases, namespace)

    def __init__(cls, name, bases, namespace):
        print("__init__")
        super().__init__(name, bases, namespace)


class User(metaclass=Meta):
    pass

__prepare__
__new__
__init__

Meta.__prepare__ → готовит пространство имён класса
Meta.__new__     → создаёт объект класса
Meta.__init__    → инициализирует объект класса

class Meta(type):
    def __instancecheck__(cls, instance):
        print("__instancecheck__")
        return True


class User(metaclass=Meta):
    pass


print(isinstance(123, User))

__instancecheck__
True

class Box:
    pass


box = Box()

box.__len__ = lambda: 10

print(box.__len__())  # 10
print(len(box))       # TypeError

class Box:
    def __len__(self):
        return 10


box = Box()

print(len(box))  # 10

Экземпляр:
    user.__str__?      — нет, Python смотрит в User.__str__
    user + other       — User.__add__
    len(user)          — User.__len__
    user()             — User.__call__

Класс:
    User()             — type(User).__call__
    isinstance(x, User) — type(User).__instancecheck__
    issubclass(A, User) — type(User).__subclasscheck__
    User.attr          — type(User).__getattribute__

dunder-методы обычного класса управляют экземплярами
dunder-методы метакласса управляют самими классами

user = User()

class User:
    pass

User = type("User", (object,), {})

экземпляр → создаётся классом
класс     → создаётся метаклассом

class User:
    pass


user = User()

print(type(user))  # <class '__main__.User'>
print(type(User))  # <class 'type'>

user — экземпляр класса User
User — экземпляр метакласса type

class Handler:
    pass


class UserHandler(Handler):
    pass


class OrderHandler(Handler):
    pass

registry = {}


class UserHandler:
    pass


registry["UserHandler"] = UserHandler

class RegistryMeta(type):
    registry = {}

    def __new__(mcls, name, bases, namespace):
        cls = super().__new__(mcls, name, bases, namespace)

        if name != "BaseHandler":
            mcls.registry[name] = cls

        return cls


class BaseHandler(metaclass=RegistryMeta):
    pass


class UserHandler(BaseHandler):
    pass


class OrderHandler(BaseHandler):
    pass


print(RegistryMeta.registry)

{
    'UserHandler': <class '__main__.UserHandler'>,
    'OrderHandler': <class '__main__.OrderHandler'>
}

создался класс UserHandler  → метакласс автоматически добавил его в registry
создался класс OrderHandler → метакласс автоматически добавил его в registry

Meta.__prepare__ → подготовка namespace класса
Meta.__new__     → создание объекта класса
Meta.__init__    → инициализация объекта класса

class Meta(type):
    @classmethod
    def __prepare__(mcls, name, bases):
        print("__prepare__")
        return {}

    def __new__(mcls, name, bases, namespace):
        print("__new__")
        return super().__new__(mcls, name, bases, namespace)

    def __init__(cls, name, bases, namespace):
        print("__init__")
        super().__init__(name, bases, namespace)


class User(metaclass=Meta):
    pass

__prepare__
__new__
__init__

user = User()

user = User()

user = type(User).__call__(User)

User.__new__(User, ...)
User.__init__(obj, ...)

class Meta(type):
    def __call__(cls, *args, **kwargs):
        print("Перед созданием объекта")
        obj = super().__call__(*args, **kwargs)
        print("После создания объекта")
        return obj


class User(metaclass=Meta):
    def __init__(self, name):
        self.name = name


user = User("Alex")

Перед созданием объекта
После создания объекта

class ServiceMeta(type):
    def __new__(mcls, name, bases, namespace):
        if name != "BaseService" and "execute" not in namespace:
            raise TypeError(f"Класс {name} должен определить метод execute")

        return super().__new__(mcls, name, bases, namespace)


class BaseService(metaclass=ServiceMeta):
    pass


class UserService(BaseService):
    def execute(self):
        print("Работаем")


class BadService(BaseService):
    pass

TypeError: Класс BadService должен определить метод execute

from abc import ABC, abstractmethod


class BaseRepository(ABC):
    @abstractmethod
    def get(self, id):
        pass

class UserRepository(BaseRepository):
    pass


repo = UserRepository()  # TypeError

class Field:
    def __set_name__(self, owner, name):
        self.name = name


class User:
    username = Field()

Field.__set_name__(field, User, "username")

класс должен автоматически регистрироваться
класс должен проверяться при создании
классу нужно автоматически добавлять методы/атрибуты
нужно изменить поведение Class(...)
нужно изменить isinstance()/issubclass()
строится фреймворк или декларативный API

class User(Model):
    id = IntegerField()
    username = StringField()

какие поля объявлены
какие у них имена
какая таблица соответствует модели
какие ограничения есть у полей

class BaseHandler:
    registry = {}

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        BaseHandler.registry[cls.__name__] = cls


class UserHandler(BaseHandler):
    pass


class OrderHandler(BaseHandler):
    pass


print(BaseHandler.registry)

class User:
    pass

User = type("User", (object,), {})

print(User)        # <class '__main__.User'>
print(type(User))  # <class 'type'>

type создал объект класса User
User потом может создавать обычные объекты user

метакласс → создаёт класс
класс     → создаёт экземпляр

class User:
    pass


user = User()

print(type(user))  # <class '__main__.User'>
print(type(User))  # <class 'type'>

user — результат работы класса User
User — результат работы метакласса type

class Meta(type):
    def __new__(mcls, name, bases, namespace):
        print("Метакласс создаёт класс:", name)
        return super().__new__(mcls, name, bases, namespace)


class User(metaclass=Meta):
    pass

Метакласс создаёт класс: User

print(type(User))  # <class '__main__.Meta'>

class User:
    pass

User

user = User()

user

with open("data.txt", "r", encoding="utf-8") as file:
    content = file.read()

with manager as value:
    body

manager = manager_expression

value = manager.__enter__()

try:
    body
except Exception as exc:
    suppress = manager.__exit__(type(exc), exc, exc.__traceback__)
    if not suppress:
        raise
else:
    manager.__exit__(None, None, None)

__enter__ → вызывается перед входом в блок with
__exit__  → вызывается при выходе из блока with

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

    def __enter__(self):
        print("Открываем файл")
        self.file = open(self.filename, self.mode, encoding="utf-8")
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        print("Закрываем файл")
        self.file.close()

with FileManager("data.txt", "w") as file:
    file.write("Hello")

1. Создаётся FileManager
2. Вызывается __enter__
3. Выполняется тело with
4. Вызывается __exit__

def __exit__(self, exc_type, exc_value, traceback):
    ...

class Manager:
    def __enter__(self):
        print("Вход")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type is None:
            print("Вышли без ошибки")
        else:
            print(f"Произошла ошибка: {exc_value}")

        print("Выход")


with Manager():
    print("Работа внутри with")

Вход
Работа внутри with
Вышли без ошибки
Выход

class SuppressZeroDivision:
    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type is ZeroDivisionError:
            print("ZeroDivisionError подавлен")
            return True

        return False


with SuppressZeroDivision():
    result = 10 / 0

print("Программа продолжила работу")

ZeroDivisionError подавлен
Программа продолжила работу

file = open("data.txt", "r", encoding="utf-8")

try:
    content = file.read()
finally:
    file.close()

with open("data.txt", "r", encoding="utf-8") as file:
    content = file.read()

from contextlib import contextmanager


@contextmanager
def managed_resource():
    print("Открываем ресурс")

    try:
        yield "resource"
    finally:
        print("Закрываем ресурс")


with managed_resource() as resource:
    print(f"Работаем с {resource}")