Для чего нужны классы в python

Как эффективно использовать классы Python

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

Классы Python: самые основы

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

Теперь мы можем определять различные экземпляры класса и поддерживать их порядок:

Мы бы добавили эти две строки без отступа после определения класса. Этот код будет работать, но мало что делает. Мы можем добавить метод для установки цены непосредственно под функцией __init__ в определении класса:

Мы также могли бы добавить несколько процедур, чтобы сообщать нам цену или продвигать товар за счет снижения цены:

Теперь мы можем добавить несколько вызовов наших методов после строк, в которых мы инициализировали экземпляры класса:

Если вы запустите сценарий, результат будет следующим:

Если вам нужно добавить больше подпрограмм, вы можете просто поместить их в определение класса.

Самое приятное во всем этом то, что вы можете добавлять и удалять столько объектов, сколько захотите. Удаление атрибута происходит так:

А если вы хотите удалить весь объект, вы делаете так:

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

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

Разделение забот: дать каждому классу свою работу

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

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

Развязка: упрощение обслуживания

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

Допустим, вы нашли ошибку в одном классе: вы можете исправить эту ошибку, не беспокоясь о других классах, потому что между ними нет связи. Точно так же вы можете добавлять новые функции, не опасаясь, что вы запутаетесь с другими частями программного обеспечения.

Скрытие реализации: определение того, что программисты могут и не могут использовать

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

Инкапсуляция: изменение кода, но не взаимодействия с пользователем

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

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

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

Наследование: написание ДНК структуры данных

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

Кроме того, наследование позволяет легко удалять или изменять части экземпляра или всего класса. Это делает конструкцию более гибкой.

Когда использовать классы

Объединение данных и методов вместе

Как правило, когда у вас есть набор данных с определенной структурой и вы хотите применить к нему определенные методы, используйте класс. Однако это допустимо только в том случае, если вы используете в своем коде несколько структур данных.

Если весь ваш код никогда не будет иметь дело с более чем одной структурой. Если у вас только одна структура данных, это действительно зависит от решаемой проблемы. Вы можете получить приблизительное представление, набросав свою программу с классом или без него; обычно довольно скоро вы увидите, какое решение проще.

Остерегайтесь глобальных переменных

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

Использование heapq или кучи

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

Если куча лучше подходит для ваших целей, вам не нужно определять класс. Встроенный в Python алгоритм heapq очереди кучи сделает всю работу за вас.

Рассмотрите возможность использования functools.partial()

У вас может возникнуть соблазн использовать класс, потому что вы постоянно вызываете функцию с одними и теми же аргументами. В большинстве случаев лучше использовать functools.partial() вместо него.

Реализовать довольно просто. Допустим, у вас есть функция, которая умножает два значения, но вы продолжаете использовать ее для удвоения значений. Чтобы избежать дублирования кода, вы можете написать это:

Намного проще, чем определять новый класс!

Определение на «будущее»

Некоторые программисты одержимы классами, потому что они настолько гибкие и расширяемые. Вот почему даже в солидных компаниях с опытными разработчиками вы можете встретить такой код:

Идея заключается в том, что по мере роста кода этот класс может понадобиться для любой новой структуры данных и связанных с ней методов. Но это плохая привычка!

Угадайте, что делают эти три строки кода? Ровно ничего. И эти строки совсем не сложно закодировать. Если вы думаете, что позже вам понадобится еще один класс, и действительно думаете, что можете забыть об этом в будущем, вы всегда можете оставить такой комментарий:

Хотя вы захотите сделать свой код расширяемым и защищенным от идиотов, инициализация класса, который ничего не делает, обычно является плохой идеей.

Классы, без сомнения, мощная концепция. При правильном использовании они могут сделать ваш код более аккуратным, читаемым и удобным в обслуживании.

Но ими часто злоупотребляют. А при неправильном использовании они могут загрязнять ваш код, пока вы ничего не поймете.

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

В этом смысле дзен Python подтвердил свой вердикт: в большинстве случаев действительно существует только один хороший способ делать что-то, будь то с классами или без них. Однако это не всегда полностью очевидно. Трудно понять, какой путь лучше.

Источник

Классы в Python

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

1. Создание класса в Python

Классы в Python могут моделировать практически все что угодно. Создадим простой класс, который будет описывать конкретный автомобиль:

Разберем код по порядку. В начале определяется класс с именем Car ( class Car ). По общепринятым соглашение название класса начинается с символа верхнего регистра. Круглые скобки в определение класса пусты, так как класс создается с нуля. Далее идет строка документации с кратким описанием. ( «»»Описание автомобиля»»» ).

1.1. Метод __init__()

Каждая из двух переменных self.brand = brand и self.model = model снабжена префиксом self и к ним можно обращаться вызовом self.brand и self.model. Значения берутся из параметров brand и model. Переменные, к которым вы обращаетесь через экземпляры, также называются атрибутами.

1.2. Создание экземпляра класса

С помощью класса Car мы можем создавать экземпляры для конкретного автомобиля. Каждый экземпляр описывает конкретный автомобиль и его параметры.

1.3. Обращение к атрибутам класса

К атрибутам экземпляра класса мы можем обращаться через запись:

В записи используется имя экземпляра класса и после точки имя атрибута (car_1.brand) или (car_1.model). В итоге на экран выведется следующая информация:

Bmw
X5

1.4. Вызов методов класса

После создания экземпляра на основе класса Car можете вызывать любые методы, написанные в классе. Чтобы вызвать метод, укажите экземпляр (car_1) и вызываемый метод после точки:

car_1. sold ()
car_1. discount ()

При вызове данных методов, Python выполнит код, написанный в этом методе.

Автомобиль Bmw X5 продан
На автомобиль Bmw X5 скидка 5%

2. Работа с классами на Python

В описание автомобиля есть три атрибута(параметра) это brand, model, years. Также мы создали новый атрибут mileage (пробег) и присвоили ему начальное значение 0. Так как пробег у всех автомобилей разный, в последующем мы сможем изменять этот атрибут. Метод get_full_name будет возвращать полное описание автомобиля. Метод read_mileage будет выводить пробег автомобиля.

Создадим экземпляр с классом Car и запустим методы:

car_2 = Car(‘audi’, ‘a4’, 2019)
print(car_2. get_full_name() )
car_2. read_mileage()

В результате в начале Python вызывает метот __init__() для создания нового экземпляра. Сохраняет название, модель, год выпуска и создает новый атрибут с пробегом равным 0. В итоге мы получим такой результат:

Автомобиль Audi A4 2019
Пробег автомобиля 0 км.

2.1. Прямое изменение значения атрибута

Для изменения значения атрибута можно обратиться к нему напрямую и присвоить ему новое значение. Изменим пробег автомобиля car_2:

car_2 = Car(‘audi’, ‘a4’, 2019)
print(car_2.get_full_name())
car_2.mileage = 38
car_2. read_mileage()

Мы обратились к нашему экземпляру car_2 и связанным с ним атрибутом пробега(mileage) и присвоили новое значение 38. Затем вызвали метод read_mileage() для проверки. В результате мы получим следующие данные.

Автомобиль Audi A4 2019
Пробег автомобиля 38 км.

2.2. Изменение значения атрибута с использованием метода

В Python удобнее писать методы, которые будут изменять атрибуты за вас. Для этого вы просто передаете новое значение методу, который обновит значения. Добавим в наш класс Car метод update_mileage() который будет изменять показания пробега.

car_2 = Car(‘audi’, ‘a4’, 2019)
print(car_2.get_full_name())

car_2. read_mileage()
car_2. update_mileage (17100)
car_2. read_mileage()

Вначале выведем текущие показания пробега ( car_2. read_mileage() ). Затем вызовем метод update_mileage() и передадим ему новое значение пробега ( car_2. update_mileage (17100) ). Этот метод устанавливает пробег 17100. Выведем текущие показания ( car_2. read_mileage() ) и у нас получается:

Автомобиль Audi A4 2019
Пробег автомобиля 0 км.
Пробег автомобиля 17100 км.

2.3. Изменение значения атрибута с приращением

Если вместо того, чтобы присвоить новое значение, требуется изменить с значение с приращением, то в этом случаем мы можем написать еще один метод, который будет просто прибавлять пробег к уже имеющемся показаниям. Для этого добавим метод add_mileage в класс Car :

Новый метод add_mileage() получает пробег в км и добавлет его к self.mileage.

