Ооп в python: концепции, принципы и примеры реализации

Объектно-ориентированное программирование. Классы и объекты

Сегодня мы поговорим об объектно-ориентированном программировании и о его применении в python.

Объектно-ориентированное программирование (ООП) — парадигма программирования, в которой основными концепциями являются понятия объектов и классов.

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

Python соответствует принципам объектно-ориентированного программирования. В python всё является объектами — и строки, и списки, и словари, и всё остальное.

Но возможности ООП в python этим не ограничены. Программист может написать свой тип данных (класс), определить в нём свои методы.

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

Приступим теперь собственно к написанию своих классов на python.

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

>>> # Пример простейшего класса, который ничего не делает
... class A:
...     pass

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

>>> a = A()
>>> b = A()
>>> a.arg = 1  # у экземпляра a появился атрибут arg, равный 1
>>> b.arg = 2  # а у экземпляра b - атрибут arg, равный 2
>>> print(a.arg)
1
>>> print(b.arg)
2
>>> c = A()
>>> print(c.arg)  # а у этого экземпляра нет arg
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'arg'

Классу возможно задать собственные методы:

>>> class A:
...     def g(self): # self - обязательный аргумент, содержащий в себе экземпляр
...                  # класса, передающийся при вызове метода,
...                  # поэтому этот аргумент должен присутствовать
...                  # во всех методах класса. 
...         return 'hello world'
...
>>> a = A()
>>> a.g()
'hello world'

И напоследок еще один пример:

>>> class B:
...     arg = 'Python' # Все экземпляры этого класса будут иметь атрибут arg,
...                    # равный "Python"
...                    # Но впоследствии мы его можем изменить
...     def g(self):
...         return self.arg
...
>>> b = B()
>>> b.g()
'Python'
>>> B.g(b)
'Python'
>>> b.arg = 'spam'
>>> b.g()
'spam'

Для вставки кода на Python в комментарий заключайте его в теги <pre><code>Ваш код</code></pre>

Свежее

• Модуль csv — чтение и запись CSV файлов
• Создаём сайт на Django, используя хорошие практики. Часть 1: создаём проект
• Онлайн-обучение Python: сравнение популярных программ

Категории

• Книги о Python
• GUI (графический интерфейс пользователя)
• Курсы Python
• Модули
• Новости мира Python
• NumPy
• Обработка данных
• Основы программирования
• Примеры программ
• Типы данных в Python
• Видео
• Python для Web
• Работа для Python-программистов

Полезные материалы

• Сделай свой вклад в развитие сайта!
• Самоучитель Python
• Карта сайта
• Отзывы на книги по Python
• Реклама на сайте

Мы в соцсетях

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

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

ООП

Python — мультипарадигмальный язык программирования. Он поддерживает разные подходы к программированию.

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

У объекта есть две характеристики: 

• атрибуты;
• поведение.

Рассмотрим пример. Допустим, наш объект — это попугай. У попугая есть такие свойства:

• Имя, возраст, цвет. Это атрибуты.
• То, как попугай поет и танцует. Это поведение. 

ООП предлагает писать код, который можно использовать повторно. Такой принцип называется DRY (don’t repeat yourself, «не повторяйся»).

Класс

Класс — это шаблон объекта.

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

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

class Parrot:
    pass

Для объявления класса Parrot мы использовали ключевое слово class. Из классов мы получаем экземпляры, созданные по подобию этого класса.

Объект

Объект — это экземпляр класса. Объявленный класс — это лишь описание объекта: ему не выделяется память. 

Например, экземпляра класса Parrot будет выглядеть так:

# obj — экземпляр класса Parrot
obj = Parrot()

Теперь разберемся, как написать класс и его объекты.

# Создаем класс и его объекты
class Parrot:

    # атрибуты класса
    species = "птица"

    # атрибуты экземпляра
    def __init__(self, name, age):
        self.name = name
        self.age = age

