🐍 Укус питона 🐍

Что такое diamondproblem ? Спросят с вероятностью 3% 👉 Проблема ромбовидного наследования (Diamond Problem) возникает в объектно-ориентированном программировании при использовании множественного наследования. Она возникает из-за неоднозначности, когда класс наследует от нескольких классов, имеющих общего предка. Рассмотрим пример:

class A:
    def method(self):
        print("Method in A")

class B(A):
    def method(self):
        print("Method in B")

class C(A):
    def method(self):
        print("Method in C")

class D(B, C):
    pass

d = D()
d.method()

В этом примере: ✅Класс A является базовым классом. ✅Классы B и C наследуют от класса A и переопределяют метод method. ✅Класс D наследует от классов B и C. 🔼 Когда мы вызываем метод method через экземпляр класса D (d.method()), возникает вопрос: какой именно метод должен быть вызван - из класса B или из класса C? Это и есть проблема ромбовидного наследования. Решение проблемы ромбовидного наследования Использует метод разрешения порядка (MRO - Method Resolution Order) для решения этой проблемы. MRO определяет порядок, в котором методы должны вызываться в случае множественного наследования. Для просмотра MRO можно использовать атрибут mro или функцию mro().

print(D.mro)

Результат будет следующим:

(<class 'main.D'>, <class 'main.B'>, <class 'main.C'>, <class 'main.A'>, <class 'object'>)

Согласно этому порядку, метод method будет взят из класса B, так как он идёт первым в MRO. Поэтому при вызове d.method(), выведется: Method in B Если классы B и C используют super(), можно правильно вызвать методы всех классов-предков:

class A:
    def method(self):
        print("Method in A")

class B(A):
    def method(self):
        print("Method in B")
        super().method()

class C(A):
    def method(self):
        print("Method in C")
        super().method()

class D(B, C):
    def method(self):
        print("Method in D")
        super().method()

d = D()
d.method()

Результат выполнения будет:

Method in D
Method in B
Method in C
Method in A

В этом случае методы всех классов вызываются в порядке, определённом MRO. 🔼Проблема ромбовидного наследования возникает при множественном наследовании и приводит к неоднозначности, какой метод вызывать. Решает эту проблему с помощью MRO (Method Resolution Order), определяющего порядок вызова методов.

У списка (и только у него) есть специальные методы .sort() и .reverse(), которые выполняют те же действия, что и функции sorted() и reversed(), но с некоторыми отличиями: ✔️ Изменяют сам исходный список, а не создают новый. ✔️ Возвращают None, а не новый список. ✔️ Поддерживают те же дополнительные аргументы.

Предположим, что требуется отсортировать данные сначала по столбцу А в порядке возрастания, затем по столбцу B в порядке убывания, а затем по столбцу C в порядке возрастания. 👉 Если данные в столбце B представлены числами, то можно использовать функцию в key, чтобы изменить знак элементов B и получить необходимый результат. ❗️ Однако, если все данные в текстовом формате, то можно воспользоваться устойчивой сортировкой sort в Python (начиная с версии 2.2), которая сохраняет порядок "одинаковых" элементов. ✔️ Для этого можно просто выполнить три сортировки по разным ключам.

🐍 Библиотека PIL (Python Imaging Library) является одной из наиболее популярных библиотек для работы с изображениями. 👉 Одной из основных возможностей библиотеки PIL является способность создавать и редактировать изображения. С ее помощью можно создавать новые изображения с определенными размерами и цветовыми схемами, а также редактировать существующие изображения. ⏺ Например, можно добавлять текст, рисовать графические примитивы, накладывать различные эффекты и многое другое. 👉 Библиотека PIL также предоставляет возможность обработки изображений в пакетном режиме. Это означает, что можно применять определенные операции к нескольким изображениям одновременно. ⏺ Например, можно изменить размер и применить фильтр к множеству изображений, что позволяет сэкономить время и упростить процесс обработки большого количества изображений.

🐍 Как выражена инкапсуляция в python ? Спросят с вероятностью 3% Инкапсуляция в Python выражается через механизмы, которые позволяют скрывать внутренние детали реализации класса и предоставлять доступ к данным и методам через определённый интерфейс. Важные аспекты инкапсуляции включают в себя соглашения об именовании и специальные методы. Соглашения об именовании ⚪ Приватные атрибуты и методы: - В Python соглашение об именовании позволяет сделать атрибуты и методы приватными, что предотвращает их случайное использование вне класса. - Атрибуты и методы, начинающиеся с одного подчёркивания (_), считаются защищёнными и не должны использоваться вне класса или подклассов. - Атрибуты и методы, начинающиеся с двойного подчёркивания (__), подвергаются манглингу имён (name mangling), что делает их труднодоступными извне класса.

class MyClass:
    def init(self, value):
        self._protected_value = value  # Защищённый атрибут
        self.__private_value = value   # Приватный атрибут

    def _protected_method(self):
        print("This is a protected method.")

    def __private_method(self):
        print("This is a private method.")

Примеры использования ⚪Защищённые атрибуты и методы: - Они не предназначены для использования вне класса, но могут быть использованы в подклассах. - Их использование вне класса является плохой практикой, но технически возможно.

class SubClass(MyClass):
    def access_protected(self):
        print(self._protected_value)
        self._protected_method()

instance = SubClass(10)
instance.access_protected()
# Выведет:
# 10
# This is a protected method.

⚪ Приватные атрибуты и методы: - Они подвергаются манглингу имён, что делает их труднодоступными извне класса. - Внешний доступ возможен, но с использованием специального синтаксиса, что считается плохой практикой.

class AnotherClass:
    def init(self, value):
        self.__private_value = value

    def __private_method(self):
        print("This is a private method.")

    def access_private(self):
        print(self.__private_value)
        self.__private_method()

instance = AnotherClass(20)
instance.access_private()
# Выведет:
# 20
# This is a private method.

# Попытка доступа к приватному атрибуту извне
# print(instance.__private_value)  # AttributeError

# Доступ с использованием манглинга имён (не рекомендуется)
print(instance._AnotherClass__private_value)  # Выведет: 20

Свойства (Properties) Предоставляют интерфейс для управления доступом к атрибутам и позволяют инкапсулировать логику доступа и изменения данных.

class MyClassWithProperty:
    def init(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        if new_value > 0:
            self._value = new_value
        else:
            raise ValueError("Value must be positive")

instance = MyClassWithProperty(10)
print(instance.value)  # Выведет: 10
instance.value = 20
print(instance.value)  # Выведет: 20
# instance.value = -10  # ValueError: Value must be positive

Инкапсуляция достигается с помощью соглашений об именовании (одинарное подчёркивание для защищённых и двойное подчёркивание для приватных атрибутов и методов) и использования свойств для управления доступом к атрибутам. Это позволяет скрывать внутренние детали реализации и предоставлять контролируемый интерфейс для взаимодействия с объектами.