car_2. add_mileage (14687)
car_2. read_mileage ()

Пробег автомобиля 31787 км.

В итоге после вызова метода add_mileage() пробег автомобиля в экземпляре car_2 увеличится на 14687 км и станет равным 31787 км. Данный метод мы можем вызывать каждый раз при изменении пробега и передавать новые значение, на которое будет увеличивать основной пробег.

3. Наследование класса в Python

class Car():
«»»Описание автомобиля»»»
def __init__(self, brand, model, years):
«»»Инициализирует атрибуты brand и model»»»
self.brand = brand
self.model = model
self.years = years
self.mileage = 0

def get_full_name(self):
«»»Автомобиль»»»
name = f»Автомобиль »
return name.title()

def read_mileage(self):
«»»Пробег автомобиля»»»
print(f»Пробег автомобиля км.»)

def update_mileage(self, new_mileage):
«»»Устанавливает новое значение пробега»»»
self.mileage = new_mileage

def add_mileage(self, km):
«»»Добавляет пробег»»»
self.mileage += km

Создадим экземпляр класса ElectriCar и сохраним его в переменную tesla_1

tesla_1 = ElectricCar (‘tesla’, ‘model x’, 2021)
print(tesla_1. get_full_name ())
tesla_1. battery_power ( )

При вызове двух методов мы получим:

Автомобиль Tesla Model X 2021
Мощность аккумулятора 100 кВт⋅ч

3.1. Переопределение методов класса-родителя

Методы, которые используются в родительском классе можно переопределить в классе-потомке (подклассе). Для этого в классе-потомке определяется метод с тем же именем, что и у класса-родителя. Python игнорирует метод родителя и переходит на метод, написанный в классе-потомке (подклассе). Переопределим метод def get_full_name() чтобы сразу выводилась мощность аккумуляторов.

В результате при запросе полного названия автомобиля Python проигнорирует метод def get_full_name() в классе-родителя Car и сразу перейдет к методу def get_full_name() написанный в классе ElectricCar.

tesla_1 = ElectricCar (‘tesla’, ‘model x’, 2021)
print(tesla_1. get_full_name ())

Автомобиль Tesla Model X 2021 100-Квт⋅Ч

Источник

Когда использовать классы (ООП)?

Я изучаю/программирую на Python уже как год, но до сих пор не могу понять когда использовать классы. Читая книги и просматривая видео уроки, я осознаю такие вещи как инкапсуляция или, что такое абстракция. Но, когда речь заходит о моментах когда именно надо использовать ООП, я встаю в ступор. В моем мышлении, классы можно заменить на модули с набором тематических функций. Никаких self ‘ов перед переменными и в качестве первого аргумента методов, никаких объявлений класса перед использованием, импортируй и пользуйся. Какие советы/материал для изучения Вы можете дать для понятия данной темы и изучения ООП в целом?

P.S. Я видел похожий вопрос, но он не ответил на мой.

4 ответа 4

Это парадигма, которую вы можете использовать везде или не использовать вообще. У неё есть свои плюсы и свои минусы. Но какого-то магического порога, когда её использовать или когда её не использовать нету.

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

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

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

P.S. В общем, можете прямо сразу брать и использовать ООП везде, даже в самых маленьких программах. Правда для Python и маленьких программ, это просто лишняя трата сил на проектирование, как по мне. Но может будет очень полезно при работе с базами данных и ORM.

В моем мышлении, классы можно заменить на модули с набором тематических функций. Никаких self’ов перед переменными и в качестве первого аргумента методов, никаких объявлений класса перед использованием, импортируй и пользуйся.

Будет аналогичен такому модулю:

То же самое в виде отдельных функций:

никаких объявлений класса перед использованием, импортируй и пользуйся.

Достаточно положить класс в модуль, потом импортировать, создать объект и пользоваться.

Но, когда речь заходит о моментах когда именно надо использовать ООП, я встаю в ступор.

Потому что не набита рука. Когда рука будет набита, будете наоборот из классов искать элементали, что бы их в библиотеку турнуть вон из объекта.

Теперь по tid-у, родительский поток может видеть кишки всех своих детишек:

Так же и с базами данных..

Источник

Знакомство с классами в Python

Всё, что нужно знать о классах Python!

Python — это высокоуровневый язык объектно-ориентированного программирования, созданный специально для того, чтобы помочь программистам в написании ясного логичного кода для проектов любого размера.

Чёткость, лёгкость в понимании и в то же время мощь — нигде больше не проявляются эти принципы так, как в классах Python.

Класс Python

Почти всё в Python можно назвать объектом. И у каждого объекта, естественно, есть свои характеристики, свойства и функции.

Мы можем считать класс неким «макетом» для создания объектов. Точнее сказать — нашим собственным специально настраиваемым макетом. А раз мы сами под себя его настраиваем, то и задавать ему можем любые характеристики, свойства и функции!

Начнём с простого примера. Создадим класс со свойством «x», где x=10. Вот определение нашего класса:

Вот и всё! Мы создали наш первый класс Python my_class со свойством x и значением 10. Чтобы использовать класс, вызываем нашу функцию. Дальше мы можем обращаться к любым свойствам класса по отдельности.

Данный код выводит число 10. Всё просто!

Ещё мы можем поменять переменную, просто присвоив ей новое значение. Вместо того, чтобы x был равен 10, пусть он равняется строке «Bob».

Функция __init__()

В качестве примера возьмём следующий код:

Результат этого кода будет такой:

Функции класса

Как любой объект, классы Python могут содержать функции! Находясь внутри класса, функции ведут себя точно так же, как вне его. Единственное отличие — способность функций класса обращаться непосредственно к переменным класса, не принимая их в качестве аргументов.

С другой стороны, трудно не заметить, как много кода нам требуется для отображения информации о Бобе с использованием print() в Python. Ну и наличие функций, специально предназначенных для того, чтобы конкретный тип-класс определялся в рамках этого класса, лучше организует код.

Заключение

Вот и всё. Вы прошли вводный курс, посвящённый классам Python.

Если вам этого мало, займитесь изучением программирования. Отлично подойдёт для начала вот этот сайт GeeksForGeeks website (Eng). Если вам нравятся приложения или вы предпочли бы записаться на какие-нибудь курсы, в Coursera есть курс Python for Everybody (Eng), в котором больше внимания уделяется приложениям.

Источник

Основы ООП в Python — классы, объекты, методы

О ОП — самая используемая парадигма программирования. Это одновременно и особый способ мышления, и отдельная методика. Её концепцию проще всего понимать на примерах из реальной жизни. И это неспроста. Объектно-ориентированное программирование помогает представлять содержимое программы наиболее естественным для нашего мира способом.

Главным понятием ООП является понятие программного объекта. Вообще говоря, большинство сущностей на планете Земля — это некие объекты. И с частью из них мы взаимодействуем при помощи программирования. Банковский счёт, персонаж компьютерной игры или анимированный виджет сайта — всё это легко представить в виде объектов. Можно сказать, что объектно-ориентированное программирование позволяет смоделировать реальный объект в виде программного.

Множество объектов со схожими свойствами формируются в классы. Идея класса также является одной из основополагающих концепций ООП. Со стороны программы, класс — это всего лишь тип данных, но для программиста это куда более глубокая абстрактная структура. Но перейдём уже к конкретике.

💁‍♂️ Итак, мы — разработчики игр. Наша студия трудится над новым автосимулятором. В игре будут представлены разные виды транспорта: легковые автомобили, гоночные, грузовые и пассажирские. Все их можно описать одним словом — автотранспорт. Сделав это, мы абстрагировались от деталей и, таким образом, определили класс. Объектом этого класса может быть, как Бьюик 1968-го года, так и грузовой Freightliner Columbia желтого цвета.

У класса есть свойства и функции (в ООП их называют методами).

Свойствами класса «автотранспорт» могут быть, например: год выпуска, вид и цвет. На уровне объектов это будет выглядеть так: Бьюик Электра — это объект класса «Автотранспорт» со следующими свойствами:

Можно сказать, что объект — это вполне конкретный экземпляр класса

Помимо физических атрибутов, которые описывают внешний вид и характеристики транспортного средства, автомобили обладают между собой и другими фундаментальными сходствами. Например, все они могут ехать, тормозить, переключать скорости, поворачивать и сигналить. В нашем случае, всё это — методы класса «Автотранспорт». То есть действия, которые любые объекты данного класса могут выполнять.

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

В Питоне класс «Автотранспорт» может выглядеть так:

# класс автотранспорт class MotorTransport(object): def __init__(self, color, year, auto_type): self.color = color self.year = year self.auto_type = auto_type # тормозить def stop(self): print(«Pressing the brake pedal») # ехать def drive(self): print(‘WRRRRRUM!’)

Теперь никто не помешает нам получить собственную красную феррари. Пусть и в симуляторе.

# создадим объект класса Автотранспорт ferrari_testarossa = MotorTransport(‘Red’, 1987, ‘passenger car’) # жмём на газ и вперёд! ferrari_testarossa.drive() > WRRRRRUM!

Принципы ООП

Абстракция

Абстракция — это выделение основных, наиболее значимых характеристик объекта и игнорирование второстепенных.

Любой составной объект реального мира — это абстракция. Говоря «ноутбук», вам не требуется дальнейших пояснений, вроде того, что это организованный набор пластика, металла, жидкокристаллического дисплея и микросхем. Абстракция позволяет игнорировать нерелевантные детали, поэтому для нашего сознания это один из главных способов справляться со сложностью реального мира. Если б, подходя к холодильнику, вы должны были иметь дело с отдельно металлом корпуса, пластиковыми фрагментами, лакокрасочным слоем и мотором, вы вряд ли смогли бы достать из морозилки замороженную клубнику.

Полиморфизм

Наследование

Это способность одного класса расширять понятие другого, и главный механизм повторного использования кода в ООП. Вернёмся к нашему автосимулятору. На уровне абстракции «Автотранспорт» мы не учитываем особенности каждого конкретного вида транспортного средства, а рассматриваем их «в целом». Если же более детализировано приглядеться, например, к грузовикам, то окажется, что у них есть такие свойства и возможности, которых нет ни у легковых, ни у пассажирских машин. Но, при этом, они всё ещё обладают всеми другими характеристиками, присущими автотранспорту.

Мы могли бы сделать отдельный класс «Грузовик», который является наследником «Автотранспорта». Объекты этого класса могли бы определять все прошлые атрибуты (цвет, год выпуска), но и получить новые. Для грузовиков это могли быть грузоподъёмность, снаряженная масса и наличие жилого отсека в кабине. А методом, который есть только у грузовиков, могла быть функция сцепления и отцепления прицепа.

Инкапсуляция

Инкапсуляция — это ещё один принцип, который нужен для безопасности и управления сложностью кода. Инкапсуляция блокирует доступ к деталям сложной концепции. Абстракция подразумевает возможность рассмотреть объект с общей точки зрения, а инкапсуляция не позволяет рассматривать этот объект с какой-либо другой.

Вы разработали для муниципальных служб класс «Квартира». У неё есть свойства вроде адреса, метража и высоты потолков. И методы, такие как получение информации о каждом из этих свойств и, главное, метод, реализующий постановку на учёт в Росреестре. Это готовая концепция, и вам не нужно чтобы кто-то мог добавлять методы «открыть дверь» и «получить место хранения денег». Это А) Небезопасно и Б) Избыточно, а также, в рамках выбранной реализации, не нужно. Работникам Росреестра не требуется заходить к вам домой, чтобы узнать высоту потолков — они пользуются только теми документами, которые вы сами им предоставили.

Класс

Классы, в некотором смысле, подобны чертежам: это не объекты сами по себе, а их схемы. Класс «банковских счетов» имеет строго определенные и одинаковые для всех атрибуты, но объекты в нём — сами счета — уникальны.

Как в Python создать класс

class SimpleClass: pass

Для именования классов в Python обычно используют стиль «camel case», где первая буква — заглавная.

Конструктор

Метод, который вызывается при создании объектов, в ООП зовётся конструктором. Он нужен для объектов, которые изначально должны иметь какие-то значение. Например, пустые экземпляры класса «Студент» бессмысленны, и желательно иметь хотя бы минимальный обозначенный набор вроде имени, фамилии и группы.

В качестве Питоновского конструктора выступает метод __init__() :

class Student: def __init__(self, name, surname, group): self.name = name self.surname = surname self.group = group alex = Student(«Alex», «Ivanov», «admin»)

Атрибуты класса

Поля могут быть статическими и динамическими:

☝️ Обратите внимание — статический и динамический атрибут может иметь одно и то же имя:

class MightiestWeapon: # статический атрибут name = «Default name» def __init__(self, name): # динамический атрибут self.name = name weapon = MightiestWeapon(«sword») print(MightiestWeapon.name) print(weapon.name)

Методы класса

Метод — это функция класса.

class SpaceShip: def atack(self): print(‘Пиу!’) star_destroyer = SpaceShip() star_destroyer.atack() > Пиу!

Что такое self?

🐈 Отличный пример с котофеями:

Уровни доступа атрибутов и методов

В Питоне не существует квалификаторов доступа к полям класса. Отсутствие аналогов связки public/private/protected можно рассматривать как упущение со стороны принципа инкапсуляции.

Декораторы

Декоратор — это функция-обёртка. В неё можно завернуть другой метод, и, тем самым, изменить его функциональность, не меняя код.

Объекты или экземпляры класса

Чем объекты отличаются от классов

Как уже было сказано, объект — это конкретный экземпляр класса. Все мы относимся к классу людей, но каждый из нас — уникальный объект этого класса.

Как создать объект класса в Python

Если у нас есть реализация класса, то его экземпляр создать очень просто:

class AirConditioner: def __init__(self, model, capacity): self.model = model self.capacity = capacity def turn_on(self): print(‘Now in the room will be cool’) # создадим объект класса Кондиционер ballu = AirConditioner(‘BPAC-07’, 785) ballu.turn_on() > Now in the room will be cool

Атрибуты объекта

Атрибуты класса могут быть динамическими и статическими. На уровне объекта они инициализируются так:

class MightiestWeapon: name = «Default name» def __init__(self, weapon_type): self.weapon_type = weapon_type # атрибут name можно переопределить и не создавая объекта MightiestWeapon.name = ‘Steel Sword’ print(MightiestWeapon.name) > Steal Sword # создаём объект и сразу же инициализируем динамический атрибут с помощью конструктора hero_sword = MightiestWeapon(‘sword’) # и теперь, уже для конкретного объекта, можно задать имя hero_sword.name = ‘Excalibur’ # новое статическое имя по умолчанию для всего класса не изменится print(MightiestWeapon.name) > Steal Sword print(hero_sword.name) > Excalibur

Наследование

Нередко в процессе написания кода выясняется, что некоторые объекты аналогичны другим за исключением нескольких различий. Определение сходств и различий между такими объектами называется «наследованием».

# класс «Животное». Это достаточно абстрактный класс всего с одним методом «Издать звук». class Animal: def make_a_sound(self): print(«Издаёт животный звук»)

Мы все прекрасно знаем, что котики, к примеру, любят всё ронять, а собакены — рыть землю. Создадим два соответствующих класса-наследника:

# факт наследования в Python указывается при объявлении класса-наследника. # в скобках, после имени класса, указывается класс-родитель class Cat(Animal): def drop_everything(self): print(‘Вставай скорее, я всё уронил!’) class Dog(Animal): def dig_the_ground(self): print(‘Однажды я докопаюсь до ядра планеты!’)

Теперь объекты этих двух классов могут не только издавать животные звуки, но и выполнять собственные уникальные действия:

Tom = Cat() Tom.make_a_sound() > Издаёт животный звук Tom.drop_everything() > Вставай скорее, я всё уронил!

Переопределение

Сейчас у нас и кошка, и собака просто «издают животные звуки», а хотелось бы, конечно, слышать звуки, свойственные именно этим животным. Для этого существует механика переопределения. Достаточно объявить в классе-наследнике метод с тем же названием, что и в базовом классе:

class Dog(Animal): def dig_the_ground(self): print(‘Однажды я докопаюсь до ядра планеты!’) # отныне для объектов класса «Собака» будет выполняться именно эта реализация метода def make_a_sound(self): print(‘Гав-гав!’) Balto = Dog() Balto.make_a_sound() > Гав-гав!

Документирование классов

Весь код нужно комментировать и документировать. Классы — не исключение. Стоит помнить, что код вы пишите не для себя, и вполне вероятно, что написанное вами придётся поддерживать другим людям. Комментарии повышают читаемость и увеличивают легкость восприятие кода в разы, тем самым экономя время и деньги.

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

Источник