Что такое инкапсуляция в питоне

Что такое инкапсуляция в Python?

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

Что такое инкапсуляция в Python?

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

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

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

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

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

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

Методы контроля доступа

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

Использование одиночного подчеркивания

Распространенное соглашение программирования Python для идентификации частной переменной — это префикс с подчеркиванием. Теперь это не имеет никакого значения для компилятора. Переменная по-прежнему доступна в обычном режиме. Но поскольку это соглашение, принятое программистами, оно сообщает другим программистам, что переменные или методы должны использоваться только в рамках класса.

Понятно, что доступ к переменным не изменился. Но можем ли мы сделать что-нибудь, чтобы это действительно было приватным? Посмотрим дальше.

Использование двойного подчеркивания

Если вы хотите сделать члены класса, то есть методы и переменные, частными, вам следует поставить перед ними двойное подчеркивание. Но Python предлагает некоторую поддержку модификатора private. Этот механизм называется изменением имени. При этом по-прежнему можно получить доступ к членам класса извне.

Имя Mangling

В Python любой идентификатор с __Var переписывается интерпретатором python как _Classname__Var, а имя класса остается как текущее имя класса. Этот механизм изменения имен называется изменением имен.

В приведенном ниже примере в Class person переменная age изменена, и ей предшествуют двойные символы подчеркивания в начале.

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

Использование методов Getter и Setter

Если вы хотите получить доступ и изменить частные переменные, следует использовать методы доступа getter и setter, поскольку они являются частью Class.

Преимущества

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

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

Зачем нужна инкапсуляция?

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

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

Источник

Сокрытие в Python

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

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

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

Никаких вам private/protected.

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

Максимум, что вам грозит – недовольство со стороны вашей IDE и коллег на code-review.Давайте добавим два знака подчеркивания перед именем. Будем более убедительными. Может, это немного контр-интуитивно, но этот трюк сработает. Такой атрибут останется видим внутри определения класса, но как-бы «пропадет» из видимости снаружи класса:

Попытались обмануть, даже что-то там присвоили, но не нанесли урона классу! Но я знаю колдунство посильнее:

Python не смог окончательно спрятать атрибут.

Работает это так: если имя атрибута начинается с двух подчеркиваний, то Python автоматически переименует его по шаблону _ИмяКласса__ИмяАтрибута. Но! Внутри класса он будет доступен по старому имени: __ИмяАтрибута.

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

В производном классе мы можем и не знать, что в нашем базовом есть переменная с таким же именем, но при совпадении – мы не нарушим работы базового класса, так как внутри это будут переменные с именами _Base__x и _Derived__x.

Тот же эффект будет и с методами, и с переменными на уровне класса (а не экземпляра).

__setattr__

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

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

Ограничение экспорта из модулей

Еще один механизм сокрытия – сокрытие сущностей (классов, функций и т. п.) на уровне модулей от бездумного импорта.

Напишем модуль. То есть создаем папку с именем testpack, туда кладем файл __init__.py

Пишем код в __init__.py:

Далее в другом файле (из основной директории) мы попытаемся импортировать (все – *) из модуля testpack.

Имя foo было импортировано, так как мы упомянули его в переменной __all__, а bar – нет. Эта все та же защита от дурака, потому что если мы намеренно импортируем bar – ни ошибок, ни предупреждений не последует.

Еще одно замечание: если имя переменной (класса, функции) начинается с подчеркивания, то оно так же не будет импортировано при import *, даже если мы не применяем __all__. И как всегда, вы можете импортировать его вручную.

Источник

Режимы доступа, геттеры и сеттеры

Теперь, когда мы научились создавать экземпляры классов и объявлять в них атрибуты и методы пришла пора рассмотреть важную тему ограничения доступа к данным и методам класса извне. Это основа механизма инкапсуляции. Также здесь посмотрим как происходит обращение к закрытым (приватным) свойствам через специальные методы: геттеры и сеттеры. И, затем, уже на следующих занятиях разовьем этот подход и поговорим о создании объектов-свойств (property) класса и дескрипторах. Фактически, это одна большая и единая тема. Для простоты восприятия я разобью ее на несколько занятий. Здесь мы разберемся с основами работы с закрытыми переменными класса, а следующее занятие будет естественным продолжением этой темы.

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

Смотрите, когда мы создаем экземпляр этого класса:

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

а, значит, можем изменить их вне этого класса:

Как видите, ничего сложного нет. Пока мы будем использовать или публичные свойства (public) или закрытые (private). О режиме protected поговорим, когда будем рассматривать наследование классов.

Итак, создадим в инициализаторе два приватных атрибута:

и теперь обратиться напрямую к этим переменным уже не получится, они стали закрытыми (приватными):

менять и использовать их можно только внутри экземпляра класса.

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

