Содержание

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

Сегодня мы поговорим об объектно-ориентированном программировании и о его применении в 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

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

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

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

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

Объект имеет две характеристики:

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

Возьмем пример:

Попугай является объектом, так как имеет следующие свойства:

  • имя, возраст, цвет как атрибуты
  • пение, танцы как поведение

Концепция ООП в Python фокусируется на создании повторно используемого кода. Эта концепция также известна как DRY (не повторяйтесь).

В Python концепция ООП следует некоторым основным принципам:

Класс

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

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

Пример класса попугаев:

класс Попугай:
    pass

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

Объект

Объект (экземпляр) является воплощением класса. Когда класс определен, определяется только описание объекта. Таким образом, память или хранилище не выделяются.

Примером объекта класса попугай может быть:

obj = Parrot()

Здесь obj является объектом класса Parrot .

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

Пример 1: Создание класса и объекта в Python 

 class Parrot:
    # атрибут класса
    вид = "птица"
    # атрибут экземпляра
    def __init__(я, имя, возраст):
        self.name = имя
        возраст = возраст
# создать экземпляр класса Parrot
синий = попугай ("Синий", 10)
Ву = Попугай ("Ву", 15)
# доступ к атрибутам класса
print("Blu — это {}".format(blu.__class__.species))
print("Woo также {}". format(woo.__class__.species))
# доступ к атрибутам экземпляра
print("{} {} лет".format( blu.name, blu.age))
print("{} {} лет".format( woo.name, woo.age))

Выход 

  Голубчик — птица
Ву тоже птица
Блу 10 лет
Ву 15 лет

В приведенной выше программе мы создали класс с именем Parrot . Затем мы определяем атрибуты. Атрибуты являются характеристикой объекта.

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

Затем мы создаем экземпляры Попугай класс. Здесь blu и woo являются ссылками (значением) на наши новые объекты.

Мы можем получить доступ к атрибуту класса, используя __class__.species . Атрибуты класса одинаковы для всех экземпляров класса. Точно так же мы получаем доступ к атрибутам экземпляра, используя blu.name и blu. age . Однако атрибуты экземпляра различны для каждого экземпляра класса.

Дополнительные сведения о классах и объектах см. в разделе Классы и объекты Python 9.0003

Методы

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

Пример 2: Создание методов в Python 

 class Parrot:
    
    # атрибуты экземпляра
    def __init__(я, имя, возраст):
        self.name = имя
        возраст = возраст
    
    # метод экземпляра
    def петь (я, песня):
        return "{} поет {}".format(self.name, песня)
    Танец защиты (я):
        return "{} сейчас танцует".format(self.name)
# создать экземпляр объекта
синий = попугай ("Синий", 10)
# вызываем методы нашего экземпляра
print(blu.sing("'Счастливый'"))
печать (blu.dance())

Выход 

  Голубчик поет "Happy"
Blu теперь танцует

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

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

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

Пример 3. Использование наследования в Python 

 # родительский класс
класс Птица:
    
    защита __init__(сам):
        print("Птичка готова")
    определение whoisThis(я):
        печать("птица")
    деф плавать(я):
        print("Плыви быстрее")
# дочерний класс
класс Пингвин(Птица):
    защита __init__(сам):
        # вызов функции super()
        супер().__инит__()
        print("Пингвин готов")
    определение whoisThis(я):
        печать("Пингвин")
    деф запустить (самостоятельно):
        print("Бежать быстрее")
пегги = пингвин()
пегги. whoisThis()
пегги.плавать()
пегги.run()

Выход 

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

В приведенной выше программе мы создали два класса: Птица (родительский класс) и Пингвин (дочерний класс). Дочерний класс наследует функции родительского класса. Мы можем видеть это из метода swim() .

Опять же, дочерний класс изменил поведение родительского класса. Это видно из метода whoisThis() . Кроме того, мы расширяем функции родительского класса, создавая новый метод run() .

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

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

Используя ООП в Python, мы можем ограничить доступ к методам и переменным. Это предотвращает прямую модификацию данных, которая называется инкапсуляцией. В Python мы обозначаем частные атрибуты, используя подчеркивание в качестве префикса, т.е. одиночные _ или двойной __ .

Пример 4. Инкапсуляция данных в Python 

 class Компьютер:
    защита __init__(сам):
        self.__maxprice = 900
    деф продать (я):
        print("Цена продажи: {}".format(self.__maxprice))
    def setMaxPrice (я, цена):
        self.__maxprice = цена
с = Компьютер()
c.sell()
# изменить цену
c.__maxprice = 1000
c.sell()
# использование функции установки
c.setMaxPrice(1000)
c.sell()

