🤔 Что относится к изменяемым типам данных и к неизменяемым?

В Python к изменяемым типам данных относятся списки (list), множества (set), словари (dict), а к неизменяемым — числа, строки (str), кортежи (tuple), замороженные множества (frozenset).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие есть виды наследования ?

Существуют различные виды наследования, которые позволяют создавать новые классы на основе существующих, что способствует повторному использованию кода и упрощает его сопровождение.

🚩Виды

🟠Простое (одиночное) наследование
Класс-наследник (подкласс) наследует от одного родительского класса (суперкласса).

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

# Использование
dog = Dog()
print(dog.speak())  # Вывод: Woof!

🟠Множественное наследование
Класс-наследник наследует от двух или более родительских классов.

class Canine:
    def bark(self):
        return "Bark!"

class Feline:
    def meow(self):
        return "Meow!"

class CatDog(Canine, Feline):
    pass

# Использование
catdog = CatDog()
print(catdog.bark())  # Вывод: Bark!
print(catdog.meow())  # Вывод: Meow!

🟠Многоуровневое (иерархическое) наследование
Класс-наследник (подкласс) наследует от другого класса-наследника (подкласса), образуя цепочку наследования.

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Bulldog(Dog):
    def speak(self):
        return "Woof! I am a Bulldog."

# Использование
bulldog = Bulldog()
print(bulldog.speak())  # Вывод: Woof! I am a Bulldog.

🟠Иерархическое наследование
Один родительский класс имеет несколько классов-наследников.

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

# Использование
dog = Dog()
cat = Cat()
print(dog.speak())  # Вывод: Woof!
print(cat.speak())  # Вывод: Meow!

🟠Гибридное наследование
Комбинация двух или более типов наследования.

class Canine:
    def bark(self):
        return "Bark!"

class Feline:
    def meow(self):
        return "Meow!"

class Animal:
    def speak(self):
        pass

class CatDog(Animal, Canine, Feline):
    def speak(self):
        return f"{self.bark()} {self.meow()}"

# Использование
catdog = CatDog()
print(catdog.speak())  # Вывод: Bark! Meow!

🚩Плюсы

➕Повторное использование кода
Классы-наследники могут использовать методы и атрибуты родительских классов, что уменьшает дублирование кода.
➕Упрощение сопровождения
Изменения в родительском классе автоматически распространяются на все классы-наследники.
➕Полиморфизм
Позволяет использовать объекты разных классов через интерфейс одного родительского класса, что упрощает обработку иерархий объектов.

🚩Минусы

➖Сложность структуры
Множественное и многоуровневое наследование могут привести к сложной и запутанной иерархии классов.
➖Жёсткая связь
Классы-наследники зависят от родительских классов, что может усложнить изменения в иерархии.
➖Проблемы с множественным наследованием
В языках, поддерживающих множественное наследование, могут возникнуть проблемы с конфликтом имен и порядок разрешения методов (MRO — Method Resolution Order).

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое list comprehension?

List comprehension в Python — это способ создания списков, используя конструкцию, состоящую из выражения и одного или нескольких циклов for и условий if в одной строке. Это позволяет генерировать новые списки путем применения выражения к каждому элементу последовательности, делая код компактным и часто более читаемым.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое @classmethod?

Это декоратор в Python, который используется для определения метода класса. Методы класса работают с самим классом, а не с его экземплярами. В отличие от обычных методов, которые принимают в качестве первого аргумента self (ссылку на экземпляр), методы класса принимают cls (ссылку на класс).

🟠Основные моменты
Доступ к атрибутам и методам класса: Методы класса имеют доступ ко всем атрибутам и методам класса, но не к атрибутам экземпляров.
Использование декоратора @classmethod: Для определения метода класса используется декоратор.
Часто используются для фабричных методов: Методы класса часто используются для создания альтернативных конструкторов.

class MyClass:
    class_attribute = "Hello, World!"

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

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

# Создание экземпляра класса
obj = MyClass("Some value")

# Вызов метода класса через класс
print(MyClass.class_method())  # Hello, World!

# Вызов метода класса через экземпляр
print(obj.class_method())  # Hello, World!

🟠Пример фабричного метода
Это метод, который возвращает объект класса. Методы класса удобно использовать для создания таких методов, поскольку они имеют доступ к самому классу и могут создавать его экземпляры.

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

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

# Создание объекта через основной конструктор
person1 = Person("Alice", 30)

# Создание объекта через фабричный метод
person2 = Person.from_birth_year("Bob", 1990)

print(person1.name, person1.age)  # Alice 30
print(person2.name, person2.age)  # Bob 33

🟠Сравнение с другими методами
Обычные методы: Принимают self как первый аргумент и работают с конкретными экземплярами класса. Доступны как к атрибутам класса, так и к атрибутам экземпляра.
Методы класса: Принимают cls как первый аргумент и работают с самим классом. Доступны только к атрибутам класса.
Статические методы: Не принимают автоматически ни self, ни cls. Они могут быть вызваны на классе или экземпляре и не имеют доступа ни к атрибутам класса, ни к атрибутам экземпляра.

class Example:
    class_attr = "class attribute"

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

    def instance_method(self):
        return f"instance method: {self.instance_attr}"

    @classmethod
    def class_method(cls):
        return f"class method: {cls.class_attr}"

    @staticmethod
    def static_method():
        return "static method"

# Создание экземпляра класса
example = Example("instance attribute")

# Вызов методов
print(example.instance_method())  # instance method: instance attribute
print(Example.class_method())     # class method: class attribute
print(example.class_method())     # class method: class attribute
print(Example.static_method())    # static method
print(example.static_method())    # static method

Ставь 👍 и забирай 📚 Базу знаний

🤔 Threading что это?

Threading в Python — это использование потоков для выполнения множества задач одновременно в рамках одного процесса. Это полезно для выполнения I/O-задержанных задач и повышения реактивности программы. Однако из-за глобальной блокировки интерпретатора (GIL) в CPython, потоки не всегда могут эффективно использоваться для задач, требующих интенсивных вычислений.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое Try Except?

Используется для обработки исключений, которые могут возникнуть во время выполнения программы. Она позволяет "ловить" ошибки и принимать меры по их устранению или логированию, что предотвращает завершение программы с ошибкой.

🚩Основные компоненты

🟠try блок: Содержит код, который потенциально может вызвать исключение.
🟠except блок: Содержит код, который выполняется, если в блоке try возникает исключение.

Общий синтаксис

try:
    # Код, который может вызвать исключение
    ...
except SomeException as e:
    # Код, который выполняется в случае возникновения исключения SomeException
    ...

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error occurred: {e}")

🚩Многоуровневая обработка исключений

Можно обрабатывать различные типы исключений по-разному. Здесь, если строку "abc" невозможно преобразовать в целое число, будет вызвано исключение ValueError, и соответствующее сообщение будет выведено.

try:
    result = int("abc")
except ZeroDivisionError:
    print("Attempted to divide by zero")
except ValueError:
    print("Invalid value")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

🚩Блоки `else` и `finally`

🟠`else` блок: Выполняется, если в блоке try не возникло исключений.
🟠`finally` блок: Выполняется всегда, независимо от того, возникло исключение или нет. Используется для освобождения ресурсов, закрытия файлов и т.д.

try:
    file = open('example.txt', 'r')
    content = file.read()
except FileNotFoundError:
    print("File not found")
else:
    print("File read successfully")
finally:
    file.close()
    print("File closed")

Пример с использованием finally

try:
    file = open('example.txt', 'r')
    content = file.read()
except FileNotFoundError:
    print("File not found")
else:
    print("File read successfully")
finally:
    try:
        file.close()
        print("File closed")
    except NameError:
        print("File was never opened")

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чем разница сравнение через is и "=="?

В Python `is` проверяет идентичность объектов, т.е., ссылаются ли две переменные на один и тот же объект в памяти. Оператор `==` проверяет равенство значений объектов. Так, две различные переменные, содержащие одинаковые данные, будут равны (`==`), но не идентичны (`is`), если они указывают на разные объекты.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как Python взаимодействует с файлом?

Предоставляет мощные и гибкие инструменты для работы с файлами. Основные операции включают чтение, запись, создание и удаление файлов.

🚩Методы

1⃣Открытие файла
Используется функция open(), которая возвращает объект файла. open() принимает два основных аргумента:
- Имя файла (путь к файлу).
- Режим открытия файла (например, чтение, запись, добавление и т.д.).
Примеры режимов:
- 'r': Открытие для чтения (по умолчанию).
- 'w': Открытие для записи (содержимое файла удаляется).
- 'a': Открытие для добавления (данные добавляются в конец файла).
- 'b': Бинарный режим (например, 'rb' или 'wb').
- '+': Открытие для чтения и записи (например, 'r+' или 'w+').

file = open('example.txt', 'r')

2⃣Чтение из файла
Для чтения данных из файла используются методы read(), readline() и readlines().

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

Пример чтения файла построчно:

with open('example.txt', 'r') as file:
    for line in file:
        print(line.strip())

3⃣Запись в файл
Для записи данных в файл используются методы write() и writelines().

with open('example.txt', 'w') as file:
    file.write('Hello, World!')

Пример добавления строки в конец файла:

with open('example.txt', 'a') as file:
    file.write('\nAppend this line')

4⃣Закрытие файла
Важно закрывать файл после работы с ним, чтобы освободить ресурсы. Это можно сделать с помощью метода close(), но лучше использовать конструкцию with, которая автоматически закрывает файл:

with open('example.txt', 'r') as file:
    content = file.read()
    # Файл автоматически закроется по завершении блока with

Пример полного цикла работы с файлом

# Открытие файла для записи
with open('example.txt', 'w') as file:
    file.write('This is the first line.\n')
    file.write('This is the second line.\n')

# Открытие файла для добавления
with open('example.txt', 'a') as file:
    file.write('This line is added to the end of the file.\n')

# Открытие файла для чтения
with open('example.txt', 'r') as file:
    for line in file:
        print(line.strip())

5⃣Работа с бинарными файлами
Для работы с бинарными файлами используется режим 'b'. Например, чтение и запись изображений или других бинарных данных

# Чтение бинарного файла
with open('image.png', 'rb') as file:
    data = file.read()

# Запись в бинарный файл
with open('copy_image.png', 'wb') as file:
    file.write(data)

6⃣Исключения и обработка ошибок
Для обработки ошибок при работе с файлами можно использовать конструкцию try except:

try:
    with open('example.txt', 'r') as file:
        content = file.read()
except FileNotFoundError:
    print("File not found.")
except IOError:
    print("An error occurred while reading the file.")

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое метаклассы в Python?

Метаклассы в Python — это "классы классов", которые определяют, как класс должен быть создан. Они играют роль шаблонов для создания классов. В Python, класс `type` является встроенным метаклассом, от которого все классы неявно наследуются. Метаклассы позволяют программистам, например, автоматически добавлять новые методы или изменять атрибуты в классах, что особенно полезно в фреймворках и библиотеках, где нужен дополнительный уровень абстракции или автоматизации при определении классов.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое monkey patch?

Это практика динамического изменения или расширения кода в рантайме. Это позволяет изменять поведение модулей или классов без изменения их исходного кода. Monkey patching может быть полезен для исправления багов, добавления функциональности или изменения поведения библиотек, особенно когда их исходный код недоступен или его нежелательно изменять.

🚩Пример использования

class Dog:
    def bark(self):
        return "Woof!"

# Оригинальное поведение
dog = Dog()
print(dog.bark())  # Вывод: Woof!

# Применение monkey patch
def new_bark(self):
    return "Woof! Woof!"

Dog.bark = new_bark

# Измененное поведение
print(dog.bark())  # Вывод: Woof! Woof!

🟠Пример использования monkey patch для исправления ошибки
Допустим, у нас есть модуль math_operations.py с функцией, содержащей ошибку:

# math_operations.py
def add(a, b):
    return a - b  # Ошибка: должно быть сложение, а не вычитание

Мы можем использовать monkey patch, чтобы исправить эту ошибку, не изменяя исходный код:

import math_operations

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

# Применение monkey patch
math_operations.add = corrected_add

# Теперь функция add работает правильно
print(math_operations.add(2, 3))  # Вывод: 5

🟠Использование monkey patch для расширения функциональности
Мы также можем использовать monkey patch для добавления новых методов в существующие классы:

class Cat:
    def meow(self):
        return "Meow!"

# Оригинальное поведение
cat = Cat()
print(cat.meow())  # Вывод: Meow!

# Применение monkey patch
def purr(self):
    return "Purr..."

Cat.purr = purr

# Расширенное поведение
print(cat.purr())  # Вывод: Purr...

🚩Плюсы

➕Быстрое исправление багов без изменения исходного кода.
➕Возможность добавления функциональности к сторонним библиотекам.
➕Гибкость и мощь изменения поведения кода во время выполнения.

🚩Минусы

➖Может сделать код менее читаемым и более сложным для понимания.
➖Возможность возникновения конфликтов, если несколько частей кода пытаются изменить одно и то же поведение.
➖Трудности с поддержкой и отладкой кода, так как поведение может изменяться непредсказуемо.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Threading что это

Threading (многопоточность) — это техника, позволяющая программе выполнять несколько операций одновременно с помощью потоков. Каждый поток представляет собой отдельный поток выполнения, который может работать параллельно с другими, что повышает производительность и эффективность, особенно в многозадачных приложениях. В многопоточном окружении важны синхронизация и управление потоками, чтобы избежать конфликтов и блокировок данных.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое unit test?

Это метод тестирования, при котором проверяется работа отдельных модулей или компонентов кода, обычно на уровне функций или методов. Цель юнит-тестирования — убедиться, что каждая часть кода работает правильно независимо от других частей.

🚩Основные характеристики

🟠Малый охват
Юнит-тесты охватывают небольшие участки кода, такие как отдельные функции или методы.
🟠Изолированность
Тесты выполняются в изолированной среде, что позволяет выявлять проблемы именно в тестируемом модуле без влияния внешних зависимостей.
🟠Автоматизация
Юнит-тесты легко автоматизировать, что позволяет быстро проверять изменения в коде.
🟠Регулярность выполнения
Юнит-тесты должны выполняться регулярно, например, при каждом изменении кода, чтобы обеспечить его стабильность.

🚩Пример

1⃣Тестируемая функция

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

2⃣Написание юнит-теста

import unittest
from my_module import add  # Импортируем тестируемую функцию из модуля

class TestAddFunction(unittest.TestCase):
    def test_add_positive_numbers(self):
        self.assertEqual(add(2, 3), 5)

    def test_add_negative_numbers(self):
        self.assertEqual(add(-1, -1), -2)

    def test_add_zero(self):
        self.assertEqual(add(0, 0), 0)

if __name__ == '__main__':
    unittest.main()

3⃣Запуск юнит-тестов

python test_add.py

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое `__slots__`?

`__slots__` — это специальный атрибут в Python, который позволяет ограничить количество атрибутов, добавляемых экземпляру класса, и уменьшить использование памяти. При его использовании Python не создает обычный словарь для хранения атрибутов, а вместо этого выделяет фиксированное место для указанных атрибутов. Это может повысить производительность и экономить память, особенно при создании большого числа объектов.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое mocking?

Это техника в программировании, используемая для замены реальных объектов или компонентов системы временными объектами (моками) во время тестирования. Эти временные объекты имитируют поведение реальных объектов, позволяя изолировать и тестировать отдельные части кода без зависимости от других компонентов системы.

🚩Основные компоненты

🟠`Mock` и `MagicMock`
Основные классы для создания мок-объектов.
🟠`patch`
Декоратор или контекстный менеджер для замены объектов на моки во время выполнения теста.

🚩Примеры использования

Простой пример с использованием Mock

from unittest.mock import Mock

# Создание мок-объекта
mock = Mock()

# Настройка мок-объекта
mock.some_method.return_value = "Mocked Result"

# Вызов метода и проверка результата
result = mock.some_method()
print(result)  # Вывод: Mocked Result

Использование patch для замены объектов

import unittest
from unittest.mock import patch

# Пример функции, которая вызывает внешний API
def fetch_data():
    import requests
    response = requests.get("http://example.com/api/data")
    return response.json()

# Тестирование функции с использованием patch
class TestFetchData(unittest.TestCase):
    @patch('requests.get')
    def test_fetch_data(self, mock_get):
        # Настройка мок-ответа
        mock_get.return_value.json.return_value = {"key": "value"}

        # Вызов тестируемой функции
        result = fetch_data()

        # Проверка результата
        self.assertEqual(result, {"key": "value"})
        mock_get.assert_called_once_with("http://example.com/api/data")

if __name__ == '__main__':
    unittest.main()

Использование MagicMock

from unittest.mock import MagicMock

# Создание объекта MagicMock
mock = MagicMock()

# Настройка возвращаемого значения для магического метода __str__
mock.__str__.return_value = "MagicMocked String"

print(str(mock))  # Вывод: MagicMocked String

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чем разница сравнение через is и ==

Оператор == проверяет равенство значений, то есть проверяет, содержат ли переменные одинаковые данные. Оператор is проверяет, ссылаются ли переменные на один и тот же объект в памяти. Таким образом, is используется для проверки идентичности объекта, а == — для проверки равенства значений.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Методы add, mul, sub, truediv?

Относятся к так называемым "магическим методам" или "специальным методам". Они позволяют определять поведение объектов при использовании операторов сложения (+), умножения (*), вычитания (-) и деления (/).

🟠Метод `__add__`

Этот метод отвечает за операцию сложения. Если вы определяете этот метод в вашем классе, вы можете контролировать, что происходит, когда вы используете оператор + между объектами этого класса.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)  # Вывод: Vector(4, 6)

🟠Метод `__mul__`

Этот метод отвечает за операцию умножения. Его можно использовать, чтобы определить, как объекты вашего класса будут вести себя при использовании оператора *.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v = Vector(1, 2)
print(v * 3)  # Вывод: Vector(3, 6)

🟠Метод `__sub__`

Этот метод отвечает за операцию вычитания. Он позволяет вам определить поведение объектов при использовании оператора -.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(5, 7)
v2 = Vector(2, 3)
print(v1 - v2)  # Вывод: Vector(3, 4)

🟠Метод `__truediv__`

Этот метод отвечает за операцию деления. Он позволяет определить, как объекты вашего класса будут вести себя при использовании оператора /.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __truediv__(self, scalar):
        return Vector(self.x / scalar, self.y / scalar)
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v = Vector(8, 4)
print(v / 2)  # Вывод: Vector(4.0, 2.0)

Ставь 👍 и забирай 📚 Базу знаний

🤔 Мультипроцессинг — что это

Мультипроцессинг — это подход, при котором для выполнения задач создаются отдельные процессы, а не потоки. В Python это полезно для обхода ограничения GIL (Global Interpreter Lock), позволяя исполнять код параллельно на нескольких ядрах процессора. Модуль multiprocessing позволяет создавать независимые процессы, каждый из которых выполняет свою копию интерпретатора Python.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Метод bool?

Используется для определения логической истинности (truthiness) объекта. Когда вызывается функция bool() на объекте или объект используется в контексте, где требуется логическое значение (например, в условиях if), вызывается метод __bool__. Если метод __bool__ не определен, Python использует метод __len__: объект считается ложным (False), если его длина равна нулю, и истинным (True) в противном случае.

🚩Зачем нужен

Метод __bool__ позволяет вам определять, что будет считаться истинным или ложным для объектов вашего класса. Это может быть полезно в различных ситуациях, например, для проверки пустых контейнеров, валидных состояний объектов и т.д.

🚩Как использовать

Для того чтобы использовать метод __bool__, нужно его определить в своем классе. Метод должен возвращать либо True, либо False. В этом примере метод __bool__ проверяет значение атрибута value. Если value имеет значение, которое считается ложным (например, 0 или None), метод возвращает False. В противном случае, он возвращает True.

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

# Примеры использования
obj1 = MyClass(0)
obj2 = MyClass(10)

print(bool(obj1))  # Вывод: False
print(bool(obj2))  # Вывод: True

if obj1:
    print("obj1 is True")
else:
    print("obj1 is False")  # Этот блок выполнится

if obj2:
    print("obj2 is True")  # Этот блок выполнится
else:
    print("obj2 is False")

🚩Пример более сложного использования

Допустим, у вас есть класс Box, который содержит предметы, и вы хотите, чтобы пустая коробка считалась ложной, а коробка с предметами — истинной.

class Box:
    def __init__(self, items):
        self.items = items
    
    def __bool__(self):
        return bool(self.items)

# Примеры использования
empty_box = Box([])
full_box = Box(['item1', 'item2'])

print(bool(empty_box))  # Вывод: False
print(bool(full_box))   # Вывод: True

if empty_box:
    print("The box is not empty")
else:
    print("The box is empty")  # Этот блок выполнится

if full_box:
    print("The box is not empty")  # Этот блок выполнится
else:
    print("The box is empty")

Ставь 👍 и забирай 📚 Базу знаний

🤔 Python — компилируемый или интерпретируемый

Python считается интерпретируемым языком, так как код выполняется интерпретатором построчно, что облегчает отладку и делает его портативным. Тем не менее, перед исполнением Python-код компилируется в байт-код (.pyc), который затем выполняется на виртуальной машине (PVM). Поэтому Python можно назвать интерпретируемым с этапом предварительной компиляции в байт-код.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Методы eq, ne, lt, le, qt, qe?

Также относятся к "магическим методам" и используются для перегрузки операторов сравнения. Эти методы позволяют вам определить, как объекты вашего класса будут сравниваться друг с другом с использованием операторов равенства, неравенства, меньше, меньше или равно, больше и больше или равно.

🟠Метод `eq`
Отвечает за оператор равенства ==. Он позволяет определить, когда два объекта вашего класса считаются равными.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

p1 = Person("Alice", 30)
p2 = Person("Alice", 30)
p3 = Person("Bob", 25)

print(p1 == p2)  # Вывод: True
print(p1 == p3)  # Вывод: False

🟠Метод `ne`
Отвечает за оператор неравенства !=. Он позволяет определить, когда два объекта вашего класса считаются неравными.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __ne__ (self, other):
        return self.name != other.name or self.age != other.age

p1 = Person("Alice", 30)
p2 = Person("Alice", 30)
p3 = Person("Bob", 25)

print(p1 != p2)  # Вывод: False
print(p1 != p3)  # Вывод: True

🟠Метод `lt`
Отвечает за оператор меньше <. Он позволяет определить, когда один объект вашего класса считается меньше другого.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __lt__(self, other):
        return self.age < other.age

p1 = Person("Alice", 30)
p2 = Person("Bob", 25)

print(p1 < p2)  # Вывод: False
print(p2 < p1)  # Вывод: True

🟠Метод `le`
Отвечает за оператор меньше или равно <=. Он позволяет определить, когда один объект вашего класса считается меньше или равен другому.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __le__(self, other):
        return self.age <= other.age

p1 = Person("Alice", 30)
p2 = Person("Bob", 30)
p3 = Person("Charlie", 25)

print(p1 <= p2)  # Вывод: True
print(p1 <= p3)  # Вывод: False

🟠Метод `gt`
Отвечает за оператор больше >. Он позволяет определить, когда один объект вашего класса считается больше другого.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __gt__(self, other):
        return self.age > other.age

p1 = Person("Alice", 30)
p2 = Person("Bob", 25)

print(p1 > p2)  # Вывод: True
print(p2 > p1)  # Вывод: False

🟠Метод `ge`
Отвечает за оператор больше или равно >=. Он позволяет определить, когда один объект вашего класса считается больше или равен другому.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __ge__(self, other):
        return self.age >= other.age

p1 = Person("Alice", 30)
p2 = Person("Bob", 30)
p3 = Person("Charlie", 25)

print(p1 >= p2)  # Вывод: True
print(p1 >= p3)  # Вывод: True
print(p3 >= p1)  # Вывод: False

Ставь 👍 и забирай 📚 Базу знаний