Автор оригинала: Usman Malik.

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

• Вступление
• Плюсы и минусы ООП
• Класс
• Объекты
• Атрибуты
• Методы
• Конструкторы
• Локальные и Глобальные переменные
• Модификаторы доступа
• Наследование
• Полиморфизм
• Инкапсуляция
• Вывод

Вступление

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

Рассмотрим сценарий, в котором вы должны разработать автомобильную гоночную игру Формулы-1 с использованием объектно-ориентированного подхода программирования. Первое, что вам нужно сделать,-это идентифицировать реальные объекты в реальной гонке Формулы-1. Каковы сущности в гонке Формулы-1, которые обладают некоторыми характеристиками и могут выполнять любую функцию? Один из очевидных ответов на этот вопрос-автомобиль. Автомобиль может иметь такие характеристики, как мощность двигателя, марка, модель, производитель и т. Д. Точно так же автомобиль может быть запущен, остановлен, ускорен и так далее. Гонщик может быть еще одним объектом в гонке Формулы-1. Водитель имеет национальность, возраст, пол и т. Д., И он может выполнять такие функции, как управление автомобилем, перемещение рулевого управления или изменение коробки передач.

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

Здесь важно отметить, что объектно-ориентированное программирование не является концепцией, зависящей от языка. Это общая концепция программирования, и большинство современных языков, таких как Java, C#, C++ и Python, поддерживают объектно-ориентированное программирование. В этой статье мы увидим подробное введение в объектно-ориентированное программирование на Python, но перед этим мы увидим некоторые преимущества и недостатки объектно-ориентированного программирования.

Плюсы и минусы ООП

Ниже приведены некоторые преимущества объектно-ориентированного программирования:

• Объектно-ориентированное программирование способствует повторному использованию. Компьютерная программа написана в виде объектов и классов, которые могут быть повторно использованы и в других проектах.
• Модульный подход, используемый в объектно-ориентированном программировании, приводит к высокому уровню обслуживания кода.
• В объектно-ориентированном программировании каждый класс имеет определенную задачу. Если ошибка возникает в одной части кода, вы можете исправить ее локально, не затрагивая другие части кода.
• Инкапсуляция данных (которую мы рассмотрим далее в статье) добавляет дополнительный уровень безопасности программе, разработанной с использованием объектно-ориентированного подхода.

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

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

В следующем разделе мы рассмотрим некоторые из наиболее важных концепций объектно-ориентированного программирования.

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

Класс

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

Отношения между классом и объектом можно понять, взглянув на отношения между автомобилем и Audi. “Ауди” – это на самом деле автомобиль. Однако не существует такой вещи, как только автомобиль. Автомобиль-это абстрактное понятие, на самом деле оно реализовано в виде Toyota, Ferrari, Honda и т. д.

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

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

# Creates class Car
class Car:

    # create class attributes
    name = "c200"
    make = "mercedez"
    model = 2008

    # create class methods
    def start(self):
        print ("Engine started")

    def stop(self):
        print ("Engine switched off")

В приведенном выше примере мы создаем класс с именем Car с тремя атрибутами: name , make и model . Класс car также содержит два метода: start() и stop() .

Объекты

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

Объект также называется экземпляром; поэтому процесс создания объекта класса называется instantiation . В Python для создания объекта класса нам просто нужно написать имя класса, за которым следуют открывающие и закрывающие скобки.

Давайте создадим объект класса Car , который мы создали в предыдущем разделе.

# Creates car_a object of Car class
car_a = Car()

# Creates car_b object of car class
car_b = Car()

В приведенном выше скрипте мы создали два объекта класса car: car_a и car_b . Чтобы проверить тип созданных нами объектов, мы можем использовать метод type и передать ему имя нашего объекта. Выполните следующий сценарий:

print(type(car_b))

В выводе вы увидите:

Который говорит, что тип объекта car_b является классом Car .

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

car_b.start()

В приведенном выше скрипте мы вызываем метод start() через объект car_b . Результат будет следующим:

Engine started

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

print(car_b.model)

В выходных данных вы увидите значение атрибута model , как показано ниже:

2008

Атрибуты

В предыдущем разделе мы видели, как мы можем создавать объекты класса и использовать эти объекты для доступа к атрибутам класса.

В Python каждый объект имеет некоторые атрибуты и методы по умолчанию в дополнение к пользовательским атрибутам. Для просмотра всех атрибутов и методов объекта можно использовать встроенную функцию dir () . Давайте попробуем увидеть все атрибуты объекта car_b , который мы создали в предыдущем разделе. Выполните следующий сценарий:

dir(car_b)

В выходных данных вы увидите следующие атрибуты:

['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 'make',
 'model',
 'name',
 'start',
 'stop']

Эта встроенная функция полезна для проверки всех атрибутов и функций объекта, особенно при использовании через REPL Python.

Атрибуты класса и экземпляра

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

Помните, что экземпляр-это просто другое имя для объекта. Атрибуты экземпляра объявляются внутри любого метода, в то время как атрибуты класса объявляются вне любого метода. Следующий пример проясняет разницу:

class Car:

    # create class attributes
    car_count = 0

    # create class methods
    def start(self, name, make, model):
        print ("Engine started")
        self.name = name
        self.make = make
        self.model = model
        Car.car_count += 1

В приведенном выше скрипте мы создаем класс Car с одним атрибутом класса car_count и тремя атрибутами экземпляра name , make и mode . Класс содержит один метод start () , который содержит три атрибута экземпляра. Значения атрибутов экземпляра передаются в качестве аргументов методу start () . Внутри метода start атрибут car_count увеличивается на единицу.

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

Давайте создадим объект класса Car и вызовем метод start () .

car_a = Car()
car_a.start("Corrola", "Toyota", 2015)
print(car_a.name)
print(car_a.car_count)

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

Engine started
Corrola
1

Теперь давайте создадим еще один объект класса car и вызовем метод start () .

car_b = Car()
car_b.start("City", "Honda", 2013)
print(car_b.name)
print(car_b.car_count)

Теперь, если вы напечатаете значение атрибута car_count , вы увидите 2 в выходных данных. Это происходит потому, что атрибут car_count является атрибутом класса и, следовательно, является общим для экземпляров. Объект car_a увеличил свое значение до 1, в то время как объект car_b увеличил его снова, следовательно, конечное значение стало 2. Вывод выглядит следующим образом:

Engine started
City
2

Методы

Как мы уже говорили ранее, в объектно-ориентированном программировании методы используются для реализации функциональных возможностей объекта. В предыдущем разделе мы создали методы start() и stop() для класса Car . До сих пор мы использовали объекты класса для вызова методов. Однако существует тип метода, который может быть вызван непосредственно с помощью имени класса. Такой метод называется статическим методом.

Статические методы

Чтобы объявить статический метод, необходимо указать дескриптор @staticmethod перед именем метода, как показано ниже:

class Car:

    @staticmethod
    def get_class_details():
        print ("This is a car class")

Car.get_class_details()

В приведенном выше скрипте мы создаем класс Car с одним статическим методом get_class_details() . Давайте назовем этот метод именем класса.

Car.get_class_details()

Вы можете видеть, что нам не нужно было создавать экземпляр класса Car для вызова метода get_class_details () , скорее мы просто использовали имя класса. Важно отметить, что статические методы могут обращаться только к атрибутам class в Python.

Возврат нескольких значений из метода

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

class Square:

    @staticmethod
    def get_squares(a, b):
        return a*a, b*b

print(Square.get_squares(3, 5))

В приведенном выше скрипте мы создали класс с именем Square с одним статическим методом get_squares() . Метод принимает два параметра; умножает каждый параметр на себя и возвращает оба результата с помощью оператора return . В выводе скрипта выше вы увидите квадраты 3 и 5.

Метод str

До сих пор мы печатали атрибуты с помощью метода print () . Давайте посмотрим, что произойдет, если мы напечатаем объект класса.

Для этого мы создадим простой класс Car с одним методом и попытаемся вывести объект класса на консоль. Выполните следующий сценарий:

class Car:

    # create class methods
    def start(self):
        print ("Engine started")

car_a = Car()
print(car_a)

В приведенном выше скрипте мы создаем car_a объект класса Car и выводим его значение на экран. В основном здесь мы рассматриваем объект car_a как строку. Выход выглядит примерно так:

<__main__.Car object at 0x000001CCCF4335C0>

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

# Creates class Car
class Car:

    # create class methods

    def __str__(self):
        return "Car class Object"

    def start(self):
        print ("Engine started")

car_a = Car()
print(car_a)

В приведенном выше сценарии мы переопределяем метод __str__ , предоставляя для него собственное пользовательское определение. Теперь, если вы напечатаете объект car_a , вы увидите сообщение “Car class Object” на консоли. Это сообщение, которое мы напечатали внутри нашего пользовательского метода __str__ .

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

Конструкторы

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

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

class Car:

    # create class attributes
    car_count = 0

    # create class methods
    def __init__(self):
        Car.car_count +=1
        print(Car.car_count)

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

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

car_a = Car()
car_b = Car()
car_c = Car()

В выходных данных вы увидите напечатанные значения 1, 2 и 3, так как с каждым объектом значение переменной car_count увеличивается и отображается на экране.

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

Локальные и Глобальные переменные

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

Локальные переменные

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

# Creates class Car
class Car:
    def start(self):
        message = "Engine started"
        return message

В приведенном выше скрипте мы создаем локальную переменную message внутри метода start() класса Car . Теперь давайте создадим объект класса Car и попытаемся получить доступ к локальной переменной message , как показано ниже:

car_a = Car()
print(car_a.message)

Приведенный выше скрипт вернет следующую ошибку:

AttributeError: 'Car' object has no attribute 'message'

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

Глобальная переменная

Глобальная переменная определяется вне любого блока кода, например метода, if-операторов и т. Д. Глобальная переменная может быть доступна в любом месте класса. Взгляните на следующий пример.

# Creates class Car
class Car:
    message1 = "Engine started"

    def start(self):
        message2 = "Car started"
        return message2

car_a = Car()
print(car_a.message1)

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

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

Модификаторы доступа

Модификаторы доступа в Python используются для изменения области действия переменных по умолчанию. В Python существует три типа модификаторов доступа: public, private и protected.

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

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

Давайте посмотрим на публичные, частные и защищенные переменные в действии. Выполните следующий сценарий:

class Car:
    def __init__(self):
        print ("Engine started")
        self.name = "corolla"
        self.__make = "toyota"
        self._model = 1999

В приведенном выше скрипте мы создаем простой класс Car с конструктором и тремя переменными name , make и model . Переменная name является публичной, в то время как переменные make и model объявлены закрытыми и защищенными соответственно.

Давайте создадим объект класса Car и попытаемся получить доступ к переменной name . Выполните следующий сценарий:

car_a = Car()
print(car_a.name)

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

Теперь попробуем вывести значение переменной make . Выполните следующий сценарий:

print(car_a.make)

В выходных данных вы увидите следующее сообщение об ошибке:

AttributeError: 'Car' object has no attribute 'make'

В последних разделах мы рассмотрели большинство основных концепций объектно-ориентированного программирования. Теперь давайте поговорим о столпах объектно-ориентированного программирования: полиморфизме, наследовании и инкапсуляции, которые в совокупности называются PIE.

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

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

В объектно-ориентированном программировании наследование означает отношение “ЕСТЬ-Есть”. Например, автомобиль – это транспортное средство. Наследование-одна из самых удивительных концепций объектно-ориентированного программирования, поскольку она способствует повторному использованию кода.

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

Давайте рассмотрим очень простой пример наследования. Выполните следующий сценарий:

# Create Class Vehicle
class Vehicle:
    def vehicle_method(self):
        print("This is parent Vehicle class method")

# Create Class Car that inherits Vehicle
class Car(Vehicle):
    def car_method(self):
        print("This is child Car class method")

В приведенном выше сценарии мы создаем два класса Vehicle class и класс Car , который наследует класс Vehicle . Чтобы наследовать класс, вам просто нужно написать имя родительского класса внутри круглой скобки, которая следует за именем дочернего класса. Класс Vehicle содержит метод vehicle_method () , а дочерний класс содержит метод car_method() . Однако, поскольку класс Car наследует класс Vehicle , он также наследует vehicle_method() .

Давайте посмотрим на это в действии. Выполните следующий сценарий:

car_a = Car()
car_a.vehicle_method() # Calling parent class method

В приведенном выше скрипте мы создаем объект класса Car и вызываем vehicle_method () , используя этот объект класса Car . Вы можете видеть , что класс Car не имеет никакого vehicle_method () , но поскольку он унаследовал класс vehicle_method () , класс car также может использовать его. Выход выглядит примерно так:

This is parent Vehicle class method

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

# Create Class Vehicle
class Vehicle:
    def vehicle_method(self):
        print("This is parent Vehicle class method")

# Create Class Car that inherits Vehicle
class Car(Vehicle):
    def car_method(self):
        print("This is child Car class method")

# Create Class Cycle that inherits Vehicle
class Cycle(Vehicle):
    def cycleMethod(self):
        print("This is child Cycle class method")

В приведенном выше скрипте родительский Vehicle класс наследуется двумя дочерними классами Car и Cycle . Оба дочерних класса будут иметь доступ к vehicle_method() родительского класса. Выполните следующий сценарий, чтобы увидеть это:

car_a = Car()
car_a.vehicle_method() # Calling parent class method
car_b = Cycle()
car_b.vehicle_method() # Calling parent class method

В выводе вы увидите вывод метода vehicle_method() дважды, как показано ниже:

This is parent Vehicle class method
This is parent Vehicle class method

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

class Camera:
    def camera_method(self):
        print("This is parent Camera class method")

class Radio:
    def radio_method(self):
        print("This is parent Radio class method")

class CellPhone(Camera, Radio):
     def cell_phone_method(self):
        print("This is child CellPhone class method")

В приведенном выше сценарии мы создаем три класса: Камера , Радио и Сотовый телефон . Класс Camera и классы Radio наследуются классом CellPhone , что означает, что класс CellPhone будет иметь доступ к методам обоих классов Camera и Radio . Следующий сценарий проверяет это:

cell_phone_a = CellPhone()
cell_phone_a.camera_method()
cell_phone_a.radio_method()

Выход выглядит примерно так:

This is parent Camera class method
This is parent Radio class method

Полиморфизм

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

Полиморфизм в программировании реализуется через перегрузку методов и переопределение методов.

Способ Перегрузки

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

# Creates class Car
class Car:
   def start(self, a, b=None):
        if b is not None:
            print (a + b)
        else:
            print (a)

В приведенном выше сценарии, если метод start() вызывается путем передачи одного аргумента, параметр будет выведен на экран. Однако если мы передадим 2 аргумента методу start () , он добавит оба аргумента и выведет результат суммы.

Давайте сначала попробуем с одним аргументом:

car_a = Car()
car_a.start(10)

На выходе вы увидите 10. Теперь давайте попробуем передать 2 аргумента:

car_a.start(10,20)

На выходе вы увидите 30.

Переопределение метода

Переопределение метода означает наличие метода с тем же именем в дочернем классе, что и в родительском. Определение метода отличается в родительском и дочернем классах, но имя остается тем же. Давайте возьмем простой пример переопределения метода в Python.

# Create Class Vehicle
class Vehicle:
    def print_details(self):
        print("This is parent Vehicle class method")

# Create Class Car that inherits Vehicle
class Car(Vehicle):
    def print_details(self):
        print("This is child Car class method")

# Create Class Cycle that inherits Vehicle
class Cycle(Vehicle):
    def print_details(self):
        print("This is child Cycle class method")

В приведенном выше скрипте классы Car и Cycle наследуют класс Vehicle . Класс vehicle имеет метод print_details () , который переопределяется дочерними классами. Теперь, если вы вызовете метод print_details () , результат будет зависеть от объекта, через который вызывается метод. Выполните следующий сценарий, чтобы увидеть эту концепцию в действии:

car_a = Vehicle()
car_a. print_details()

car_b = Car()
car_b.print_details()

car_c = Cycle()
car_c.print_details()

Результат будет выглядеть следующим образом:

This is parent Vehicle class method
This is child Car class method
This is child Cycle class method

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

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

Инкапсуляция-это третий столп объектно-ориентированного программирования. Инкапсуляция просто относится к сокрытию данных. Как правило, в объектно-ориентированном программировании один класс не должен иметь прямого доступа к данным другого класса. Скорее всего, доступ должен контролироваться с помощью методов класса.

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

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

# Creates class Car
class Car:

    # Creates Car class constructor
    def __init__(self, model):
        # initialize instance variables
        self.model = model

    # Creates model property
    @property
    def model(self):
        return self.__model

    # Create property setter
    @model.setter
    def model(self, model):
        if model < 2000:
            self.__model = 2000
        elif model > 2018:
            self.__model = 2018
        else:
            self.__model = model

    def getCarModel(self):
        return "The car model is " + str(self.model)
    
carA = Car(2088)
print(carA.getCarModel())

Собственность состоит из трех частей. Вы должны определить атрибут, который является model в приведенном выше скрипте. Затем вы должны определить свойство для атрибута с помощью @property decorator . Наконец, вы должны создать сеттер свойств, который является @model.setter дескриптором в приведенном выше скрипте.

Теперь, если вы попытаетесь ввести значение больше 2018 для атрибута модели, вы увидите, что это значение равно 2018. Давайте проверим это. Выполните следующий сценарий:

car_a = Car(2088)
print(car_a.get_car_model())

Здесь мы передаем 2088 в качестве значения для model , однако если вы выведете значение для атрибута model через функцию get_car_model () , то увидите 2018 в выходных данных.

Вывод

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