Вывод 

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

В приведенной выше программе мы определили класс Компьютер .

Мы использовали метод __init__() для сохранения максимальной цены продажи Computer . Здесь обратите внимание на код

 c.__maxprice = 1000

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

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

Полиморфизм

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

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

Пример 5. Использование полиморфизма в Python 

 класс Попугай:
    деф летать(я):
        print("Попугай умеет летать")
    
    деф плавать(я):
        print("Попугай не умеет плавать")
класс Пингвин:
    деф летать(я):
        print("Пингвин не умеет летать")
    
    деф плавать(я):
        print("Пингвин умеет плавать")
# Общий интерфейс
def fly_test (птица):
    птица. летать()
#создавать экземпляры объектов
синий = попугай ()
пегги = пингвин()
# передача объекта
fly_test (синий)
fly_test(peggy)

Вывод 

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

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

Чтобы использовать полиморфизм, мы создали общий интерфейс, то есть функцию fly_test() , которая принимает любой объект и вызывает метод fly() объекта. Таким образом, когда мы передали объекты blu и peggy в функцию fly_test() , она работала эффективно.

Ключевые моменты, которые следует помнить:

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

Концепции ООП в Python — GeeksforGeeks

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

Main Concepts of Object-Oriented Programming (OOPs) 

  • Class
  • Objects
  • Polymorphism
  • Encapsulation
  • Inheritance
  • Data Abstraction

OOPs 

Class 

A class is a collection of objects . Класс содержит чертежи или прототипы, из которых создаются объекты. Это логический объект, который содержит некоторые атрибуты и методы.

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

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

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

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

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

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

Python

Класс Собака:

Pass

в создании.

Объекты

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

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

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

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

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

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

Python3

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

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

OBJ = DOG ()

class Dog:

 

    

     attr1 = "mammal"

 

    

     def __init__( self , name):

         self . name = 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))

Выход

  • 3 Роджер Томми тоже млекопитающее Меня зовут Роджер Меня зовут Томми

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

    Python3

    class Dog:

     

        

         attr1 = "mammal"

     

        

         def __init__( self , name):

             self .name = name0003

    DEF ( Self ):

    . Self .name))

    Rodger = ( "Rodger" )

    TOMMY 444444444444444444444444444444444444444444444444444444444444444444444444445 44444444444444444444444444444444445 .0045 "Tommy" )

    Rodger.speak ()

    Tommy.peak ()

    9031 9031 9031. Меня зовут Томми

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

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

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

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

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

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

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

      Example: Inheritance in Python

      Python3

       

      class Person( object ):

       

          

           def __init__( сам , имя, идентификационный номер):

               self .name = name

               self . idnumber = idnumber

       

           def display( self ):

      Печать ( Self . Печать)

      Печать

      .0045 ( self .idnumber)

                

           def details( self ):

               print ( "My name is { } " . Формат ( Self .name))

      Печать ( " IDNUMB0044 format ( self . idnumber))

            

      class Employee(Person):

           def __init__( self , name, idnumber , зарплата, почта):

      Self .Salary = Зарплата

      Self .POST 4 = .0045 post

       

              

               Person.__init__( self , name, idnumber)

                

           def details( self ) :

      Печать ( "Мое имя {}" . Формат ( Self 0045

      Печать ( "Idnumber: {}" . . : {}" . format ( self .post))

       

       

      a = Employee( 'Rahul' , 886012 , 200000 , "Intern" )

       

      a.display()

      a.details()

      Output 

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

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

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

      Полиморфизм

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

      Print ( "Есть много типов птиц. Полет ( Self ):

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

      class sparrow(Bird):

          

           def flight( self ):

               print ( "Sparrows can fly. " )

      Класс Острих (птица):

      DEF ( 4445 ( 4444)0045

               print ( "Ostriches cannot fly." )

       

      obj_bird = Bird()

      obj_spr = sparrow()

      OBJ_OST = OSTRICH ()

      OBJ_BIRD. INTRO ()

      . OBJ_BIRD.FLIGH0045

      obj_spr.flight ()

      obj_ost.intro ()

      obj_ost.flight ()

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

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

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

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

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

      Example: Encapsulation in Python

      Python3

       

      class Base:

           def __init__( self ):

               Self .A = "Geeksforgeeks"

      Self .__ C = "Geeksforgeeks"0045

       

      class Derived(Base):

           def __init__( self ):

       

              

              

               Base. __init__( self )

               print ( "Вызов частного члена базового класса: " 5

      45

               print ( self .__c)

       

       

      obj1 = Base()

      print (obj1.a)

       

      Вывод 

       GeeksforGeeks

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

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

      No related posts.