# создаем экземпляра класса
kesha = Parrot("Кеша", 10)
cookie = Parrot("Куки", 15)

# получаем доступ к атрибутам класса
print("Кеша — {}".format(kesha.__class__.species))
print("Куки тоже {}".format(cookie.__class__.species))

# получаем доступ к атрибутам экземпляра
print("{} — {}-летний попугай".
  format(kesha.name, kesha.age))
print("{} — {} летний попугай".format(cookie.name, cookie.age))

Вывод:

Кеша — птица
Куки тоже птица
Кеша — 10-летний попугай
Куки — 15-летний попугай

Мы создали класс Parrot. После этого мы объявили атрибуты — характеристики объекта.

Атрибуты объявлены внутри класса — в методе __init__. Это метод-инициализатор, который запускается сразу же после создания объекта. 

После этого мы создаем экземпляры класса Parrot. kesha и cookie — ссылки на (значения) наши новые объекты. 

Получить доступ к атрибуту класса можно так — __class__.species. Атрибуты класса для всех экземпляров класса одинаковы. Точно так же мы можем получить доступ к атрибутам экземпляра —

kesha.name и kesha.age. Но вот атрибуты каждого экземпляра класса уникальны. 

Подробнее о классах и объектах.

Методы

Методы — функции, объявленные внутри тела класса. Они определяют поведения объекта.

# Создаем метод
class Parrot:
    
    # атрибуты экземпляра
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # метод экземпляра
    def sing(self, song):
        return "{} поет {}".format(self.name, song)

    def dance(self):
        return "{} танцует".format(self.name)

# создаем экземпляр класса
kesha = Parrot("Кеша", 10)

# вызываем методы экземпляра
print(kesha.sing("песенки"))
print(kesha.dance())

Вывод:

Кеша поет песенки
Кеша танцует

В этой программе мы объявили два метода: sing() и dance(). Они являются методами экземпляра, потому что они вызываются объектами — например, kesha. 

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

Наследование — способ создания класса. Его суть заключается в том, что функциональность нового класса наследуются от уже существующего класса.

Новый класс называется производным (дочерним). Существующий — базовым (родительским).

# родительский класс
class Bird:
    
    def __init__(self):
        print("Птица готова")

    def whoisThis(self):
        print("Птица")

    def swim(self):
        print("Плывет быстрее")

# дочерний класс
class Penguin(Bird):

    def __init__(self):
        # вызов функции super() 
        super().__init__()
        print("Пингвин готов")

    def whoisThis(self):
        print("Пингвин")

    def run(self):
        print("Бежит быстрее")

peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

Вывод:

Птица готова
Пингвин готов
Пингвин
Плывет быстрее
Бежит быстрее

В этой программе мы создаем два класса — Bird (родительский) и Penguin (дочерний). Дочерний класс наследует функции родительского. Это вы можете заметить по методу swim().

Но и дочерний класс изменяет функциональность родительского. Это можно заметить по методу whoisThis()

. Более того, мы расширяем функциональность родительского класса — создаем метод run().

Также мы используем функцию super() внутри метода __init__(). Это позволяет запускать метод __init__() родительского класса внутри дочернего.

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

Мы можем ограничить доступ к методам и переменным, что предотвратит модификацию данных — это и есть инкапсуляция. Приватные атрибуты выделяются нижним подчеркиванием: одинарным _ или двойным __. 

# Используем инкапсуляцию данных
class Computer:

    def __init__(self):
        self.__maxprice = 900

    def sell(self):
        print("Цена продажи: {}".format(self.__maxprice))

    def setMaxPrice(self, price):
        self. __maxprice = price

c = Computer()
c.sell()

# изменение цены
c.__maxprice = 1000
c.sell()

# используем функцию изменения цены
c.setMaxPrice(1000)
c.sell()

 Вывод:

Цена продажи: 900
Цена продажи: 900
Цена продажи: 1000

