Конструктор класса в python это
Обновлено: 25.04.2024
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:
Объектно-ориентированный шаблон в 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 ООП также имеет некоторые недостатки. Эти недостатки приведены ниже.
Конструктор в 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 – это «объектно-ориентированный язык программирования». Это означает, что большая часть кода реализована с помощью специальной конструкции, известной как классы. Программисты используют классы, чтобы связывать вещи вместе. Мы можем сделать это с помощью ключевого слова «class», которое представляет собой группу объектно-ориентированных конструкций.
В данном руководстве мы рассмотрим следующие темы:
- Что такое класс?
- Как создать?
- Что такое метод?
- Как создать экземпляр объекта?
- Как создать атрибуты в Python?
Понимание класса
Класс считается шаблоном кода, используемым для создания объектов в Python. Объекты состоят из переменных-членов и имеют связанное с ними поведение. В таком языке программирования, как Python, мы можем создать класс, используя ключевое слово «class».
Мы можем создать объект с помощью конструктора класса. Затем этот объект будет распознан как экземпляр класса. В Python мы можем создавать экземпляры, используя следующий синтаксис:
Создание класса в Python
Мы можем создать класс, используя ключевое слово class, как мы читали ранее. Давайте теперь рассмотрим пример, демонстрирующий создание простого пустого класса без функциональных возможностей.
В приведенном выше фрагменте кода мы определили пустой класс как «College». Затем мы создали экземпляр класса, используя ученика в качестве объекта, и напечатали этот объект для пользователей.
Атрибуты и методы в классе
Класс сам по себе не используется, пока с ним не связаны некоторые функции. Мы можем определить эти функции, установив атрибуты, которые действуют как контейнеры для данных и функций, связанных с этими атрибутами. Мы называем эти функции методами.
Атрибуты
Мы можем определить следующий класс с именем College. У этого класса будет атрибут student_name.
В приведенном выше фрагменте кода мы определили класс как «College». Затем мы определили атрибут как “student_name” внутри класса.
Теперь давайте попробуем присвоить класс переменной, то есть создадим экземпляр объекта. После этого мы сможем получить доступ к атрибутам, доступным в классе, с помощью dot . оператора. Давайте рассмотрим это на примере:
В приведенном выше фрагменте кода мы выполнили ту же процедуру, что и в предыдущем примере. Однако теперь мы создали экземпляр класса и напечатали значение атрибута с помощью объекта.
Методы
После того, как мы определили атрибуты, принадлежащие классу, теперь мы можем определить несколько функций для доступа к атрибутам класса. Эти функции известны как методы. Каждый раз, когда мы определяем метод, необходимо всегда предоставлять первый аргумент методу с ключевым словом «self».
Давайте рассмотрим следующий пример, демонстрирующий это.
В приведенном выше фрагменте кода мы определили класс и определили его атрибут. Затем мы определили метод как change_std_name для изменения предыдущего значения атрибута на другое. Затем мы создали экземпляр класса и распечатали необходимые выходные данные для пользователей. В результате мы можем наблюдать другое значение атрибута.
В объектно-ориентированном программировании конструктором класса называют метод, который автоматически вызывается при создании объектов. Его также можно назвать конструктором объектов класса. Имя такого метода обычно регламентируется синтаксисом конкретного языка программирования. Так в Java имя конструктора класса совпадает с именем самого класса. В Python же роль конструктора играет метод __init__().
В Python наличие пар знаков подчеркивания спереди и сзади в имени метода говорит о том, что он принадлежит к группе методов перегрузки операторов. Если подобные методы определены в классе, то объекты могут участвовать в таких операциях как сложение, вычитание, вызываться как функции и др.
При этом методы перегрузки операторов не надо вызывать по имени. Вызовом для них является сам факт участия объекта в определенной операции. В случае конструктора класса – это операция создания объекта. Так как объект создается в момент вызова класса по имени, то в этот момент вызывается метод __init__().
Необходимость конструкторов связана с тем, что нередко объекты должны иметь собственные свойства сразу. Пусть имеется класс Person, объекты которого обязательно должны иметь имя и фамилию. Если класс будет описан подобным образом
то создание объекта возможно без полей. Для установки имени и фамилии метод set_name() нужно вызывать отдельно:
В свою очередь, конструктор класса не позволит создать объект без обязательных полей:
Здесь при вызове класса в круглых скобках передаются значения, которые будут присвоены параметрам метода __init__(). Первый его параметр – self – ссылка на сам только что созданный объект.
Теперь, если мы попытаемся создать объект, не передав ничего в конструктор, то будет возбуждено исключение, и объект не будет создан:
Однако бывает, что надо допустить создание объекта, даже если никакие данные в конструктор не передаются. В таком случае параметрам конструктора класса задаются значения по умолчанию:
Если класс вызывается без значений в скобках, то для параметров будут использованы их значения по умолчанию. Однако поля width и height будут у всех объектов.
Кроме того, конструктору вовсе не обязательно принимать какие-либо параметры, не считая self. Значения полям могут назначаться как угодно. Также не обязательно, чтобы в конструкторе происходила установка атрибутов объекта. Там может быть, например, код, который порождает создание объектов других классов.
В других языка программирования, например в Java, классы могут содержать несколько конструкторов, которые между собой отличаются количеством параметром, а также, возможно, их типом. При создании объекта срабатывает тот конструктор, количество и типы параметров которого совпали с количеством и типами переданных в конструктор аргументов.
В Python создать несколько методов __init__() в классе можно, однако "рабочим" останется только последний. Он переопределит ранее определенные. Поэтому в Python в классах используется только один конструктор, а изменчивость количества передаваемых аргументов настраивается через назначение значений по-умолчанию.
Практическая работа. Конструктор и деструктор
Помимо конструктора объектов в языках программирования есть обратный ему метод – деструктор. Он вызывается, когда объект не создается, а уничтожается.
В языке программирования Python объект уничтожается, когда исчезают все связанные с ним переменные или им присваивается другое значение, в результате чего связь со старым объектом теряется. Удалить переменную можно с помощью команды языка del.
В классах Python функцию деструктора выполняет метод __del__().
Напишите программу по следующему описанию:
Есть класс Person, конструктор которого принимает три параметра (не учитывая self) – имя, фамилию и квалификацию специалиста. Квалификация имеет значение заданное по умолчанию, равное единице.
У класса Person есть метод, который возвращает строку, включающую в себя всю информацию о сотруднике.
Класс Person содержит деструктор, который выводит на экран фразу "До свидания, мистер …" (вместо троеточия должны выводиться имя и фамилия объекта).
В основной ветке программы создайте три объекта класса Person. Посмотрите информацию о сотрудниках и увольте самое слабое звено.
В конце программы добавьте функцию input(), чтобы скрипт не завершился сам, пока не будет нажат Enter. Иначе вы сразу увидите как удаляются все объекты при завершении работы программы.
В Python деструктор используется редко, так как интерпретатор и без него хорошо убирает "мусор".
Курс с примерами решений практических работ:
android-приложение, pdf-версия
Читайте также: