Inner Class in Python
Python is an Object-Oriented Programming Language, everything in python is related to objects, methods, and properties. A class is a user-defined blueprint or a prototype, which we can use to create the objects of a class. The class is defined by using the class keyword.
Example of class
Python3
First of all, we have to understand the __init__() built-in method for understanding the meaning of classes. Whenever the class is being initiated, a method namely __init__() is always executed. An __init__() method is used to assign the values to object properties or to perform the other method that is required to complete when the object is created.
Example: class with __init__() method
Python3
Course : Campus Preparation Duration : As per your schedule
Inner Class in Python
A class defined in another class is known as an inner class or nested class. If an object is created using child class means inner class then the object can also be used by parent class or root class. A parent class can have one or more inner classes but generally inner classes are avoided.
We can make our code even more object-oriented by using an inner class. A single object of the class can hold multiple sub-objects. We can use multiple sub-objects to give a good structure to our program.
- First, we create a class and then the constructor of the class.
- After creating a class, we will create another class within that class, the class inside another class will be called an inner class.
Python3
Name: Green Name: Light Green Code: 024avc
Why inner class?
For the grouping of two or more classes. Suppose we have two classes remote and battery. Every remote needs a battery but a battery without a remote won’t be used. So, we make the Battery an inner class to the Remote. It helps us to save code. With the help of the inner class or nested class, we can hide the inner class from the outside world. Hence, Hiding the code is another good feature of the inner class. By using the inner class, we can easily understand the classes because the classes are closely related. We do not need to search for classes in the whole code, they all are almost together. Though inner or nested classes are not used widely in Python it will be a better feature to implement code because it is straightforward to organize when we use inner class or nested class.
# create NameOfOuterClass class class NameOfOuterClass: # Constructor method of outer class def __init__(self): self.NameOfVariable = Value # create Inner class object self.NameOfInnerClassObject = self.NameOfInnerClass() # create a NameOfInnerClass class class NameOfInnerClass: # Constructor method of inner class def __init__(self): self.NameOfVariable = Value # create object of outer class outer = NameOfOuterClass()
Types of inner classes are as follows:
Multiple inner class
The class contains one or more inner classes known as multiple inner classes. We can have multiple inner class in a class, it is easy to implement multiple inner classes.
Example: Multiple inner class
Вложенные классы
На этом занятии речь пойдет о вложенных классах. В двух словах, это когда один класс объявлен внутри другого. Да, в Python так тоже можно делать. И здесь сразу возникает два главных вопроса: как это работает и зачем это надо? Я попробую дать ответ сразу на оба этих вопроса.
На мой взгляд, хороший пример использования вложенных классов – это описание моделей во фреймворке Django. Если вы не знаете, что это такое, то не беспокойтесь, нам нужна будет только суть вложений. Итак, там часто можно встретить определения вида:
class Women: title = 'объект класса для поля title' photo = 'объект класса для поля photo' class Meta: ordering = ['id']
Здесь объявляется некий класс Women, далее прописаны два атрибута, которые в Django являются ссылками на определенные классы, но в нашем примере – это просто строки. Причем, атрибуты title и photo – это поля в таблице БД, с которой впоследствии идет работа, то есть, полагаем, что нам важно называть эти атрибуты именно такими именами. Затем, идет объявление вложенного класса Meta с одним атрибутом ordering. В Django с помощью такого класса Meta определяют некие вспомогательные параметры. В частности, параметр ordering определяет сортировку по полю id записей в таблице БД. Если вы ничего не поняли про записи и таблицы, то это не важно. Главное сейчас, что у нас есть класс Women, в нем атрибуты со строго определенными именами и вложенный класс Meta с одним атрибутом ordering. Это все, что нужно сейчас знать.
Но все же, зачем нужен такой вложенный класс? Почему бы этот атрибут не прописать непосредственно в классе Women? Давайте предположим, что в нашей таблице есть поле с именем ordering и для работы с ним в классе Women его следует прописать, сделаем это так:
class Women: title = 'объект класса для поля title' photo = 'объект класса для поля photo' ordering = 'объект класса для поля ordering' class Meta: ordering = ['id']
Видите, если бы не было вложенного класса Meta, то возникла бы проблема с использованием одного и того же атрибута ordering для разных целей: и для представления данных поля ordering и для управления сортировкой. Вложенный класс Meta, фактически, создает независимое пространство имен для разрешения подобных конфликтов.
Разумеется, мы можем совершенно спокойно обращаться ко всем атрибутам класса через основной класс Women, например, так:
print(Women.ordering) print(Women.Meta.ordering)
В первом случае берем атрибут ordering непосредственно из класса Women, а во втором – из класса Meta.
То же самое можно делать и через экземпляры класса Women:
w = Women() print(w.ordering) print(w.Meta.ordering)
Причем внутри самого объекта у нас сейчас не будет никаких локальных свойств:
Давайте для примера добавим инициализатор в класс Women, запишем его следующим образом:
class Women: title = 'объект класса для поля title' photo = 'объект класса для поля photo' ordering = 'объект класса для поля ordering' def __init__(self, user, psw): self._user = user self._psw = psw class Meta: ordering = ['id']
Теперь, при создании объектов:
w = Women('root', '12345') print(w.__dict__)
в них дополнительно будут создаваться локальные свойства user и psw:
Но обратите внимание, объект класса Meta при этом не создается. Здесь Meta – это, по сути, еще один атрибут (пространство имен) в классе Women и мы к нему обращаемся через w как к атрибуту класса, не более того. Если нам нужен объект класса Meta, его нужно явно создать в инициализаторе класса Women:
def __init__(self, user, psw): self._user = user self._psw = psw self.meta = self.Meta()
Теперь в экземпляре класса Women имеется ссылка meta на объект класса Meta. Чтобы в этой операции был смысл, давайте пропишем инициализатор во вложенном классе:
class Women: title = 'объект класса для поля title' photo = 'объект класса для поля photo' ordering = 'объект класса для поля ordering' def __init__(self, user, psw): self._user = user self._psw = psw self.meta = self.Meta(user + '@' + psw) class Meta: ordering = ['id'] def __init__(self, access): self._access = access
Теперь, при создании объекта класса Women будут автоматически создаваться два объекта: класса Women и класса Meta с соответствующими локальными свойствами:
w = Women('root', '12345') print(w.__dict__) print(w.meta.__dict__)
И, обратите внимание, мы не можем из класса Meta или из его объектов обращаться к атрибутам класса Women. Это совершенно изолированное пространство имен от внешнего класса. Например, запись вида:
class Meta: ordering = ['id'] t = Meta.title # ошибка при обращении к атрибуту title класса Women
приведет к ошибке, так как у вложенного пространства имен класса нет ссылки на внешнее пространство имен класса Women. Мало того, непосредственно во вложенном классе мы даже не можем явно указывать класс Women:
class Meta: ordering = ['id'] t = Women.title # ошибка при обращении к атрибуту title класса Women
то тоже приведет к ошибке, так как пространство имен Women на данный момент еще не создано. А вот обращаться к пространству имен Women внутри инициализатора класса Meta можно:
class Meta: ordering = ['id'] def __init__(self, access): self._access = access self._t = Women.title
Но, обычно, вложенные классы содержат изолированный код, который доступен только из внешнего класса. Именно так следует проектировать программы при использовании вложенных классов.
В заключение занятия отмечу, что подобные вложения служат исключительно для удобства программирования. Какого-то особого, сакрального смысла во вложенных классах нет и все что можно делать через вложения, также можно реализовать и без них, используя обычные, независимые объявления. Но вы вполне можете столкнуться с ними в других проектах, в частности, как я отмечал вначале, во фреймворке Django. И чтобы это не вызывало у удивления, я решил привести пример работы этой конструкции. Надеюсь, вы теперь хорошо себе представляете, как работают вложенные классы.
Видео по теме
Концепция ООП простыми словами
#1. Классы и объекты. Атрибуты классов и объектов
#2. Методы классов. Параметр self
#3. Инициализатор __init__ и финализатор __del__
#4. Магический метод __new__. Пример паттерна Singleton
#5. Методы класса (classmethod) и статические методы (staticmethod)
#6. Режимы доступа public, private, protected. Сеттеры и геттеры
#7. Магические методы __setattr__, __getattribute__, __getattr__ и __delattr__
#9. Свойства property. Декоратор @property
#10. Пример использования объектов property
#11. Дескрипторы (data descriptor и non-data descriptor)
#12. Магический метод __call__. Функторы и классы-декораторы
#13. Магические методы __str__, __repr__, __len__, __abs__
#14 Магические методы __add__, __sub__, __mul__, __truediv__
#15. Методы сравнений __eq__, __ne__, __lt__, __gt__ и другие
#16. Магические методы __eq__ и __hash__
#17. Магический метод __bool__ определения правдивости объектов
#18. Магические методы __getitem__, __setitem__ и __delitem__
#19. Магические методы __iter__ и __next__
#20. Наследование в объектно-ориентированном программировании
#21. Функция issubclass(). Наследование от встроенных типов и от object
#22. Наследование. Функция super() и делегирование
#23. Наследование. Атрибуты private и protected
#24. Полиморфизм и абстрактные методы
#25. Множественное наследование
#27. Как работает __slots__ с property и при наследовании
#28. Введение в обработку исключений. Блоки try / except
#29. Обработка исключений. Блоки finally и else
#30. Распространение исключений (propagation exceptions)
#31. Инструкция raise и пользовательские исключения
#32. Менеджеры контекстов. Оператор with
#34. Метаклассы. Объект type
#35. Пользовательские метаклассы. Параметр metaclass
#36. Метаклассы в API ORM Django
#37. Введение в Python Data Classes (часть 1)
#38. Введение в Python Data Classes (часть 2)
#39. Python Data Classes при наследовании
© 2023 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта