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

Вступление

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

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

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

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

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

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

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

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

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

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

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

Класс

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

Отношения между классом и объектом можно понять, посмотрев на отношения между автомобилем и Audi. 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() .

Объекты

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

Объект также называется экземпляром; поэтому процесс создания объекта класса называется созданием экземпляра . В 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)) 

На выходе вы увидите:

 <class '__main__.Car'> 

Это говорит о том, что тип 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() , мы просто использовали имя класса. Важно отметить, что статические методы могут обращаться только к атрибутам класса в 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 оба результата с помощью оператора 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 , вы увидите сообщение «Объект класса автомобиля» на консоли. Это сообщение, которое мы напечатали внутри нашего пользовательского метода __str__

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

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

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

Чтобы создать конструктор, вам нужно создать метод с ключевым словом __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 и распечатали ее значение на экране. В выводе вы увидите значение message1 , напечатанное без ошибок.

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

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

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

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

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

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

 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.

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

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

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

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

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

 # 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 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 , содержащий 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 . Класс 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 Класс транспортного средства имеет 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 . Наконец, вы должны создать установщик свойств, который является @model.setter в приведенном выше скрипте.

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

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

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

Заключение

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