Теперь, мы можем вызвать этот метод и указать нужные координаты для приватных атрибутов:

Чтобы увидеть изменение данных, давайте добавим еще один метод, у которого будет префикс get (получить):

И, далее, вызовем его:

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

Обратите внимание вот на этот слеш. Он используется когда конструкцию в языке Python нужно записать в несколько строчек. Он, говорит интерпретатору языка, что следующая строчка – это продолжение первой. Итак, здесь мы проверяем, что обе переданные переменные x и y должны иметь тип int или float и только после этого приватным атрибутам экземпляра класса будут присвоены эти значения. Иначе, выводится сообщение, что координаты должны быть числами. Давайте проверим как это будет работать:

Как видите, все работает именно так, как мы и хотели.

Продолжим совершенствовать наш класс Point. Вот такие проверки корректности данных, часто реализуют в виде вспомогательных методов, которые доступны только внутри класса, то есть, их делают приватными (закрытыми). Приватный метод объявляется также как и приватная переменная – двумя подчеркиваниями, например, так:

Мы здесь объявили метод без параметра self, т.к. ему не нужен доступ к экземпляру класса и вызываться он будет непосредственно через класс:

Запускаем программу и видим, что все работает также. Но, при этом, доступа к этому методу извне нет, он приватный.

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

_Имя класса__имя переменной
_Имя класса__имя метода

Например, мы можем изменить приватную переменную __x, так:

и теперь она равна 100. Или, вызвать скрытый метод:

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

Например, переопределив метод:

мы не сможем извне узнать значение приватной переменной __x:

выдаст исключение. Обратите внимание, что для всех остальных свойств мы должны вызывать этот метод базового класса, в данном случае – это класс object. Иначе, мы не сможем работать с атрибутами класса. Что такое базовый класс мы еще будем говорить в теме «Наследование». Пока просто запомните этот момент.

Далее, переопределяя метод:

мы запрещаем изменять свойство WIDTH нашего класса. При попытке это сделать:

сработает исключение AttributeError. А иначе, мы в экземпляре класса меняем значение свойства с именем key на значение value. Обратите внимание, что внутри __setattr__ менять свойства следует только через словарь __dict__. Если записать здесь что-то вроде:

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

Наконец, методы __delattr__ и __getattr__ можно перегрузить так:

Еще один дополнительный контроль за локальными свойствами экземпляров классов можно сделать с помощью коллекции:

и при попытке создать какие-либо дополнительные локальные атрибуты:

возникнет ошибка. И, обратите внимание, в slots можно указывать имена только локальных свойств экземпляров, записать туда имена переменных самого класса нельзя. Вот такая запись приведет к ошибке:

На этом мы завершим первую часть темы работы с атрибутами класса. На следующем занятии продолжим и поговорим о создании объектов-свойств (property) и довольно интересном и гибком механизме – дескрипторах.

Видео по теме

#1: парадигма ООП, классы, экземпляры классов, атрибуты

#2: методы класса, параметр self, конструктор и деструктор

#4: объекты свойства (property) и дескрипторы классов

#5: статические свойства и методы классов, декоратор @staticmethod, создание синглетона

#6: простое наследование классов, режим доступа protected

#7: переопределение и перегрузка методов, абстрактные методы

#8: множественное наследование, функция super

#9: перегрузка операторов

#10: собственные исключения и итерабельные объекты

#11: функторы и менеджеры контекста

#12: нейронная сеть (пример реализации)

#14: полиморфизм в ООП на Python

#15: Моносостояние экземпляров класса

#16: Магические методы __str__, __repr__, __len__, __abs__

#17: Коллекция __slots__ для классов

#18: Как работает __slots__ с property и при наследовании классов

#19. Введение в обработку исключений

#20. Распространение исключений (propagation exceptions)

#21. Инструкция raise и пользовательские исключения

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

Источник

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

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

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

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

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

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

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

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

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

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

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

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

Объекты

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

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

Здесь, obj – это «объект» class1.

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

Объяснение: ’emp1′ и ’emp2′ – это объекты, экземпляры которых создаются для класса ’employee’. Здесь слово (__dict__) – это «словарь», который печатает все значения объекта ’emp1′ для данного параметра ( имя, возраст, зарплата). (__ init__) действует как конструктор, который вызывается всякий раз, когда создается объект.

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

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

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

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

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

Разберемся подробно с каждой из подтем.

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

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

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

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

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

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

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

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

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

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

Полиморфизм

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

Полиморфизм времени компиляции

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

Его зовут Харшит, 3000 – его зарплата, 22 – его возраст; его зовут Рахул, 4000 – его зарплата, 23 – его возраст.

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

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

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

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

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

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

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

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

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

Вывод: Заработок: 1000000, заработок: 1000000, заработок: 10000.

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

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

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

Абстракция

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

Вывод: emp_id – 12345.

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

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

Источник