Объектно-ориентированное программирование на Python: подробное объясне

Узнайте об основах объектно-ориентированного программирования на Python с подробным объяснением его концепций и принципов.

Объектно-ориентированное программирование — популярный способ написания компьютерных программ.

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

В этом руководстве будут рассмотрены основы, включая некоторые концепции, которые не рассматриваются в большинстве руководств, например:

Что такое «__init__»?
Чем отличаются методы и функции?
Что означает параметр «self» в Python?

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

Что мы рассмотрим:

Что такое ООП ?
Что такое классы и экземпляры классов?
Как создавать классы с помощью «__init__»
Что такое ключевое слово self?
Переменные класса
Методы в ООП
Куда пойти отсюда

В этом руководстве предполагается, что вы знаете основы программирования на Python .

Не стесняйтесь использовать код и изображения публикаций в репозитории GitHub ниже.

Что такое ООП?

Фото Биньямина Меллиша: Pexels

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

Вы решаете, что все дома будут иметь более или менее одинаковую структуру.

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

Каждый дом будет построен по единому плану дома, разработанному архитектором.

Фото JESHOOTS.com

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

В этом случае можно сказать, что ваша компания строит дома по домостроительному принципу.

В этой аналогии:

Рисунок = класс
Дом = экземпляр класса или объекта
Домоориентированное здание = Объектно-ориентированное программирование

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

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

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

Однако в объектно-ориентированном программировании вы создаете схемы управления данными и их создания.

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

А в программировании использование чертежей для создания объектов позволяет повторно использовать код и легко дорабатывать его.

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

Основные принципы ООП

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

Чтобы написать отличный код, ООП следует четырем столпам:

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

Чтобы связать это с нашим примером строительства дома:

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

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

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

Можете ли вы писать объектно-ориентированный код на разных языках?

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

Например, возьмем Java. Он разработан специально для ООП. В Java вы создаете классы и объекты для структурирования своего кода.

Это все равно, что создавать чертежи, а затем строить по этим чертежам.

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

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

Его также можно использовать для процедурного программирования, когда вы даете простые инструкции, например список дел.

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

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

Что такое классы и экземпляры классов (или объектов)?

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

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

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

Но как все это выглядит в реальном коде?

Как создавать классы вручную:

class house():
    pass

house1 = house()
house2 = house()

house1.address = 1234;
house1.state = "california"
house1.Alarm = False;
house1.price = 300000;

house2.address = 5678;
house2.state = "texas"
house2.Alarm = True;
house2.price = 100000;

print(house1.state)
print(house2.price)

>>> california
>>> 100000

В первой строке мы создали проект дома без каких-либо предопределенных настроек.

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

Затем мы создали 2 дома с одинаковыми характеристиками:

Адрес дома
Состояние дома
Есть ли сигнализация или нет
Цена дома

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

Но что, если вы хотите создать 100 домов с заполненными индивидуальными характеристиками для каждого дома?

Добавление всех этих атрибутов класса вручную довольно утомительно и отнимает много времени.

Давайте посмотрим, как мы можем это упростить:

Как создавать классы с помощью init:

class house():
    def __init__(self, address, state, Alarm, price):
        self.address = address
        self.state = state
        self.Alarm = Alarm
        self.price = price


house1 = house(1234, "california", False , 300000)

house2 = house(5678, "texas", True , 100000)

print(house1.state)
print(house2.price)

>>> california
>>> 100000

Выходные данные этого блока кода и блока из предыдущего раздела одинаковы.

В первом 18 линий и создать дом сложно. Второй имеет 14 линий и можно легко построить дом.

В этом суть программирования – автоматизировать вещи и сделать их проще.

У вас могут возникнуть вопросы по приведенному выше коду. Давайте посмотрим на это более подробно.

Что такое init?

__init__это конструктор Python. Он сообщает интерпретатору Python, что вы хотите создать класс с определенными атрибутами , такими как цена, состояние и т. д. в данном случае.

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

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

Нужные атрибуты находятся рядом с конструктором.

Но почему здесь находится переменная «self»? И что значит сам?

Что такое selfключевое слово?

Ключевое selfслово просто сообщает вам, что определенный атрибут меняется от объекта к объекту.

