Объектно-ориентированное программирование на Python
Автор Популярный язык программирования Python также следует парадигме объектно-ориентированного программирования. Объявление классов и объектов в Python закладывают основу концепций ООП.
Что такое объектно-ориентированное программирование в Python?
Объектно-ориентированное программирование в Python – это способ компьютерного программирования, использующий идею «объектов» для представления данных и методов. Это также подход, используемый для создания аккуратного и многоразового кода вместо избыточного.
Программа разбита на автономные объекты или несколько мини-программ. Каждый индивидуальный объект представляет собой отдельную часть приложения, имеющую собственную логику и данные для взаимодействия внутри себя.
Что такое концепции ООП?
Основные концепции ООП (объектно-ориентированного программирования) в Python включают класс, объект, метод, наследование, полиморфизм, абстракцию данных и инкапсуляцию.
Что такое классы и объекты?
Класс – это набор объектов или план объектов, определяющих общие атрибуты и поведение. Возникает вопрос, как это сделать?
Что ж, он логически группирует данные таким образом, что повторное использование кода становится простым. Я могу привести вам пример из реальной жизни – представьте, что офис становится «сотрудником» как класс и все атрибуты, связанные с ним, такие как «emp_name», «emp_age», «emp_salary», «emp_id» как объекты в Python. Давайте посмотрим с точки зрения кодирования, как создать экземпляр класса и объекта.
Класс определяется ключевым словом «Класс». Пример:
class class1(): // class 1 is the name of the class
Примечание. Python не чувствителен к регистру.
Объекты
Объекты – это экземпляр класса, у которого есть состояние и поведение. В двух словах, это экземпляр класса, который может получить доступ к данным.
Синтаксис: obj = class1()
Здесь, obj – это «объект» class1.
Создание объекта и класса
Пример:
class employee():
def __init__(self,name,age,id,salary): //creating a function
self.name = name // self is an instance of a class
self.age = age
self.salary = salary
self.id = id
emp1 = employee("harshit",22,1000,1234) //creating objects
emp2 = employee("arjun",23,2000,2234)
print(emp1.__dict__)//Prints dictionary
Объяснение: ’emp1′ и ’emp2′ – это объекты, экземпляры которых создаются для класса ’employee’. Здесь слово (__dict__) – это «словарь», который печатает все значения объекта ’emp1′ для данного параметра ( имя, возраст, зарплата). (__ init__) действует как конструктор, который вызывается всякий раз, когда создается объект.
Я надеюсь, что теперь вы, ребята, не столкнетесь с какими-либо проблемами при работе с «классами» и «объектами» в будущем.
Методологии объектно-ориентированного программирования
Методологии объектно-ориентированного программирования имеют дело со следующими концепциями:
- наследование;
- полиморфизм;
- инкапсуляция;
- абстракция.
Давайте подробно разберемся с первой концепцией наследования.
Наследование
Вы когда-нибудь слышали об этом диалоге от родственников: «Вы выглядите в точности как отец или мать», причина этого называется «наследство». С точки зрения программирования это обычно означает «наследование или передачу характеристик от родительского к дочернему классу без каких-либо изменений». Новый класс называется производным или дочерним классом, а тот, от которого он является производным, называется родительским или базовым классом.
Разберемся подробно с каждой из подтем.
Одиночное наследование
Одноуровневое наследование позволяет производному классу наследовать характеристики от одного родительского класса.
Пример:
class employee1()://This is a parent class
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.salary = salary
class childemployee(employee1)://This is a child class
def __init__(self, name, age, salary,id):
self.name = name
self.age = age
self.salary = salary
self.id = id
emp1 = employee1('harshit',22,1000)
print(emp1.age)
Выход: 22.
Объяснение:
- Я взял родительский класс и создал конструктор (__init__), сам класс инициализирует атрибуты параметрами («имя», «возраст» и «зарплата»).
- Создал дочерний класс childemployee, который наследует свойства родительского класса, и, наконец, созданы экземпляры объектов emp1 и emp2 в соответствии с параметрами.
- Я напечатал возраст emp1. Что ж, вы можете распечатать весь словарь, имя или зарплату.
Многоуровневое наследование
Многоуровневое наследование позволяет производному классу наследовать свойства от непосредственного родительского класса, который, в свою очередь, наследует свойства от своего родительского класса.
Пример:
class employee()://Super class
def __init__(self,name,age,salary):
self.name = name
self.age = age
self.salary = salary
class childemployee1(employee)://First child class
def __init__(self,name,age,salary):
self.name = name
self.age = age
self.salary = salary
class childemployee2(childemployee1)://Second child class
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.salary = salary
emp1 = employee('harshit',22,1000)
emp2 = childemployee1('arjun',23,2000)
print(emp1.age)
print(emp2.age)
Выход: 22,23.
Объяснение:
- Это четко объясняется в коде, написанном выше. Здесь я определил суперкласс как сотрудник, а дочерний класс, как childemployee1. Теперь childemployee1 действует, как родитель для childemployee2.
- Я создал два объекта «emp1» и «emp2», где я передаю параметры «имя», «возраст», «зарплата» для emp1 из суперкласса «сотрудник» и «имя», «возраст», «зарплата» и «идентификатор». Из родительского класса «childemployee1 »
Иерархическое наследование
Наследование на иерархическом уровне позволяет более чем одному производному классу наследовать свойства родительского класса.
Пример:
class employee():
def __init__(self, name, age, salary): //Hierarchical Inheritance
self.name = name
self.age = age
self.salary = salary
class childemployee1(employee):
def __init__(self,name,age,salary):
self.name = name
self.age = age
self.salary = salary
class childemployee2(employee):
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.salary = salary
emp1 = employee('harshit',22,1000)
emp2 = employee('arjun',23,2000)
print(emp1.age)
print(emp2.age)
Выход: 22,23.
Объяснение:
- В приведенном выше примере вы можете ясно видеть, что существует два дочерних класса «childemployee1» и «childemployee2». Они наследуют функции от общего родительского класса, который называется «служащий».
- Объекты emp1 и emp2 создаются по параметрам name, age, salary.
Множественное наследование
Многоуровневое наследование позволяет производному классу наследовать свойства более чем одного базового класса.
Пример:
class employee1()://Parent class
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.salary = salary
class employee2()://Parent class
def __init__(self,name,age,salary,id):
self.name = name
self.age = age
self.salary = salary
self.id = id
class childemployee(employee1,employee2):
def __init__(self, name, age, salary,id):
self.name = name
self.age = age
self.salary = salary
self.id = id
emp1 = employee1('harshit',22,1000)
emp2 = employee2('arjun',23,2000,1234)
print(emp1.age)
print(emp2.id)
Выход: 22,1234.
Объяснение: В приведенном выше примере я взял два родительских класса «employee1» и «employee2». И дочерний класс «childemployee», который наследует оба родительских класса, создавая экземпляры объектов emp1 и emp2 по параметрам родительские классы.
Речь шла о наследовании, продвигаясь вперед в объектно-ориентированном программировании Python, давайте углубимся в «полиморфизм».
Полиморфизм
Вы все должны были использовать GPS для навигации по маршруту. Разве не удивительно, сколько разных маршрутов вы встречаете для одного и того же пункта назначения в зависимости от трафика, с точки зрения программирования это называется «полиморфизмом». Это одна из таких методологий ООП, в которой одну задачу можно выполнять несколькими способами. Проще говоря, это свойство объекта, которое позволяет ему принимать несколько форм.
Полиморфизм бывает двух типов:
- Полиморфизм времени компиляции
- Полиморфизм времени выполнения
Полиморфизм времени компиляции
Полиморфизм времени компиляции, также называемый статическим полиморфизмом, разрешается во время компиляции программы. Один из распространенных примеров – «перегрузка метода». Позвольте мне показать вам быстрый пример того же.
Пример:
class employee1():
def name(self):
print("Harshit is his name")
def salary(self):
print("3000 is his salary")
def age(self):
print("22 is his age")
class employee2():
def name(self):
print("Rahul is his name")
def salary(self):
print("4000 is his salary")
def age(self):
print("23 is his age")
def func(obj)://Method Overloading
obj.name()
obj.salary()
obj.age()
obj_emp1 = employee1()
obj_emp2 = employee2()
func(obj_emp1)
func(obj_emp2)
Вывод:
Его зовут Харшит, 3000 – его зарплата, 22 – его возраст; его зовут Рахул, 4000 – его зарплата, 23 – его возраст.
Объяснение:
- В приведенной выше программе я создал два класса «employee1» и «employee2», создал функции для «name», «salary» и «age» и распечатал их значения, не принимая их у пользователя.
- Теперь добро пожаловать в основную часть, где я создал функцию с параметром «obj» и вызвал все три функции, то есть «имя», «возраст» и «зарплата».
- Позже были созданы экземпляры объектов emp_1 и emp_2 для двух классов и просто вызвана функция. Такой тип называется перегрузкой метода, который позволяет классу иметь более одного метода с одним и тем же именем.
Полиморфизм времени выполнения
Полиморфизм времени выполнения также называется динамическим полиморфизмом, где он разрешается во время выполнения. Одним из распространенных примеров полиморфизма времени выполнения является «переопределение метода». Позвольте мне показать вам пример для лучшего понимания.
Пример:
class employee():
def __init__(self,name,age,id,salary):
self.name = name
self.age = age
self.salary = salary
self.id = id
def earn(self):
pass
class childemployee1(employee):
def earn(self)://Run-time polymorphism
print("no money")
class childemployee2(employee):
def earn(self):
print("has money")
c = childemployee1
c.earn(employee)
d = childemployee2
d.earn(employee)
Выход: денег нет, деньги есть.
Объяснение: В приведенном выше примере я создал два класса childemployee1 и childemployee2, которые являются производными от одного и того же базового класса employee. Один не получил денег, а другой получил. Теперь главный вопрос: как это произошло? Итак, если вы присмотритесь, я создал пустую функцию и использовал Pass (оператор, который используется, когда вы не хотите выполнять какую-либо команду или код). Теперь, в двух производных классах, я использовал одну и ту же пустую функцию и использовал оператор печати, как «нет денег» и «есть деньги». Наконец, создал два объекта и вызвал функцию.
Переходя к следующей методологии объектно-ориентированного программирования Python, я расскажу об инкапсуляции.
Инкапсуляция
В необработанном виде инкапсуляция означает связывание данных в одном классе. В Python, в отличие от Java, нет закрытых ключевых слов. Доступ к классу не должен осуществляться напрямую, он должен иметь префикс в виде подчеркивания.
Пример:
class employee(object): def __init__(self): self.name = 1234 self._age = 1234 self.__salary = 1234 object1 = employee() print(object1.name) print(object1._age) print(object1.__salary)
Вывод:
1234 Traceback (последний вызов последний): 1234 Файл «C: /Users/Harshit_Kant/PycharmProjects/test1/venv/encapsu.py», строка 10, в печати (object1 .__ salary) AttributeError: объект ’employee’ не имеет атрибута ‘ __зарплата’
Объяснение: Вы получите этот вопрос, что такое подчеркивание и ошибка? Класс python обрабатывает частные переменные, как (__ salary), к которым нельзя получить доступ напрямую.
Итак, в моем следующем примере я использовал метод установки, который обеспечивает косвенный доступ к ним.
Пример:
class employee():
def __init__(self):
self.__maxearn = 1000000
def earn(self):
print("earning is:{}".format(self.__maxearn))
def setmaxearn(self,earn)://setter method used for accesing private class
self.__maxearn = earn
emp1 = employee()
emp1.earn()
emp1.__maxearn = 10000
emp1.earn()
emp1.setmaxearn(10000)
emp1.earn()
Вывод: Заработок: 1000000, заработок: 1000000, заработок: 10000.
Объяснение: Использование метода установки обеспечивает косвенный доступ к методу частного класса. Здесь я определил класс сотрудника и использовал (__maxearn), который представляет собой метод установки, используемый здесь для хранения максимального заработка сотрудника, и функцию установки setmaxearn(), которая принимает цену в качестве параметра.
Это наглядный пример инкапсуляции, когда мы ограничиваем доступ к методу частного класса, а затем используем метод установки для предоставления доступа.
Далее в методологии объектно-ориентированного программирования Python рассказывается об одной из ключевых концепций, называемой абстракцией.
Абстракция
Невозможно создать экземпляр абстрактного класса, что просто означает, что вы не можете создавать объекты для этого типа класса. Его можно использовать только для наследования функциональных возможностей.
Пример:
from abc import ABC,abstractmethod
class employee(ABC):
def emp_id(self,id,name,age,salary): //Abstraction
pass
class childemployee1(employee):
def emp_id(self,id):
print("emp_id is 12345")
emp1 = childemployee1()
emp1.emp_id(id)
Вывод: emp_id – 12345.
Объяснение: Как вы можете видеть в приведенном выше примере, мы импортировали абстрактный метод, а остальная часть программы имеет родительский и производный классы. Создается экземпляр объекта для базового класса childemployee, и используются функциональные возможности абстрактного.
Python не имеет спецификаторов доступа, таких как «частный», как в java. Он поддерживает большинство терминов, связанных с «объектно-ориентированным» языком программирования, за исключением строгой инкапсуляции. Следовательно, он не полностью объектно-ориентирован.