Мы объявили класс Computer. 

Затем мы использовали метод __init__() для хранения максимальной цены компьютера. Затем мы попытались изменить цену — безуспешно: Python воспринимает __maxprice как приватный атрибут. 

Как видите, для изменения цены нам нужно использовать специальную функцию — setMaxPrice(), которая принимает цену в качестве параметра.

Полиморфизм

Полиморфизм — особенность ООП, позволяющая использовать одну функцию для разных форм (типов данных).

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

# Используем полиморфизм
class Parrot:

    def fly(self):
        print("Попугай умеет летать")
    
    def swim(self):
        print("Попугай не умеет плавать")

class Penguin:

    def fly(self):
        print("Пингвин не умеет летать")
    
    def swim(self):
        print("Пингвин умеет плавать")

# общий интерфейс 
def flying_test(bird):
    bird.fly()

# создаем экземпляров класса
kesha = Parrot()
peggy = Penguin()

# передача объектов в качестве аргумента
flying_test(kesha)
flying_test(peggy)

Вывод:

Попугай умеет летать
Пингвин не умеет летать

В этой программе мы объявили два класса: Parrot и Penguin. В каждом из них описан общий метод fly(). Но функции у них разные.  

Для использование полиморфизма мы создали общий интерфейс — функцию flying_test(). В качестве аргумента она принимает любой объект, после чего происходит вызов его собственного метода fly(). 

Что нужно запомнить:

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

Python OOP Concepts — GeeksforGeeks

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

Основные концепции объектно-ориентированного программирования (ООП) 

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

OOPS

Класс

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

Чтобы понять необходимость создания класса, давайте рассмотрим пример. Допустим, вы хотите отслеживать количество собак, которые могут иметь разные атрибуты, такие как порода, возраст. Если используется список, первым элементом может быть порода собаки, а вторым элементом может быть ее возраст. Предположим, есть 100 разных собак, тогда как узнать, какой элемент должен быть каким? Что, если бы вы захотели добавить этим собакам другие свойства? Этому не хватает организации, и это именно то, что нужно для занятий.

Некоторые моменты в классе Python:  

• Классы создаются по ключевому слову class.
• Атрибуты — это переменные, принадлежащие классу.
• Атрибуты всегда общедоступны, и к ним можно получить доступ с помощью оператора точка (.). Например: Myclass.Myattribute

Синтаксис определения класса:

 class ClassName:
   # Заявление-1
   .
   .
   .
   # Заявление-N 

Пример: Создание пустого класса в Python

Python

Класс DOG: Pass

В примере вышеуказанный пример, мы создаем A Class Sword.

Объекты

Объект — это сущность, с которой связано состояние и поведение. Это может быть любой объект реального мира, такой как мышь, клавиатура, стул, стол, ручка и т. д. Целые числа, строки, числа с плавающей запятой, даже массивы и словари — все это объекты. Более конкретно, любое целое число или любая отдельная строка является объектом. Число 12 — это объект, строка «Hello, world» — это объект, список — это объект, который может содержать другие объекты, и так далее. Вы все время использовали объекты и, возможно, даже не осознавали этого.

Объект состоит из:

• Состояние: Он представлен атрибутами объекта. Он также отражает свойства объекта.
• Поведение: Представлено методами объекта. Он также отражает реакцию объекта на другие объекты.
• Идентификация: Дает уникальное имя объекту и позволяет одному объекту взаимодействовать с другими объектами.

Чтобы понять состояние, поведение и идентичность, давайте возьмем пример класса собак (объяснено выше).

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

Пример: Создание объекта

Python3

OBJ = DOG ()

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

The self   

1. Методы класса должны иметь дополнительный первый параметр в определении метода. Мы не даем значение этому параметру при вызове метода, его предоставляет Python
2. Если у нас есть метод, который не принимает аргументов, то нам все равно нужно иметь один аргумент.
3. Это похоже на этот указатель в C++ и эту ссылку в Java.

