Что такое конструктор класса в python
Python — это процедурно-ориентированный и одновременно объектно-ориентированный язык программирования.
Процедурно-ориентированный
«Процедурно-ориентированный» подразумевает наличие функций. Программист может создавать функции, которые затем используются в сторонних скриптах.
Объектно-ориентированный
«Объектно-ориентированный» подразумевает наличие классов. Есть возможность создавать классы, представляющие собой прототипы для будущих объектов.
Создание класса в Python
Синтаксис для написания нового класса:
- Для создания класса пишется ключевое слово class , его имя и двоеточие (:). Первая строчка в теле класса описывает его. (По желанию) получить доступ к этой строке можно с помощью ClassName.__doc__
- В теле класса допускается объявление атрибутов, методов и конструктора.
Атрибут:
Атрибут — это элемент класса. Например, у прямоугольника таких 2: ширина ( width ) и высота ( height ).
Метод:
- Метод класса напоминает классическую функцию, но на самом деле — это функция класса. Для использования ее необходимо вызывать через объект.
- Первый параметр метода всегда self (ключевое слово, которое ссылается на сам класс).
Конструктор:
- Конструктор — уникальный метод класса, который называется __init__ .
- Первый параметр конструктора во всех случаях self (ключевое слово, которое ссылается на сам класс).
- Конструктор нужен для создания объекта.
- Конструктор передает значения аргументов свойствам создаваемого объекта.
- В одном классе всегда только один конструктор.
- Если класс определяется не конструктором, Python предположит, что он наследует конструктор родительского класса.
Создание объекта с помощью класса Rectangle:
Что происходит при создании объекта с помощью класса?
При создании объекта класса Rectangle запускается конструктор выбранного класса, и атрибутам нового объекта передаются значения аргументов. Как на этом изображении:
Конструктор с аргументами по умолчанию
В других языках программирования конструкторов может быть несколько. В Python — только один. Но этот язык разрешает задавать значение по умолчанию.
Все требуемые аргументы нужно указывать до аргументов со значениями по умолчанию.
Сравнение объектов
В Python объект, созданный с помощью конструктора, занимает реальное место в памяти. Это значит, что у него есть точный адрес.
Если объект AA — это просто ссылка на объект BB , то он не будет сущностью, занимающей отдельную ячейку памяти. Вместо этого он лишь ссылается на местоположение BB .
Оператор == нужен, чтобы узнать, ссылаются ли два объекта на одно и то же место в памяти. Он вернет True , если это так. Оператор != вернет True , если сравнить 2 объекта, которые ссылаются на разные места в памяти.
Атрибуты
В Python есть два похожих понятия, которые на самом деле отличаются:
Стоит разобрать на практике:
Атрибут
Объекты, созданные одним и тем же классом, будут занимать разные места в памяти, а их атрибуты с «одинаковыми именами» — ссылаться на разные адреса. Например:
Python умеет создавать новые атрибуты для уже существующих объектов. Например, объект player1 и новый атрибут address .
Встроенные атрибуты класса
Объекты класса — дочерние элементы по отношению к атрибутам самого языка Python. Таким образом они заимствуют некоторые атрибуты:
Атрибут | Описание |
---|---|
__dict__ | Предоставляет данные о классе коротко и доступно, в виде словаря |
__doc__ | Возвращает строку с описанием класса, или None , если значение не определено |
__class__ | Возвращает объект, содержащий информацию о классе с массой полезных атрибутов, включая атрибут __name__ |
__module__ | Возвращает имя «модуля» класса или __main__ , если класс определен в выполняемом модуле. |
Переменные класса
Для получения доступа к переменной класса лучше все-таки использовать имя класса, а не объект. Это поможет не путать «переменную класса» и атрибуты.
У каждой переменной класса есть свой адрес в памяти. И он доступен всем объектам класса.
Составляющие класса или объекта
В Python присутствует функция dir , которая выводит список всех методов, атрибутов и переменных класса или объекта.
Python – это «объектно-ориентированный язык программирования». Это означает, что большая часть кода реализована с помощью специальной конструкции, известной как классы. Программисты используют классы, чтобы связывать вещи вместе. Мы можем сделать это с помощью ключевого слова «class», которое представляет собой группу объектно-ориентированных конструкций.
В данном руководстве мы рассмотрим следующие темы:
- Что такое класс?
- Как создать?
- Что такое метод?
- Как создать экземпляр объекта?
- Как создать атрибуты в Python?
Понимание класса
Класс считается шаблоном кода, используемым для создания объектов в Python. Объекты состоят из переменных-членов и имеют связанное с ними поведение. В таком языке программирования, как Python, мы можем создать класс, используя ключевое слово «class».
Мы можем создать объект с помощью конструктора класса. Затем этот объект будет распознан как экземпляр класса. В Python мы можем создавать экземпляры, используя следующий синтаксис:
Создание класса в Python
Мы можем создать класс, используя ключевое слово class, как мы читали ранее. Давайте теперь рассмотрим пример, демонстрирующий создание простого пустого класса без функциональных возможностей.
В приведенном выше фрагменте кода мы определили пустой класс как «College». Затем мы создали экземпляр класса, используя ученика в качестве объекта, и напечатали этот объект для пользователей.
Атрибуты и методы в классе
Класс сам по себе не используется, пока с ним не связаны некоторые функции. Мы можем определить эти функции, установив атрибуты, которые действуют как контейнеры для данных и функций, связанных с этими атрибутами. Мы называем эти функции методами.
Атрибуты
Мы можем определить следующий класс с именем College. У этого класса будет атрибут student_name.
В приведенном выше фрагменте кода мы определили класс как «College». Затем мы определили атрибут как “student_name” внутри класса.
Теперь давайте попробуем присвоить класс переменной, то есть создадим экземпляр объекта. После этого мы сможем получить доступ к атрибутам, доступным в классе, с помощью dot . оператора. Давайте рассмотрим это на примере:
В приведенном выше фрагменте кода мы выполнили ту же процедуру, что и в предыдущем примере. Однако теперь мы создали экземпляр класса и напечатали значение атрибута с помощью объекта.
Методы
После того, как мы определили атрибуты, принадлежащие классу, теперь мы можем определить несколько функций для доступа к атрибутам класса. Эти функции известны как методы. Каждый раз, когда мы определяем метод, необходимо всегда предоставлять первый аргумент методу с ключевым словом «self».
Давайте рассмотрим следующий пример, демонстрирующий это.
В приведенном выше фрагменте кода мы определили класс и определили его атрибут. Затем мы определили метод как change_std_name для изменения предыдущего значения атрибута на другое. Затем мы создали экземпляр класса и распечатали необходимые выходные данные для пользователей. В результате мы можем наблюдать другое значение атрибута.
Конструктор в Python – это особый тип метода (функции), который используется для инициализации членов экземпляра класса.
В C ++ или Java конструктор имеет то же имя, что и его класс, в Python конструктор обрабатывается по-разному. Он используется для создания объекта.
Конструкторы бывают двух типов:
- Параметризованный конструктор
- Непараметрический конструктор
Определение конструктора выполняется, когда мы создаем объект этого класса. Конструкторы также проверяют, что у объекта достаточно ресурсов для выполнения любой задачи запуска.
Создание конструктора на Python
В Python метод __init __() имитирует конструктор класса. Этот метод вызывается при создании экземпляра класса. Он принимает ключевое слово self в качестве первого аргумента, который позволяет получить доступ к атрибутам или методу класса.
Мы можем передать любое количество аргументов во время создания объекта класса, в зависимости от определения __init __(). В основном он используется для инициализации атрибутов класса. У каждого класса должен быть конструктор, даже если он просто полагается на конструктор по умолчанию.
Рассмотрим следующий пример для инициализации атрибутов класса Employee при работе с конструкторами в Python.
Подсчет количества объектов класса
Конструктор вызывается автоматически, когда мы создаем объект класса. Рассмотрим следующий пример.
Непараметрический
Непараметрический конструктор используется, когда мы не хотим манипулировать значением, или конструктором, который имеет только self в качестве аргумента. Разберем на примере.
Параметризованный конструктор Python
У параметризованного конструктора есть несколько параметров вместе с самим собой.
Конструктор Python по умолчанию
Когда мы не включаем конструктор в класс или забываем его объявить, он становится конструктором по умолчанию. Он не выполняет никаких задач, а инициализирует объекты. Рассмотрим пример.
Более одного конструктора в одном классе
Давайте посмотрим на другой сценарий, что произойдет, если мы объявим два одинаковых конструктора в классе.
В приведенном выше коде объект st вызвал второй конструктор, тогда как оба имеют одинаковую конфигурацию. Первый метод недоступен для объекта st. Внутренне объект класса всегда будет вызывать последний конструктор, если у класса есть несколько конструкторов.
Примечание. Перегрузка конструктора в Python запрещена.
Встроенные функции классов Python
Встроенные функции, определенные в классе, описаны в следующей таблице.
SN | Функция | Описание |
---|---|---|
1 | getattr(obj,name,default) | Используется для доступа к атрибуту объекта. |
2 | setattr(obj, name,value) | Она используется для установки определенного значения для определенного атрибута объекта. |
3 | delattr (obj, name) | Необходима для удаления определенного атрибута. |
4 | hasattr (obj, name) | Возвращает истину, если объект содержит определенный атрибут. |
Встроенные атрибуты класса
Наряду с другими атрибутами класс Python также содержит некоторые встроенные атрибуты класса, которые предоставляют информацию о классе.
Объектно-ориентированный шаблон в Python является наиболее распространенным типом шаблона проектирования, и его можно найти почти в каждом языке программирования высокого уровня. В этом методе мы создаем объект и конкретный класс и используем функциональность класса, используя объект этого определенного класса. Понятия oops состоят из следующих компонентов:
- Класс
- Объект
- Конструктор
- Наследование
- Инкапсуляция
- Полиморфизм
Мы кратко обсудим вышеуказанные компоненты.
Класс
Класс — это план объекта; он содержит методы и конструкторы. Мы используем ключевое слово class для определения класса. Класс Python будет выглядеть следующим образом.
Класс может содержать специальные атрибуты, начинающиеся с двойного подчеркивания(__). Например, __init__() — непараметризованный конструктор.
Объект
Объект используется для доступа к атрибутам класса. Мы можем создать объект класса следующим образом.
Конструкторы
Конструкторы — это специальные методы, которые автоматически вызываются всякий раз, когда создается экземпляр нового объекта этого класса. Они начинаются с двойного подчеркивания __ и называются специальными функциями. Конструктор определяется как функция __int__(). Он используется для инициализации всех переменных.
Наследование
Наследование — это процесс передачи свойства одного класса другому классу. Класс, производный от свойства другого класса, называется подклассом или дочерним классом, а класс, производный от другого класса, называется родительским классом или базовым классом. Наследование обеспечивает возможность повторного использования кода.
Давайте разберем следующий пример.
Собственный параметр
Self работает в Python так же, как «this» в C++. Он относится к текущему классу функции, и мы можем получить доступ к данным в функции класса. Он работает как переменная, но не вызывает данные.
Инкапсуляция
В отличие от C++, Python не поддерживает такие ключевые слова, как public, protected и private, для определения доступности данных. По умолчанию все данные в Python общедоступны. Но он предоставляет возможность определить любой метод или переменную private. Мы можем использовать «__», чтобы скрыть его свойство перед переменной или методом. Давайте разберем следующий пример:
Существует специальный синтаксис, который можно использовать для доступа к закрытым данным или методу в Python. Синтаксис на самом деле является его именем изменения. Давайте разберем следующий пример.
В приведенном выше коде мы определили переменную age как закрытый член класса. Для доступа к нему мы использовали специальный синтаксис с использованием объекта класса./p>
Полиморфизм
Полиморфизм — один из наиболее важных аспектов концепции oops. Python — это язык с динамической типизацией, который отслеживает типы переменных. Полиморфизм используется для достижения многих целей одним и тем же способом.
Как видно из приведенного выше кода, операция «добавить» поддерживается не только целым числом, но и строкой. Это простой пример полиморфизма.
Многие операции и функции в Python полиморфны. Итак, пока мы используем полиморфные операторы и функции, полиморфизм будет существовать, даже если у нас нет этой цели.
Преимущества объектно-ориентированного шаблона
Ниже приведены несколько важных преимуществ шаблона проектирования Oops:
- Он поддерживает привязку динамического типа, что означает, что экземпляр класса может динамически изменяться во время выполнения.
- Python поддерживает множественное наследование и перегрузку операторов с расширенным определением, которого нет в некоторых языках ООП.
- Концепция oops в Python не поддерживает ключевое слово private, public и protected, поскольку это усложняет синтаксис. Как сказал изобретатель Python Гвидо Ван Россум: «Изобилие синтаксиса приносит больше хлопот, чем помощи». Мы можем повторно использовать код, используя наследование.
- Полиморфизм обеспечивает гибкость программы. Используя полиморфизм, мы можем создать такой же метод в родительском классе, и он будет работать во всех дочерних классах.
- Обеспечивает эффективное решение проблем. Концепция ООП позволяет нам разбивать код на небольшие задачи, которые мы затем можем решить.
Недостатки объектно-ориентированного шаблона
Шаблон Python ООП также имеет некоторые недостатки. Эти недостатки приведены ниже.
Classes provide a means of bundling data and functionality together. Creating a new class creates a new type of object, allowing new instances of that type to be made. Each class instance can have attributes attached to it for maintaining its state. Class instances can also have methods (defined by its class) for modifying its state.
Compared with other programming languages, Python’s class mechanism adds classes with a minimum of new syntax and semantics. It is a mixture of the class mechanisms found in C++ and Modula-3. Python classes provide all the standard features of Object Oriented Programming: the class inheritance mechanism allows multiple base classes, a derived class can override any methods of its base class or classes, and a method can call the method of a base class with the same name. Objects can contain arbitrary amounts and kinds of data. As is true for modules, classes partake of the dynamic nature of Python: they are created at runtime, and can be modified further after creation.
In C++ terminology, normally class members (including the data members) are public (except see below Private Variables ), and all member functions are virtual. As in Modula-3, there are no shorthands for referencing the object’s members from its methods: the method function is declared with an explicit first argument representing the object, which is provided implicitly by the call. As in Smalltalk, classes themselves are objects. This provides semantics for importing and renaming. Unlike C++ and Modula-3, built-in types can be used as base classes for extension by the user. Also, like in C++, most built-in operators with special syntax (arithmetic operators, subscripting etc.) can be redefined for class instances.
(Lacking universally accepted terminology to talk about classes, I will make occasional use of Smalltalk and C++ terms. I would use Modula-3 terms, since its object-oriented semantics are closer to those of Python than C++, but I expect that few readers have heard of it.)
9.1. A Word About Names and Objects¶
Objects have individuality, and multiple names (in multiple scopes) can be bound to the same object. This is known as aliasing in other languages. This is usually not appreciated on a first glance at Python, and can be safely ignored when dealing with immutable basic types (numbers, strings, tuples). However, aliasing has a possibly surprising effect on the semantics of Python code involving mutable objects such as lists, dictionaries, and most other types. This is usually used to the benefit of the program, since aliases behave like pointers in some respects. For example, passing an object is cheap since only a pointer is passed by the implementation; and if a function modifies an object passed as an argument, the caller will see the change — this eliminates the need for two different argument passing mechanisms as in Pascal.
9.2. Python Scopes and Namespaces¶
Before introducing classes, I first have to tell you something about Python’s scope rules. Class definitions play some neat tricks with namespaces, and you need to know how scopes and namespaces work to fully understand what’s going on. Incidentally, knowledge about this subject is useful for any advanced Python programmer.
Let’s begin with some definitions.
By the way, I use the word attribute for any name following a dot — for example, in the expression z.real , real is an attribute of the object z . Strictly speaking, references to names in modules are attribute references: in the expression modname.funcname , modname is a module object and funcname is an attribute of it. In this case there happens to be a straightforward mapping between the module’s attributes and the global names defined in the module: they share the same namespace! 1
Attributes may be read-only or writable. In the latter case, assignment to attributes is possible. Module attributes are writable: you can write modname.the_answer = 42 . Writable attributes may also be deleted with the del statement. For example, del modname.the_answer will remove the attribute the_answer from the object named by modname .
Namespaces are created at different moments and have different lifetimes. The namespace containing the built-in names is created when the Python interpreter starts up, and is never deleted. The global namespace for a module is created when the module definition is read in; normally, module namespaces also last until the interpreter quits. The statements executed by the top-level invocation of the interpreter, either read from a script file or interactively, are considered part of a module called __main__ , so they have their own global namespace. (The built-in names actually also live in a module; this is called builtins .)
The local namespace for a function is created when the function is called, and deleted when the function returns or raises an exception that is not handled within the function. (Actually, forgetting would be a better way to describe what actually happens.) Of course, recursive invocations each have their own local namespace.
A scope is a textual region of a Python program where a namespace is directly accessible. “Directly accessible” here means that an unqualified reference to a name attempts to find the name in the namespace.
Although scopes are determined statically, they are used dynamically. At any time during execution, there are 3 or 4 nested scopes whose namespaces are directly accessible:
the innermost scope, which is searched first, contains the local names
the scopes of any enclosing functions, which are searched starting with the nearest enclosing scope, contains non-local, but also non-global names
the next-to-last scope contains the current module’s global names
the outermost scope (searched last) is the namespace containing built-in names
If a name is declared global, then all references and assignments go directly to the middle scope containing the module’s global names. To rebind variables found outside of the innermost scope, the nonlocal statement can be used; if not declared nonlocal, those variables are read-only (an attempt to write to such a variable will simply create a new local variable in the innermost scope, leaving the identically named outer variable unchanged).
Usually, the local scope references the local names of the (textually) current function. Outside functions, the local scope references the same namespace as the global scope: the module’s namespace. Class definitions place yet another namespace in the local scope.
It is important to realize that scopes are determined textually: the global scope of a function defined in a module is that module’s namespace, no matter from where or by what alias the function is called. On the other hand, the actual search for names is done dynamically, at run time — however, the language definition is evolving towards static name resolution, at “compile” time, so don’t rely on dynamic name resolution! (In fact, local variables are already determined statically.)
A special quirk of Python is that – if no global or nonlocal statement is in effect – assignments to names always go into the innermost scope. Assignments do not copy data — they just bind names to objects. The same is true for deletions: the statement del x removes the binding of x from the namespace referenced by the local scope. In fact, all operations that introduce new names use the local scope: in particular, import statements and function definitions bind the module or function name in the local scope.
The global statement can be used to indicate that particular variables live in the global scope and should be rebound there; the nonlocal statement indicates that particular variables live in an enclosing scope and should be rebound there.
9.2.1. Scopes and Namespaces Example¶
This is an example demonstrating how to reference the different scopes and namespaces, and how global and nonlocal affect variable binding:
The output of the example code is:
Note how the local assignment (which is default) didn’t change scope_test's binding of spam. The nonlocal assignment changed scope_test's binding of spam, and the global assignment changed the module-level binding.
You can also see that there was no previous binding for spam before the global assignment.
9.3. A First Look at Classes¶
Classes introduce a little bit of new syntax, three new object types, and some new semantics.
9.3.1. Class Definition Syntax¶
The simplest form of class definition looks like this:
Class definitions, like function definitions ( def statements) must be executed before they have any effect. (You could conceivably place a class definition in a branch of an if statement, or inside a function.)
In practice, the statements inside a class definition will usually be function definitions, but other statements are allowed, and sometimes useful — we’ll come back to this later. The function definitions inside a class normally have a peculiar form of argument list, dictated by the calling conventions for methods — again, this is explained later.
When a class definition is entered, a new namespace is created, and used as the local scope — thus, all assignments to local variables go into this new namespace. In particular, function definitions bind the name of the new function here.
When a class definition is left normally (via the end), a class object is created. This is basically a wrapper around the contents of the namespace created by the class definition; we’ll learn more about class objects in the next section. The original local scope (the one in effect just before the class definition was entered) is reinstated, and the class object is bound here to the class name given in the class definition header ( ClassName in the example).
9.3.2. Class Objects¶
Class objects support two kinds of operations: attribute references and instantiation.
Attribute references use the standard syntax used for all attribute references in Python: obj.name . Valid attribute names are all the names that were in the class’s namespace when the class object was created. So, if the class definition looked like this:
then MyClass.i and MyClass.f are valid attribute references, returning an integer and a function object, respectively. Class attributes can also be assigned to, so you can change the value of MyClass.i by assignment. __doc__ is also a valid attribute, returning the docstring belonging to the class: "A simple example class" .
Class instantiation uses function notation. Just pretend that the class object is a parameterless function that returns a new instance of the class. For example (assuming the above class):
creates a new instance of the class and assigns this object to the local variable x .
The instantiation operation (“calling” a class object) creates an empty object. Many classes like to create objects with instances customized to a specific initial state. Therefore a class may define a special method named __init__() , like this:
When a class defines an __init__() method, class instantiation automatically invokes __init__() for the newly-created class instance. So in this example, a new, initialized instance can be obtained by:
Of course, the __init__() method may have arguments for greater flexibility. In that case, arguments given to the class instantiation operator are passed on to __init__() . For example,
9.3.3. Instance Objects¶
Now what can we do with instance objects? The only operations understood by instance objects are attribute references. There are two kinds of valid attribute names: data attributes and methods.
data attributes correspond to “instance variables” in Smalltalk, and to “data members” in C++. Data attributes need not be declared; like local variables, they spring into existence when they are first assigned to. For example, if x is the instance of MyClass created above, the following piece of code will print the value 16 , without leaving a trace:
The other kind of instance attribute reference is a method. A method is a function that “belongs to” an object. (In Python, the term method is not unique to class instances: other object types can have methods as well. For example, list objects have methods called append, insert, remove, sort, and so on. However, in the following discussion, we’ll use the term method exclusively to mean methods of class instance objects, unless explicitly stated otherwise.)
Valid method names of an instance object depend on its class. By definition, all attributes of a class that are function objects define corresponding methods of its instances. So in our example, x.f is a valid method reference, since MyClass.f is a function, but x.i is not, since MyClass.i is not. But x.f is not the same thing as MyClass.f — it is a method object, not a function object.
9.3.4. Method Objects¶
Usually, a method is called right after it is bound:
In the MyClass example, this will return the string 'hello world' . However, it is not necessary to call a method right away: x.f is a method object, and can be stored away and called at a later time. For example:
will continue to print hello world until the end of time.
What exactly happens when a method is called? You may have noticed that x.f() was called without an argument above, even though the function definition for f() specified an argument. What happened to the argument? Surely Python raises an exception when a function that requires an argument is called without any — even if the argument isn’t actually used…
Actually, you may have guessed the answer: the special thing about methods is that the instance object is passed as the first argument of the function. In our example, the call x.f() is exactly equivalent to MyClass.f(x) . In general, calling a method with a list of n arguments is equivalent to calling the corresponding function with an argument list that is created by inserting the method’s instance object before the first argument.
If you still don’t understand how methods work, a look at the implementation can perhaps clarify matters. When a non-data attribute of an instance is referenced, the instance’s class is searched. If the name denotes a valid class attribute that is a function object, a method object is created by packing (pointers to) the instance object and the function object just found together in an abstract object: this is the method object. When the method object is called with an argument list, a new argument list is constructed from the instance object and the argument list, and the function object is called with this new argument list.
9.3.5. Class and Instance Variables¶
Generally speaking, instance variables are for data unique to each instance and class variables are for attributes and methods shared by all instances of the class:
As discussed in A Word About Names and Objects , shared data can have possibly surprising effects with involving mutable objects such as lists and dictionaries. For example, the tricks list in the following code should not be used as a class variable because just a single list would be shared by all Dog instances:
Читайте также: