магические методы python что это
Магия в Python — создаём объект с магическими методами (ч. 1)
Добрый день, уважаемые читатели. Python всегда славился своим удобством по отношению к пользователю, это не для кого не секрет.
Лично мне всегда нравились «магические» методы — если по простому, то это методы, которые вызываются неявно во время вызова функций или выполнения различных операций.
В этой статье мы создадим класса n-мерного вектора, который будет использовать магические методы, которые согласуются с логикой операций над векторами.
Инициализация
В описании ValueError указано троеточие лишь из-за того, что полное описание ошибки не влезет в блок кода. В конце статьи будет оставлена ссылка на исходник, где будет присутствовать полное описание ошибок.
Такое объявление конструктора класса даёт нам возможность создать экземпляр класса двумя способами:
Использование встроенных функций
Протестируем эту возможность:
Чтобы протестировать эти методы, воспользуемся функцией print() и интерпретатором Python.
Математические магические методы
Концепция перегрузки операторов одинакова, потому я предоставляю список различных методов и соответствующих операций:
Это далеко не все магические методы, связанные с математическими операциями, однако этого нам на данный вполне достаточно. Ниже вы можете видеть реализацию всех этих методов:
Обратные операции
Реализуем все эти методы в нашем классе:
Теперь протестируем выполнение математических операций с нашим вектором
.
Если тестировать все операции, то статья выйдет слишком большой, но главную суть вы уловили.
Магические методы какЛогические операции
В Python есть три логические операции — И, ИЛИ, XOR.
Протестируем логические операции с нашим вектором:
Заключение
Сегодня мы разобрали множество магических методов, однако это далеко не всё. В ближайшее время выйдет продолжение этой статьи, где будут рассмотрены другие методы, а также альтернативные конструкторы. Также мы добавим функционал, свойственный вектору — к примеру, скалярное произведение с другим вектором.
Ссылка на код класса из статьи вы можете найти здесь.
На этом статья заканчивается. Если вы заинтересованы в математическом анализе, советую прочитать «Производная. Базовые определения и термины«.
А также подписывайтесь на группу ВКонтакте, Telegram и YouTube-канал. Там еще больше полезного и интересного для программистов.
Элегантное ООП в Python
Разбираемся с магическими методами в Python, облегчающими жизнь с ООП. Вам понравится!
Jan 22, 2020 · 3 min read
Что за магические методы?
Магические методы — это специальные методы в python, обрамленные двумя нижними подчеркиваниями. Они также известны как dunder методы. Многое из того, что мы делаем в Python, делается с использованием dunder методов. Посмотрите на примеры ниже:
Мы внедрим эти методы в наши классы, чтобы сделать их интуитивно понятными. Давайте разбираться как.
1. __init__()
Первый магический метод — это метод init. Он используется в качестве конструктора для классов в Python.
2. __str__()
При создании объектов классов очень хотелось бы видеть, что у них внутри, в легко читаемом для человека представлении. И здесь пригождается str:
Существует д р угой метод — __repr__() — который используется для возврата состояния объекта как он есть, но в данной статье мы пропустим этот метод.
3. __len__()
Теперь, предположим, у нас есть класс School, который хранит детальную информацию о студентах. И вот простой способ посчитать количество студентов в School.
4. __getitem__()
Нам также нужен простой способ получить доступ к записям о конкретном студенте:
5. __setitem__()
…и возможность редактировать их.
6. __getattr__() and __setattr__()
Эти методы доступны в Python автоматически при создании класса, чтобы получать и задавать его атрибуты, следовательно нам не нужно их определять. Однако мы можем сделать это, если захотим изменить их поведение.
Например, можно изменить поведение __setattr__() для сохранения атрибута в списке, когда бы он ни был задан, чтобы легко получить доступ ко всем атрибутам.
7. __iter__()
Мы можем создать итератор, используя метод __iter__(). Затем мы можем использовать его для доступа к данным каждого студента.
Магические методы в Python
Mar 7, 2020 · 6 min read
Создание объекта dict, принимающего только целые и плавающие числа в качестве значений
В этом сценарии мы реализуем класс, который создает объекты-словари, принимающие только целые и плавающие значения.
При добавлении других типов данных, таких как строки, списки и кортежи, будет появляться исключение, указывающее пользователю, что пользовательский объект dict может принимать только целые и плавающие числа в качестве значений.
Для реализации этого процесса используются следующие методы:
__int__, __setitem__ и __str __
Для начала создаем пользовательский класс CustomIntFloat и передаем dict в список наследования аргументов. Это означает, что созданный объект будет вести себя как словарь, за исключением тех мест, в которых это поведение будет выборочно изменено.
Затем создаем м етод __init__, чтобы сконструировать объект dict CustomIntFloat, который принимает ключ и значение в список аргументов, установленный в тип None по умолчанию. Таким образом, если пользователь создает объект класса CustomIntFloat без передачи ключа или значения, будет сгенерирован пустой dict. Данное условие гласит: если ключ не передан, то параметру ключа по умолчанию присваивается аргумент None, а пустой dict создается путем ссылки на объект CustomIntFloat с атрибутом класса empty_dict.
Если пользователь указывает ключ length и соответствующее значение, которое является экземпляром класса int или float, то ключ и значение будут установлены в объекте.
Наконец, если пользователь указывает несколько ключей и значений в качестве итерируемых в операторе else, то они будут заархивированы функцией zip и им будет присвоено имя переменной zipped. Выполняем цикл на zipped, чтобы проверить, имеет ли значение тип int или float. Если нет, то будет сгенерировано пользовательское исключение CustomIntFloatError.
Класс исключения CustomIntFloatError и метод __str__
При генерации исключения CustomIntFloatError создается экземпляр класса CustomIntFloatError.
Таким образом, этот пользовательский класс исключений нуждается в помощи magic-методов __init__ и __str__. Созданный экземпляр принимает переданное значение и устанавливает его в качестве значения атрибута в классе CustomIntFloatError.
Это означает, что при появлении сообщения об ошибке значение, переданное в __init__ объекта CustomIntFloat, может быть установлено как атрибут ( self.value) в классе CustomIntFloatError и с легкостью проверено.
Если ввод неверный, то появляется исключение CustomIntFloatError, а объект не создается. Сообщение об ошибке информирует пользователя о том, что допустимыми являются только целые и плавающие значения.
Аналогичным образом при попытке создать экземпляр объекта z (который был закомментирован) с несколькими ключами и значениями, возникает то же исключение, информирующее пользователя о том, что ‘three’ не является допустимым вводом.
Метод __setitem__
__setitem__ — это magic-метод, который вызывается при установке ключа и значения в словаре. Если после создания объекта CustomIntFloat пользователь попытается добавить значение, которое не относится к типу int или float, появится то же исключение CustomIntFloatError. Ниже показано, как установить ключ и значение:
В результате недопустимого ввода возникает исключение CustomIntFloatError:
Обзор класса CustomIntFloat
С помощью наследования через такие встроенные классы, как dict, можно настраивать поведение через повторную реализацию magic-методов. У этого подхода есть множество преимуществ.
Стоит отметить, что пользователю не нужно изучать новый синтаксис. Он может добавить ключ и значение к объекту dict CustomIntFloat привычным образом. Единственным отличием является выбор допустимых значений типа int и float. Если пользователь указывает любой другой тип, то сообщение об ошибке информирует его об этом и указывает допустимые типы значений.
Сразу несколько методов
Примеры с использованием математических операторов
__sub__, __add__ и __mul__ (с пользовательским __repr__)
С помощью magic-методов можно также воспользоваться математическими операторами в Python. Рассмотрим на примере таких методов, как __add__, __sub__ и __mul__ в созданном нами пользовательском объекте.
Это означает, что при включении метода __add__ в класс можно воспользоваться знаком + в объектах.
Применение magic-методов оператора в классе
После создания объекта(ов) NumOperations можно с легкостью использовать magic-методы для работы с ними и передачи математической операции.
Например, magic-метод __sub__ принимает 2 объекта NumOperations, объединяет их списки и просматривает другие соответствующие им списки кортежей. Второй элемент в кортеже вычитается из первого, и это значение добавляется в новый список minuslst и передается в качестве аргумента в конструктор NumOperations.
Теперь он возвращает новый объект NumOperations.
Эта передача выполняется по методу __sub__. Это означает, что можно воспользоваться оператором минус (-).
Magic-метод __repr__ реализуется повторно, чтобы возвращать представление строки списка, установленное в новом объекте. Он был изменен, поэтому когда пользователь печатает выходные данные двух объектов NumOperations, результат будет соответствовать ожиданиям.
Ниже представлен список, где элементы были вычтены друг из друга:
Методы __add__ и __mul__ реализуются аналогично __sub__, однако используют списковое включение для сокращения количества строк кода.
Такое поведение при передаче аналогично таким пакетам анализа данных, как Pandas и Numpy.
Методы __add__ и __mul__ также предназначены для работы с двумя объектами NumOperations. Это означает, что пользователь может воспользоваться оператором плюс + и умножением *. Как видно из приведенного ниже примера, q является результатом x * y, который возвращает новый объект NumOperations. При вводе q мы получаем представление строки операции передачи в виде списка.
Исходный код доступен по ссылке на GitHub gist:
Магические методы в Python
Магический метод в Python определяется как специальный метод, который добавляет классу «магию». Он начинается и заканчивается двойным подчеркиванием, например _init_ или _str_.
Встроенные классы определяют множество магических методов. Функцию dir() можно использовать для просмотра количества магических методов, унаследованных классом. Имеют два префикса и суффикс подчеркивания в имени метода.
__init__
Метод _init_ вызывается после создания экземпляра класса, но до его возврата вызывающей стороне. Он вызывается без какого-либо вызова, когда экземпляр класса создается как конструктор в других языках программирования, таких как C ++, Java, C #, PHP и т. д. Также известен как инициализация и вызываются после _new_. Здесь вы должны инициализировать переменные экземпляра.
__str__
Эта функция вычисляет “неформальное” или хорошо печатаемое строковое представление объекта и должна возвращать строковый объект.
__repr__
Этот метод вызывается встроенной функцией repr() для вычисления «официального» строкового представления объекта и возвращает машиночитаемое представление типа. Цель _repr_ – быть недвусмысленной.
__len__
Эта функция должна возвращать длину объекта.
__call__
Мы можем сделать объект вызываемым, добавив магический метод _call_. Если он присутствует в классе, то этот класс может быть вызван. Экземпляр вызывается как функция, передавая ему любые позиционные аргументы.
__del__
Так же, как _init_, который является методом конструктора, _del_ похож на деструктор. Если вы открыли файл в _init _, _del_ может его закрыть.
__bytes__
Он предлагает вычислить представление объекта в виде байтовой строки и должен возвращать строковый объект.
__ge__
Этот метод вызывается при использовании оператора> = и возвращает True или False.
__neg__
Функция вызывается для унарного оператора.
__ipow__
Эта функция для экспонент с аргументами. например, a ** = b.
__le__
Эта функция нужна при сравнении с использованием оператора
Классы в Python: магические методы и свойства
Каждый разработчик Python, создающий (и использующий) классы, должен знать о “магических методах”.
Это те, которые начинаются и заканчиваются двойным подчеркиванием; вам известны некоторые из них, например __init()__.
Мы будем работать с несколькими из них и рассмотрим свойства, которые используются для инкапсуляции атрибутов класса.
Первые шаги
Будем учиться на примерах.
Итак, мы будем работать с классом, который я назову Time и который будет содержать три атрибута: часы, минуты и секунды.
Наша цель – выдать не конкретный час дня, а единицу времени в целом, поэтому мы допускаем значения больше 24 часов и меньше 0.
Пока у нас есть первое определение нашего класса, который принимает аргументы и хранит их в экземпляре, чтобы к ним можно было обращаться как к атрибутам.
Давайте попробуем: попробуем представить 14 часов 23 минуты и 10 секунд.
Аргументы имеют значение по умолчанию, равное нулю.
Теперь было бы интересно иметь возможность напечатать любой экземпляр Time напрямую и заставить его показать нам три его атрибута.
Если мы сделаем это сейчас, то увидим, что результат выглядит примерно так.
Это ничего не говорит нам об объекте, кроме его адреса в памяти.
Давайте изменим это, определив метод __repr()__ ниже инициализатора.
Результат этого метода будет возвращен функцией str() при попытке преобразовать экземпляр нашего класса в строку, что как раз и делает print().
Поэтому, если мы сейчас распечатаем наш объект, мы увидим более четкое представление.
Отлично! Мы уже реализовали наш первый магический метод.
Свойства
Свойства позволяют нам инкапсулировать атрибуты внутри класса. Для чего они нужны?
Давайте рассмотрим следующее.
По сути, проблема заключается в том, что ничто не мешает присвоить строку атрибуту, который должен быть целым числом.
Для решения этой проблемы мы воспользуемся встроенным декоратором property(), который позволяет нам контролировать получение и изменение значения атрибута.
Сделаем это для трех атрибутов.
Давайте начнем с времени.
Первое, что нам нужно сделать, это определить функцию, которая будет вызываться Python, когда он попытается получить доступ к значению нашего атрибута.
Таким образом, print(a.h) выведет значение, возвращаемое методом h().
Но мы еще не определили атрибут _h, то есть значение, которое мы хотим инкапсулировать, чтобы предотвратить присвоение ему любого типа данных, кроме целого.
Итак, следующее, что нужно сделать, это определить другую функцию, которая будет вызываться, когда атрибуту h будет присвоено новое значение.
Таким образом, выполнение a.h = 50 будет эквивалентно вызову вышеуказанной функции.
Это позволяет нам устанавливать ограничения на присваиваемые значения, например, проверять их тип данных.
Давайте проверим, что следующий код выдает ошибку.
То же самое произойдет, если аргументы будут неправильного типа, потому что метод __init()__ позаботится о присвоении переданных значений соответствующим атрибутам.
Давайте сделаем то же самое для двух других атрибутов и создадим дополнительный декоратор для проверки того, что аргумент value всегда является целым числом.
Отлично! Мы успешно решили проблему типа данных.
Теперь давайте разберемся с другим вопросом.
Мы знаем, что 60 секунд равны одной минуте, а 60 минут равны одному часу.
Необходимо, чтобы наш класс позаботился о балансировке данных автоматически: например, преобразовал 80 секунд в 1 минуту и 20 секунд, присвоив соответствующие атрибуты.
Для этого добавим баланс в методы, вызываемые при присвоении атрибутов m и s (сеттеры).
Функция _balance() создается перед определением класса.
Я не объясняю, как работает функция, потому что это не главная тема статьи.
Давайте убедимся, что теперь балансировка происходит автоматически.
Арифметические операции
Python позволяет реализовать это очень простым способом: определив методы __add()__ и __sub()__ соответственно.
Аналогично __mul()__ и __truediv()__ доступны для умножения (*) и деления (/).
Начнем со сложения.
Логика довольно проста: если a и b – два экземпляра Time, выполнение a + b Python вернет результат a.__add(b)__.
Для вычитания процедура аналогична.
Мы также можем выразить это в более функциональной форме следующим образом.
(Стандартный модуль operator определяет функции, которые действуют так же, как операторы Python, например, operator.add(a, b) соответствует а+b).
Теперь, чтобы избежать попыток сложения или вычитания экземпляра Time с объектом любого другого типа, мы должны проверить тип данных аргумента.
Давайте создадим декоратор для этого.
Давайте применим его к двум методам, которые мы только что создали.
Идеально! Далее рассмотрим, как сделать возможным сравнение между двумя экземплярами нашего класса.
Сравнение
Магические методы для каждой из операций сравнения следующие.
Давайте сначала реализуем последний вариант, который является более простым.
Мы знаем, что один экземпляр Time будет равен другому, когда часы, минуты и секунды совпадают.
Просто! Теперь продолжим с операцией a Полный код
Вот мы и добрались до конца! В Python существует множество других магических методов.
Ниже приведен код, который мы разработали на протяжении всей статьи.