Когда мы вызываем метод этого объекта как myobject. method(arg1, arg2), он автоматически преобразуется Python в MyClass.method(myobject, arg1, arg2) — это все, что касается специального self.

Примечание: Дополнительные сведения см. в разделе self в классе Python. Он запускается, как только создается экземпляр объекта класса. Этот метод полезен для любой инициализации, которую вы хотите выполнить с вашим объектом.

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

Пример 1: Создание класса и объекта с атрибутами класса и экземпляра

Python3

class Dog:             attr1 = "mammal"             def __init__( self , name):          self . name = 0 name0003   Rodger = Dog( "Rodger" ) Tommy = Dog( "Tommy" )   print ( "Rodger is a {}" . format (Rodger.__class__.attr1)) print ( "Tommy is also a {}" . format (Tommy.__class__.attr1))   print ( "My name is {}" . format (Rodger.name)) print ( "Меня зовут {}" . формат (Tommy.name))

Выход 63 млекопитающее Роджер Томми тоже млекопитающее Меня зовут Роджер Меня зовут Томми

Пример 2: Создание класса и объектов с помощью методов

Python3

class Dog:             attr1 = "mammal"             def __init__( self , name):          self . name = 0 name0003                 def speak( self ):          print ( "My name is {}" . format ( self .name))   Rodger = Dog( "Rodger" ) Tommy = Dog( "Tommy" )   Rodger.speak() Tommy.speak()

Output

 My name is Rodger
Меня зовут Томми 

Примечание. Для получения дополнительной информации см. раздел Классы и объекты Python

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

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

• Хорошо отображает отношения в реальном мире.
• Обеспечивает возможность повторного использования кода. Нам не нужно писать один и тот же код снова и снова. Кроме того, это позволяет нам добавлять дополнительные функции в класс, не изменяя его.
• Он транзитивен по своей природе, что означает, что если класс B наследуется от другого класса A, то все подклассы B автоматически наследуются от класса A.0022 :
  Одноуровневое наследование позволяет производному классу наследовать характеристики однородного класса.

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

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

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

  Example: Inheritance in Python

  Python3

  class Person( object ):             def __init__( сам , имя, идентификационный номер):          self .name = name          self . idnumber = idnumber        def display( self ): Печать ( Self . Печать 0060 ( self .idnumber)                 def details( self ):          print ( "My name is { } " . Формат ( Self .name)) Печать ( " IDNUMB0059 format ( self . idnumber))        class Employee(Person):      def __init__( self , name, idnumber , зарплата, почта): Self .SALARY = САРЬ Self .POST = .0060 post                     Person.__init__( self , name, idnumber)                 def details( self ) :          печать ( "Меня зовут {}" . формат 9 ( 0 селф..name)) Печать ( "Idnumber: {}" . формат ( Self .idnumb "Post: {}" . format ( self .post))     a = Employee( 'Rahul' , 886012 , 200000 , "Intern" )   a.display() a.details()

  Выход

   Рахул
  886012
  Меня зовут Рахул
  Идентификационный номер: 886012
  Сообщение: Intern 

  В приведенной выше статье мы создали два класса: Person (родительский класс) и Employee (дочерний класс). Класс Employee наследуется от класса Person. Мы можем использовать методы класса person через класс сотрудников, как показано в функции отображения в приведенном выше коде. Дочерний класс также может изменить поведение родительского класса, как видно из метода details().

  Примечание: Для получения дополнительной информации обратитесь к нашему руководству по наследованию в Python.

  Полиморфизм

  Полиморфизм просто означает наличие множества форм. Например, нам нужно определить, летают ли данные виды птиц или нет, используя полиморфизм, мы можем сделать это с помощью одной функции. Пример: полиморфизм в Python0058 DEF Intro ( Self ):

  Печать ( ». Полет ( Self ):

  Печать ( "Большинство птиц могут летать, но некоторые не могут. 0003

  class sparrow(Bird):

      

       def flight( self ):

           print ( "Sparrows can fly. " )

  Класс Страус (птица):

  DEF ( Self

  9): ( Self
  ): )0060

           print ( "Ostriches cannot fly." )

   

  obj_bird = Bird()

  obj_spr = sparrow()

  obj_ost = ostrich()

   

  obj_bird. intro()

  obj_bird.flight()

   

  obj_spr.intro()

  obj_spr.flight()

   

  obj_ost.intro()

  obj_ost.flight()

  Output

   There are many types птиц.
  Большинство птиц могут летать, но некоторые не могут.
  Есть много видов птиц.
  Воробьи умеют летать.
  Есть много видов птиц.
  Страусы не умеют летать. 

  Примечание: Для получения дополнительной информации обратитесь к нашему учебнику по полиморфизму в Python.

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

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

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

  Example: Encapsulation in Python

  Python3

  class Base:      def __init__( self ):          Self .A = "Geeksforgeeks" Self . __ C = "Geeksforgeeks"0060   class Derived(Base):      def __init__( self ):                              Base. __init__( self )          print ( "Вызов частного члена базового класса: " 0 )          print ( self .__c)     obj1 = Base() print (obj1. a)

  Вывод

   GeeksforGeeks 

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

  Примечание: для получения дополнительной информации см. в нашем руководстве по инкапсуляции в Python.

  Абстракция данных 

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

  Абстракция данных в Python может быть достигнута путем создания абстрактных классов.

  Объектно-ориентированное программирование на Python | Набор 2 (скрытие данных и печать объектов)

  https://youtu.be/CiH7lN4

  Пожалуйста, пишите комментарии, если вы обнаружите что-то неверное, или вы хотите поделиться дополнительной информацией по теме, обсуждаемой выше

  
  

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

  Стать сертифицированным специалистом

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

  В этой статье будут подробно рассмотрены следующие аспекты:

  • Введение в объектно-ориентированное программирование на Python
  • Разница между объектно-ориентированным и процедурно-ориентированным программированием
  • Что такое классы и объекты?
  • Методологии объектно-ориентированного программирования:
    • • Наследование
      • Полиморфизм
    • • Инкапсуляция 9 00007

      • 8 000080008

    Начнем.

    Что такое объектно-ориентированное программирование? (Концепции ООП в Python)

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

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

    Difference between Object-Oriented and Procedural Oriented Programming

    Object-Oriented  Programming (OOP)	Procedural-Oriented  Programming (Pop)
    Восходящий подход	Это нисходящий подход
    Программа разделена на объекты	Программа делится на функции
    . Использование Modifiers	Make Of Access Modifiers 3 . , protected'	Не использует Модификаторы доступа
    Более безопасный	Менее безопасный3 0055 Object can move freely within member functions	Data can move freely from function to function within programs
    It supports inheritance	It does not support inheritance

    That was all о различиях, продвигаясь вперед, давайте получим представление об ООП Python Conceots.

    Что такое концепции ООП Python?

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

    Это все о различиях, давайте продолжим, давайте разберемся с классами и объектами.

    Что такое классы и объекты?

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

    Логически данные группируются таким образом, что повторное использование кода упрощается. Я могу привести пример из реальной жизни: подумайте об офисе, который называется «служащий», как о классе, а все связанные с ним атрибуты, такие как «emp_name», «emp_age», «emp_salary», «emp_id», — как объекты в Python. Давайте посмотрим с точки зрения кодирования, как вы создаете экземпляр класса и объекта.

    Класс определяется ключевым словом «Класс».
    Пример:

    class class1(): // класс 1 — это имя класса
     

    Примечание. Python не чувствителен к регистру.

     Объекты:

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

    Синтаксис: obj = class1()

    Здесь obj — «объект» класса1.

    Создание объекта и класса в python:

    Пример:

     class employee():
        def __init__(self,name,age,id,salary): //создание функции
            self.name = name // self является экземпляром класса
            возраст = возраст
            собственная зарплата = зарплата
            self.id = идентификатор
    emp1 = employee("harshit",22,1000,1234) //создание объектов
    emp2 = сотрудник ("арджун", 23,2000,2234)
    print(emp1.__dict__)//Выводит словарь
     

    Объяснение: 'emp1' и 'emp2' — это объекты, созданные для класса «сотрудник». Здесь слово (__dict__) — это «словарь», который печатает все значения объекта 'emp1' по заданному параметру (имя, возраст, зарплата).(__init__) действует как конструктор, который вызывается всякий раз, когда создается объект.

    Надеюсь, теперь у вас, ребята, не возникнет проблем при работе с «классами» и «объектами» в будущем.

    На этом я познакомлю вас с методологиями объектно-ориентированного программирования:

    Методологии объектно-ориентированного программирования:

    Методологии объектно-ориентированного программирования имеют дело со следующими понятиями.

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

    Давайте подробно разберемся с первой концепцией наследования.

    Наследство:

    Слышали когда-нибудь такой диалог от родственников "вы очень похожи на своего отца/мать" причина этого называется "наследство". С точки зрения программирования это обычно означает «наследование или передачу характеристик от родительского к дочернему классу без каких-либо изменений». Новый класс называется производный/дочерний класс , а тот, из которого он является производным, называется родительским/базовым классом .

    Давайте подробно разберем каждую из подтем.

    Одиночное наследование:

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

    Пример:

     class employee1()://Это родительский класс
    def __init__(я, имя, возраст, зарплата):
    self.name = имя
    возраст = возраст
    собственная зарплата = зарплата
    class childemployee(employee1)://Это дочерний класс
    def __init__(я, имя, возраст, зарплата, идентификатор):
    self.name = имя
    возраст = возраст
    собственная зарплата = зарплата
    self.id = идентификатор
    emp1 = сотрудник1('грубость',22,1000)
    печать (emp1.age)
     

    Вывод : 22

    Объяснение:

    • Я беру родительский класс и создаю конструктор (__init__), сам класс инициализирует атрибуты параметрами («имя», «возраст» и «зарплата»). ').

    • Создан дочерний класс «childemployee», который наследует свойства от родительского класса и, наконец, создает экземпляры объектов «emp1» и «emp2» для параметров.

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

     

    Многоуровневое наследование:

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

    Пример:

     class employee()://Super class
    def __init__(я,имя,возраст,зарплата):
    self.name = имя
    возраст = возраст
    собственная зарплата = зарплата
    class childemployee1(employee)://первый дочерний класс
    def __init__(я,имя,возраст,зарплата):
    self.name = имя
    возраст = возраст
    собственная зарплата = зарплата
    class childemployee2(childemployee1)://Второй дочерний класс
    def __init__(я, имя, возраст, зарплата):
    self.name = имя
    возраст = возраст
    собственная зарплата = зарплата
    emp1 = сотрудник('грубость',22,1000)
    emp2 = childemployee1('arjun',23,2000)
    печать (emp1. age)
    печать(emp2.age)
     

    Вывод: 22,23

    Объяснение:

    • Это ясно объяснено в коде, написанном выше. Здесь я определил суперкласс как сотрудника и дочерний класс как childemployee1. Теперь childemployee1 действует как родитель для childemployee2.

    • Я создал два объекта "emp1" и "emp2", где я передаю параметры "имя", "возраст", "зарплата" для emp1 из суперкласса "сотрудник" и "имя", "возраст, "зарплата" " и "id" из родительского класса "childemployee1"

     

    Иерархическое наследование:

    Наследование на уровне иерархии позволяет нескольким производным классам наследовать свойства родительского класса.

    Пример:

     class employee():
    def __init__(я, имя, возраст, зарплата): // Иерархическое наследование
    self.name = имя
    возраст = возраст
    собственная зарплата = зарплата
    класс childemployee1 (сотрудник):
    def __init__(я,имя,возраст,зарплата):
    self. name = имя
    возраст = возраст
    собственная зарплата = зарплата
    класс childemployee2 (сотрудник):
    def __init__(я, имя, возраст, зарплата):
    self.name = имя
    возраст = возраст
    собственная зарплата = зарплата
    emp1 = сотрудник('грубость',22,1000)
    emp2 = сотрудник('арджун',23,2000)
    печать (emp1.age)
    печать(emp2.age)
     

    Вывод: 22,23

    Объяснение:

    • В приведенном выше примере вы можете ясно видеть, что есть два дочерних класса «childdemployee1» и «childdemployee2». Они наследуют функциональные возможности от общего родительского класса, которым является «служащий».

    • Объекты «emp1» и «emp2» создаются для параметров «имя», «возраст», «зарплата».

    Множественное наследование:

    Многоуровневое наследование позволяет одному производному классу наследовать свойства более чем одного базового класса.

    Пример:

     класс employee1()://Родительский класс
        def __init__(я, имя, возраст, зарплата):
            self. name = имя
            возраст = возраст
            собственная зарплата = зарплата
    класс employee2()://Родительский класс
        def __init__(я,имя,возраст,зарплата,id):
         self.name = имя
         возраст = возраст
         собственная зарплата = зарплата
         self.id = идентификатор
    класс дочерний сотрудник (сотрудник1, сотрудник2):
        def __init__(я, имя, возраст, зарплата, идентификатор):
         self.name = имя
         возраст = возраст
         собственная зарплата = зарплата
         self.id = идентификатор
    emp1 = сотрудник1('грубость',22,1000)
    emp2 = сотрудник2('арджун',23,2000,1234)
    печать (emp1.age)
    печать (emp2.id)
     

    Вывод: 22,1234

    Объяснение: В приведенном выше примере я взял два родительских класса «employee1» и «employee2». И дочерний класс «childemployee», который наследует оба родительских класса путем создания экземпляров объектов. 'emp1' и 'emp2' относительно параметров родительских классов.

    Это было все о наследовании, продвигаясь вперед в объектно-ориентированном программировании Python, давайте глубоко погрузимся в «полиморфизм».

    Полиморфизм:

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

    Полиморфизм состоит из двух типов:

    • Полиморфизм с компиляцией
    • Полиморфизм времени . полиморфизм, который разрешается во время компиляции программы. Одним из распространенных примеров является «перегрузка метода». Позвольте мне показать вам быстрый пример того же самого.

      Пример:

       класс employee1():
      имя защиты (я):
      print("Его зовут Жестокий")
      заработная плата (я):
      print("3000 - его зарплата")
      возраст защиты (я):
      print("22 - его возраст")
      класс работник2():
      имя защиты (я):
      print("Его зовут Рахул")
      заработная плата (я):
      print("4000 - его зарплата")
      возраст защиты (я):
      print("23 - его возраст")
      def func(obj)://Перегрузка метода
      имя. объекта()
      obj.salary()
      obj.возраст()
      obj_emp1 = сотрудник1()
      obj_emp2 = сотрудник2()
      функция (obj_emp1)
      функция (obj_emp2)
       

      Выход:

      Харшит - его имя
      3000 - его зарплата
      22 - его возраст
      Рахул - его имя
      4000 - его зарплата
      23 - его возраст

      Объяснение:

    • 9000

    • в. Я создал два класса «employee1» и «employee2», создал функции для «имени», «зарплаты» и «возраста» и распечатал их значение, не беря его у пользователя.

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

    • Позже были созданы объекты emp_1 и emp_2 для двух классов и просто вызвана функция. Такой тип называется перегрузкой метода, который позволяет классу иметь более одного метода с одним и тем же именем.

    Полиморфизм времени выполнения:

    Полиморфизм времени выполнения также называется динамическим полиморфизмом, когда он разрешается во время выполнения. Одним из распространенных примеров полиморфизма во время выполнения является «переопределение метода». Позвольте мне показать вам на примере для лучшего понимания.

    Пример:

     class employee():
       def __init__(я, имя, возраст, идентификатор, зарплата):
           self.name = имя
           возраст = возраст
           собственная зарплата = зарплата
           self.id = идентификатор
    заработок(сам):
            проходить
    класс childemployee1 (сотрудник):
       defear(self)://Полиморфизм во время выполнения
          печатать("денег нет")
    класс childemployee2 (сотрудник):
       заработок(сам):
           print("есть деньги")
    c = ребенок-сотрудник1
    c.earn (сотрудник)
    d = ребенок-сотрудник2
    d.earn (сотрудник)
     

    Выход: нет денег, есть деньги

    Объяснение: В приведенном выше примере я создал два класса «childdemployee1» и «childemployee2», которые являются производными от одного и того же базового класса «employee». получает другой. Теперь реальный вопрос, как это произошло? Что ж, если вы посмотрите внимательно, я создал пустую функцию и использовал Pass (инструкция, которая используется, когда вы не хотите выполнять какую-либо команду или код). Теперь в двух производных классах я использовал одну и ту же пустую функцию и использовал оператор печати как «нет денег» и «есть деньги». Наконец, создал два объекта и вызвал функцию.

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

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

    В необработанном виде инкапсуляция в основном означает привязку данных к одному классу. Python не имеет ключевого слова private, в отличие от Java. К классу нельзя обращаться напрямую, но он должен иметь префикс в виде подчеркивания.

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

    Пример:

     класс сотрудника(объект):
    защита __init__(сам):
    самоназвание = 1234
    self. _age = 1234
    сам.__зарплата = 1234
    объект1 = сотрудник()
    печать (объект1.имя)
    печать (object1._age)
    печать (объект1.__зарплата)
     

    Вывод:

    1234
    Трассировка (последний последний вызов):
    1234
    Файл «C:/Users/Harshit_Kant/PycharmProjects/test1/venv/encapsu.py», строка 10, в
    print(object1.75 __salary)
    AttributeError: объект «сотрудник» не имеет атрибута «__salary»

    Объяснение: Вы получите этот вопрос, что такое подчеркивание и ошибка? Что ж, класс python обрабатывает частные переменные как (__salary), к которым нельзя получить прямой доступ.

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

    Пример:

     class employee():
    защита __init__(сам):
    self.__maxearn = 1000000
    заработок(сам):
    print("доход:{}".format(self.__maxearn))
    Метод def setmaxearn(self,earn)://setter, используемый для доступа к частному классу
    self. __maxearn = зарабатывать
    emp1 = сотрудник()
    emp1.earn()
    emp1.__maxearn = 10000
    emp1.earn()
    emp1.setmaxearn(10000)
    emp1.earn()
     

    Выход:

    заработок:1000000,заработок:1000000,заработок:10000

    Объяснение:  Использование метода установки обеспечивает косвенный доступ к методу закрытого класса . Здесь я определил сотрудника класса и использовал (__maxearn), который является методом установки, используемым здесь для хранения максимального заработка сотрудника, и функцию установки setmaxearn(), которая принимает цену в качестве параметра.

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

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

    Абстракция:

     

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

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

    Пример:

     из abc import ABC, abstractmethod
    сотрудник класса (ABC):
    def emp_id(self,id,name,age,salary): //Абстракция
    проходить
    класс childemployee1 (сотрудник):
    def emp_id (я, идентификатор):
    print("emp_id равен 12345")
    emp1 = дочерний сотрудник1()
    emp1.emp_id(идентификатор)
     

    Выход : emp_id равен 12345

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

    No related posts.