Ниже приведен пример того, что я имею в виду:

self.address = address

Это то же самое, что написать:

house1.address = 1234;

Однако, написав:

  def __init__(self, address, state, alarm, price):
        self.address = address
        self.state = state
        self.alarm = alarm
        self.price = price

Вы говорите, что хотите создать дом ( __init__) с четырьмя характеристиками: адресом, состоянием, сигнализацией и ценой.

Вы говорите, что в любом экземпляре класса . Характеристика дома такая же, как и в параметрах.

Таким образом, при написании:

house1 = house(1234, "california", False , 300000)

Он подумает:

house1.address = 1234
house1.state = "california"
house1.alarm = False
house1.price = 300000

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

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

Почему вся эта путаница?

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

class house():
    def __init__(self, address, street , state):
        self.address = address
        self.street = street
        self.state = state

        self.completeAddress = str(address) + " " + state


house = house(1234, "california", "awesome road")

print(house.completeAddress)

>>>1234 awesome road

С помощью self мы можем создавать другие атрибуты на основе __init__параметров.

Функция __init__не имеет completeAddressпараметра.

Он был построен на основе адреса, улицы и государственных ценностей.

(Обратите внимание, что это случайный адрес и он не настоящий.)

Итак, на данный момент мы увидели, что можем построить множество домов на основе одного плана дома.

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

Фото автора Pixabay: Pexels

В каждой комнате в каждом доме будет одинаковый ковер. Другие вещи в доме, например диван, могут быть разными .

Предположим также, что во всех домах будет диван.

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

Например, атрибуты:

адрес
состояние
тревога
цена

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

Таким образом, диван — это переменная экземпляра , а ковер — это переменная класса.

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

Другой пример переменной класса — название компании, строящей дома:

class house():

    company_name = "Awesome building company"

    def __init__(self, address, state, Alarm, price):
        self.address = address
        self.state = state
        self.Alarm = Alarm
        self.price = price


house1 = house(1234, "california", False , 300000)

house2 = house(5678, "texas", True , 100000)

Переменная класса здесь — это название компании: «Потрясающая строительная компания».

Опять же, переменная, содержащая данные, специфичные для экземпляра, называется переменной экземпляра — она не используется совместно между классами.

Переменные, такие как состояние или цена, являются переменными экземпляра.

Переменные экземпляра = конкретные характеристики каждого дома (разные)
Переменные класса = Название компании, которая строит дом (то же самое)

Все экземпляры классов содержат переменные класса, и каждый экземпляр класса имеет свои собственные переменные экземпляра.

Что, если переменные изменяются со временем?

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

Например, со временем дом, который оценивался в 50 000 долларов, теперь будет стоить 54 000 долларов из-за инфляции в 8%.

Цена выросла. Итак, теперь у вас есть проблема:

Как вы собираетесь обновить новую цену дома, учитывая, что инфляция сейчас составляет 8%?

Один из ответов на этот вопрос — использовать метод обновления цены.

Проще говоря, метод — это функция внутри класса. Это всего лишь функция, но когда мы ее используем, она связана с классом.

Как исправить инфляцию

Теперь мы рассмотрим 3 способа корректировки цены:

Создание метода экземпляра внутри класса для коррекции цены
Использование метода класса для коррекции цены
Использование функции для коррекции цены

Все они выполняют одну и ту же операцию, только по-разному.

Как построить метод экземпляра внутри класса для коррекции цены

В этом первом примере мы создадим внутри класса метод экземпляра houseдля коррекции цены correctPriceMethod():

class house():

    company_name = "Awesome building company"

    inflation_coefficient = 1.08

    def __init__(self, address, state, Alarm, price):
        self.address = address
        self.state = state
        self.Alarm = Alarm
        self.price = price

    def correctPriceMethod(self):
        self.price = self.price * self.inflation_coefficient

В этом коде я создал метод под названием correctPriceMethod():

    def correctPriceMethod(self):
        self.price = self.price * self.inflation_coefficient

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

Например, предположим, что у нас есть квартира со следующей информацией:

apartment1 = house(1234, "california", False , 300000)

apartment1.correctPriceMethod()

print(apartment1.price)

В следующей строке:

 apartment.correctPriceMethod():

Метод обновляет цену с 300 000 до 324 000 долларов, чтобы отразить инфляцию.

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

class house():

    company_name = "Awesome building company"

    inflation_coefficient = 1.08

    def __init__(self, address, state, Alarm, price):
        self.address = address
        self.state = state
        self.Alarm = Alarm
        self.price = price

    def correctPriceMethod(self):
        self.price = self.price * self.inflation_coefficient
        
#----------------------------------------------------------------

apartment1 = house(1234, "california", False , 300000)
apartment2 = house(1234, "california", False , 300000)
apartment3Price = 300000

print(apartment1.price)

apartment1.correctPriceMethod()
print(apartment1.price)

>>> 300000
>>> 324000

Я обновил цену на квартиру 1 с помощью correctPriceMethod.

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

Как использовать метод класса для коррекции цены

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

Другими словами, вместо вызова метода apartment1.correctPriceMethod()я буду использовать house.correctPriceMethod(apartment2):

class house():

    company_name = "Awesome building company"

    inflation_coefficient = 1.08

    def __init__(self, address, state, Alarm, price):
        self.address = address
        self.state = state
        self.Alarm = Alarm
        self.price = price

    def correctPriceMethod(self):
        self.price = self.price * self.inflation_coefficient

#-----------------------------------------------------------

apartment1 = house(1234, "california", False , 300000)
apartment2 = house(1234, "california", False , 300000)
apartment3Price = 300000

apartment1.correctPriceMethod()

#-----------------------------------------------------------
print(apartment2.price)

house.correctPriceMethod(apartment2)
print(apartment2.price)

>>> 300000
>>> 324000

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

Другими словами, house.correctPriceMethod(apartment2)это apartment2.correctPriceMethod()одно и то же.

Первый получает метод из класса, а второй — из экземпляра класса.

Как использовать функцию для коррекции цены

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

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

Сейчас обновлю цену на третью квартиру, но на этот раз с функцией:

def correctPricefunction(apartment):
    return apartment * 1.08

Добавим это в код:

class house():

    company_name = "Awesome building company"

    inflation_coefficient = 1.08

    def __init__(self, address, state, Alarm, price):
        self.address = address
        self.state = state
        self.Alarm = Alarm
        self.price = price

    def correctPriceMethod(self):
        self.price = self.price * self.inflation_coefficient

#-----------------------------------------------------------

apartment1 = house(1234, "california", False , 300000)
apartment2 = house(1234, "california", False , 300000)
apartment3Price = 300000

apartment1.correctPriceMethod()

#-----------------------------------------------------------

house.correctPriceMethod(apartment2)

#-----------------------------------------------------------

def correctPricefunction(apartment):
    return apartment * 1.08

print(apartment3Price)

apartment3Price = correctPricefunction(apartment3Price)
print(apartment3Price)

>>> 300000
>>> 324000

Мы делаем то же самое только с ценой квартиры3, но на этот раз мы используем функцию.

Правильно, у нас то же самое. Никаких изменений нет.

Метод — это просто функция, связанная с классом, а функция сама по себе является функцией.

Используя метод, вы изолируете функцию, которая изменяет данные из класса, а не данные не из класса.

В Python есть случаи, когда лучше использовать функцию, а не метод .

Куда пойти отсюда?

Эта статья касается объектно-ориентированного программирования.

Чтобы полностью понять это, полезно изучить одно и то же с разных точек зрения.

Есть много вещей, которые вы можете сделать, чтобы узнать больше об объектно-ориентированном программировании:

Изучите объектно-ориентированное программирование с помощью Python

2. Изучите и напишите реальный код, лежащий в основе 4 основных столпов ООП в Python:

Полиморфизм
Инкапсуляция
Наследование
Абстракция

3. Применять и выполнять проекты ООП на Python и на другом языке программирования .

4. Более продвинутый уровень: изучите основные шаблоны проектирования программного обеспечения .

Подведение итогов

Вот что мы рассмотрели в этом уроке:

Какие классы
Что такое ключевое слово self и почему его легко понять
Что такое переменные класса
Разница между функциями и методами

Вы также узнали о некоторых лучших практиках объектно-ориентированного программирования.

Спасибо за чтение!

Источник: https://www.freecodecamp.org .

#python #oop