Может ли в одном классе быть несколько конструкторов?
Доброго времени суток. Программируя на питоне, возникла потребность создать несколько конструкторов в одном классе. Может ли кто подсказать, есть ли такая возможность в питоне, и если есть, как правильно это реализовать. Буду особо благодарен, если кто-то сможет скинуть пример.
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
Ответы с готовыми решениями:
как правильно сделать в одном запросе может быть несколько подзапросов
Народ подскажите как правильно сделать запрос SELECT id,title FROM table (IN SELECT cat.
Несколько пользовательских элементов в одном классе
Вечер добрый, Может кто-то может подсказать, как собрать несколько пользовательских элементов.
Как может быть в классе 2 одинаковых функции?
Открываю рабочий проект и там вижу такие вот строки public abstract class MainMenu .
840 / 478 / 58
Регистрация: 18.09.2012
Сообщений: 1,688
Petrol1342, вам придёться в одном конструкторе в зависимости от параметров делать то или иное. А конкретно, что вы хотите?
Регистрация: 11.09.2013
Сообщений: 22
Класс, который я пытаюсь написать, создает многомерный массив. Требуется, чтобы массив, в зависимости от данных вводимых пользователем заполнялся разными значениями: в первом случае конструктор принимает n — размерность, а далее по порядку пределы изменения индексов; во втором случае конструктор принимает размерность, а далее по порядку символьные переменные, которые этот массив заполнят. Эта конструкция взята из матлаба, там это все реализовано. Собственно, пытаемся сделать это теперь в питоне
4866 / 3288 / 468
Регистрация: 10.12.2008
Сообщений: 10,570
можешь в __init__ сделать условие
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
>>> class A: . def __init__(self, *args): . a1 = args[0] . rest = args[1:] . if type(a1) == int: . self.type = 1 . self.n = a1 . self.pred = rest . elif type(a1) == tuple: . self.type = 2 . self.i, self.j = a1 . self.chars = rest . . def print(self): . if self.type == 1: . print(self.n, self.pred) . elif self.type == 2: . print(self.i, self.j, self.chars) . >>> a1 = A(2, (1, 2), (3, 4)) >>> a2 = A((2, 3), 'a', 'b') >>> >>> a1.print() 2 ((1, 2), (3, 4)) >>> a2.print() 2 3 ('a', 'b') >>>
Классы: введение в объектно-ориентированное программирование
Представление переменных в языке Python сильно отличается от традиционных языков программирования: Pascal, C, Java. Любая сущность, с которой работает Python-программа, является объектом. Числа, строки, списки, множества являются объектами. Названия функций также являются объектами и в некотором смысле ничем не отличаются от чисел, кроме того, что у функций есть операции, нетипичные для чисел (например, вызов функции при помощи операции () ), а другие операции, наоборот, отсутствуют.
У каждого объекта есть свой тип (это также называется классом): int , str , set , function и т.д.
Переменные в свою очередь являются ссылками на объекты: в любой момент времени переменная связана с каким-то объектом в памяти. Если мы выполняем присваивание:
a = 5
то имя переменной 5 связывается с объектом типа int , в котором хранится значение 5.
Если теперь выполнить другое присваивание:
a = 'hello'
то старая связь разрывается, создается новый объект типа str , в котором хранится значение ‘hello’ , и переменная a связывается с этим объектом.
Если же теперь выполнить операцию:
def a(): pass
то в памяти создается объект типа function , хранящий тело функции из одной инструкции pass , и переменная a теперь связывается с этой функцией.
Если же справа от оператора = поставить имя другого объекта:
b = a
то второй объект связывается с тем же объектом, с которым был связан первый объект: теперь b и a становятся ссылками на один и тот же объект и являются неразличимыми, пока для одного из них связь не будет разорвана при помощи оператора =
Интересным свойством является то, что переменные могут ссылаться на один и тот же объект. Проверить, ссылаются ли две переменные на один объект или на разные можно при помощи оператора is , возвращающего значение True , если ссылки совпадают:
a is b
При этом переменные могут ссылаться на различные, но равные объекты, то есть оператов == для них вернет True . Пример различных, но равных объектов:
a = 'a' * 1000 b = 'aa' * 500
Но при этом в целях экономии памяти если переменным присвоить значение одного и того же небольшого целого числа или одной и той же небольшой строки, то переменные будут ссылаться на один и тот же объект, даже если значение этого объекта будет получено разными путями. Например:
a = 2 + 3 b = 1 + 4
При выполнении второго оператора = , интерпретатор обнаружит, что в памяти уже есть объект со значением 5 и не будет создавать другой объект с таким же значением.
Такое повторное использование применяется только для небольших чисел, строк и объектов типа bool , поскольку для больших объектов проверка того, что объект уже хранится в памяти требует много времени.
Создание новых типов данных
Часто программе приходится иметь дело не с простыми числовыми и строковым данными, а с более сложными объектами, являющихся представлением каких-то жизненных сущностей.
Например, пусть программе дан список учащихся, который нужно отсортировать по экзаменационному баллу. Это можно сделать, если хранить в одном списке имена учащихся, в другом списке их баллы, и сортировать список баллов, синхронно переставляя элементы в списке имен учащихся. Такой путь, очевидно, неудобен.
Можно использовать кортеж, один из элементов которого будет равен имени учащегося, другой элемент — его баллу. Такой подход лучше тем, что позволяет работать с представлением одного учащегося, как с единым целым, что экономит действия, например, при сортировке, и повышает наглядность программы.
В этом случае придется поставать так:
Vasya = ('Василий', 4) print('Имя:', Vasya[0]) print('Балл:', Vasya[1])
Но элементы кортежей не имеют собственных названий (то есть вовсе неочевидно, балл хранится именно в элементе кортежа с индексом 1). Удобней было бы обозначить атрибуты каждого объекта какими-то осмысленными идентификаторами и далее работать с этими идентификаторами. Пример:
class Person: pass Vasya = Person() Vasya.name = 'Василий' Vasya.score = 4
В этом примере мы объявляем новый класс объектов: Person . Затем мы создаем новый объект класса, при помощи вызова конструктора Person() , который возвращает ссылку на новый объект, и присваиваем ссылку на этот объект переменной Vasya , которая также называется экземпляром класса или объектом. Далее объекту Vasya устанавливается два атрибута: name (типа str ) и score (типа int ).
Поля и методы
Таким образом, объе ты классов представляют собой новые типы данный, объединяющие несколько атрибутов (полей). Атрибуты могут быть произвольными типами данных: числами, строками, списками, множествами, словарями, другими классами. Обращение к атрибуту какого-либо объекта осуществляется при помощи dot-нотации: имя_класса.имя_атрибута .
Помимо полей у классов бывают методы: функции, которые можно применять к экземплярам класса. Например, у списков есть метод sort . Вызов метода также осуществляется при помощи dot-нотации, например: A.sort() .
Можно рассматривать методы, как функции, у которых первым параметром является экземпляр класса. Методы так и объявляются: как функции внутри описания класса, первым параметром которой является экземпляр класса. По соглашению, эта ссылка должна называться self . Вот пример объявления класса Person и метода print , выводящего информацию о полях name и score :
class Person: def print(self): print(self.name, self.score)
Теперь для вызова метода print для объекта Vasya нужно вызвать Vasya.print() . При этом не нужно задавать первый параметр self : в качестве этого параметра автоматически будет передан объект, для которого был вызван метод.
Методы могут принимать дополнительные параметры, как и обычные функции. Эти параметры описываются после параметра self .
Стандартные методы
Наш метод print предполагает, что у объекта есть поля name и score , иначе он завершится с ошибкой. Хочется быть уверенным, что у любого объекта класса Person есть эти поля. Для этого проще всего создать эти поля при создании объекта, т.е. при вызове функции Person . Для этого можнзо использовать конструктор: метод, который автоматически вызывается при создании объекта. Конструктором является метод с именем __init__ :
class Person: def __init__(self): self.name = '' self.score = 0
При создании объекта функцией Person будет автоматически вызван конструктор __init__ (явно вызывать его не нужно), который полю name объекта, для которого он вызван, присвоит пустую строку, а полю score присвоит значение 0.
Удобно будет, если конструктор сможет создавать объект, инициализируя поля объекта некоторыми параметрами, используя передаваемые ему значения, а не значения по умолчанию. Для этого конструктору можно передавать параметры:
class Person: def __init__(self, name, score): self.name = name self.score = score
В данном случае мы используем одинаковые имена ( name , score ) для обозначения передаваемых параметров и полей класса. Это сделано для удобства — имена могут и различаться.
Теперь мы сможем создавать новый объект с заданными полями так: Person(‘Иванов’, 5) .
Но поскольку конструктор теперь обязательно принимает два дополнительных параметра мы лишились возможности вызывать конструктор без параметров, что также бывает удобно. Можно вернуть эту особенность, если установить для параметров, передаваемых конструктору, значения по умолчанию:
class Person: def __init__(self, name = '', score = 0): self.name = name self.score = score
Теперь мы можем вызывать конструктор как с параметрами ( Person(‘Иванов’, 5) ), так и без параметров ( Person() ), в последнем случае параметрам будут переданы значения “по умолчанию”, указанные в описании конструктора.
Есть и другие стандартные методы, которые можно определить в описании класса.
Метод __repr__ должен возвращать текстовую строку, содержащую код (на языке Python), создающую объект, равный данному. Естественно, метод __repr__ должен содержать вызов конструктора, которому передаются в качестве параметров все строки исходного объекта, то есть он должен возвращать строку вида «Person(‘Иванов’, 5)»
Пример метода __repr__ (для экономии места опустим описание конструктора __init__ ):
class Person: def __repr__(self): return "Person('" + self.name + "', " + self.score + ")"
Таким образом, метод __repr__ возвращает строку с описанием объекта, которое может быть воспринято итерпретатором языка Питон.
Метод __str__ возвращает строку, являющуюся описанием объекта в том виде, в котором его удобно будет воспринимать человеку. Здесь не нужно выводить имя конструктора, можно, например, просто вернуть строку с содержимым всех полей:
class Person: def __str__(self): return self.name + ' ' + str(self.score)
Метод __str__ будет вызываться, когда вызывается функция str от данного объекта, например, str(Vasya) . То есть создавая метод __str__ вы даете указание Питону, как преобразовывать данный объект к типу str .
Поскольку функция print использует именно функцию str для вывода объекта на экран, то определение метода __str__ позволит выводить объекты на экран удобным способом: при помощи print .
Переопределение стандартных операций
Рассмотрим класс Point (точка), используемый для представления точек (или радиус-векторов) на координатной плоскости. У точки два естественных поля-координаты: x и y . Если рассматривать точку как радиус-вектор, то хотелось бы определить для точек операцию + , чтобы точки можно было складывать столь же удобно, как и числа или строки. Например, чтобы можно было записать так:
A = Point(1, 2) B = Point(3, 4) C = A + B
Для этого необходимо перегрузить операцию + : определить функцию, которая будет использоваться, если операция + будет вызвана для объекта класса Point . Для этого нужно определить метод __add__ класса Point , у которого два параметра: неявная ссылка self на экземпляр класса, для которого она будет вызвана (это левый операнд операции + ) и явная ссылка other на правый операнд:
class Point: def __init__(self, x = 0, y = 0): self.x = x self.y = y def __add__(self, other): return Point(self.x + other.x, self.y + other.y)
Теперь при вызове оператора A + B Питон вызовет метод A.__add__(B) , то есть вызовет указанный метод, где self = A , other = B .
class Point: def __lt__(self, other): return self.x < other.x or self.x == other.x and self.y < other.y
В этом примере оператор вернет True , если у левого операнда поле x меньше, чем у правого операнда, а также если поля x у них равны, а поле y меньше у левого операнда.
Функции type и isinstance
Полезно, чтобы конструктор __init__ мог воспринимать параметры различных типов. Например, удобно инициализировать точку не только двумя числами, но и строкой, в которой через пробел записаны два числа (такая строка может быть считана со стандартного ввода), списком или кортежем. То есть передаваемые конструктору аргументы могут быть разного типа ( int , float , str , list , tuple ). Конструктор должен выполнять различные действия для параметров различного типа, для этого нужно уметь проверять принадлежность объекту какому-либо классу.
Эту задачу можно решить при помощи функций type и isinstance . Функция type возвращает класс, к которому принадлежит объект. Например:
if type(a) == int: print('a - целое число') elif type(a) == str: print('a - строка')
Для этого можно использовать функцию isinstance , у которой два параметра: объект и класс. Функция возращает True , если объект принадлежит классу или False в противном случае. Пример:
if isinstance(a, int): print('a - целое число') elif isinstance(a, str): print('a - строка')
Конструктор класса – метод __init__
В объектно-ориентированном программировании конструктором класса называют метод, который автоматически вызывается при создании объектов. Его также можно назвать конструктором объектов класса. Имя такого метода обычно регламентируется синтаксисом конкретного языка программирования. Так в Java имя конструктора класса совпадает с именем самого класса. В Python же роль конструктора играет метод __init__ .
В Python наличие пар знаков подчеркивания спереди и сзади в имени метода говорит о том, что он принадлежит к группе методов перегрузки операторов. Если подобные методы определены в классе, то объекты могут участвовать в таких операциях как сложение, вычитание, вызываться как функции и др.
При этом методы перегрузки операторов не надо вызывать по имени. Вызовом для них является сам факт участия объекта в определенной операции. В случае конструктора класса – это операция создания объекта. Так как объект создается в момент вызова класса по имени, то в этот момент вызывается метод __init__ .
Необходимость конструкторов связана с тем, что нередко объекты должны иметь собственные свойства сразу. Пусть имеется класс Person , объекты которого обязательно должны иметь имя и фамилию. Если класс будет описан подобным образом
class Person: def set_name(self, n, s): self.name = n self.surname = s
то создание объекта возможно без полей. Для установки имени и фамилии метод set_name нужно вызывать отдельно:
>>> from test import Person >>> p1 = Person() >>> p1.set_name("Bill", "Ross") >>> p1.name, p1.surname ('Bill', 'Ross')
В свою очередь, конструктор класса не позволит создать объект без обязательных полей:
class Person: def __init__(self, n, s): self.name = n self.surname = s p1 = Person("Sam", "Baker") print(p1.name, p1.surname)
Здесь при вызове класса в круглых скобках передаются значения, которые будут присвоены параметрам метода __init__ . Первый его параметр – self – ссылка на сам только что созданный объект.
Теперь, если мы попытаемся создать объект, не передав ничего в конструктор, то будет возбуждено исключение, и объект не будет создан:
>>> p1 = Person() Traceback (most recent call last): File "", line 1, in TypeError: __init__() missing 2 required positional arguments: 'n' and 's'
Однако бывает, что надо допустить создание объекта, даже если никакие данные в конструктор не передаются. В таком случае параметрам конструктора класса задаются значения по умолчанию:
class Rectangle: def __init__(self, w=0.5, h=1): self.width = w self.height = h def square(self): return self.width * self.height rec1 = Rectangle(5, 2) rec2 = Rectangle() rec3 = Rectangle(3) rec4 = Rectangle(h=4) print(rec1.square()) print(rec2.square()) print(rec3.square()) print(rec4.square())
10 0.5 3 2.0
Если класс вызывается без значений в скобках, то для параметров будут использованы их значения по умолчанию. Однако поля width и height будут у всех объектов.
Кроме того, конструктору вовсе не обязательно принимать какие-либо параметры, не считая self .
В других языка программирования, например в Java, классы могут содержать несколько конструкторов, которые между собой отличаются количеством параметром, а также, возможно, их типом. При создании объекта срабатывает тот конструктор, количество и типы параметров которого совпали с количеством и типами переданных в конструктор аргументов.
В Python создать несколько методов __init__ в классе можно, однако "рабочим" останется только последний. Он переопределит ранее определенные. Поэтому в Python в классах используется только один конструктор, а изменчивость количества передаваемых аргументов настраивается через назначение значений по-умолчанию.
Практическая работа. Конструктор и деструктор
Помимо конструктора объектов в языках программирования есть обратный ему метод – деструктор. Он вызывается, когда объект не создается, а уничтожается.
Это не значит, что сам деструктор уничтожает объект. В теле самого метода нет никаких инструкций по удалению экземпляра. Непосредственное удаление выполняется автоматически так называемым сборщиком мусора.
Деструктор (финализатор) в коде вашего класса следует использовать, когда при удалении объекта необходимо выполнить ряд сопутствующий действий, например, отправить сообщение, закрыть файл, разорвать соединение с базой данных.
В языке программирования Python объект уничтожается, когда исчезают все связанные с ним переменные или им присваивается другое значение, в результате чего связь со старым объектом теряется. Удалить переменную можно с помощью команды языка del . Также все объекты уничтожаются, когда программа завершает свою работу.
В классах Python функцию деструктора выполняет метод __del__ .
Напишите программу по следующему описанию:
- Есть класс Person , конструктор которого принимает три параметра (не учитывая self ) – имя, фамилию и квалификацию специалиста. Квалификация имеет значение заданное по умолчанию, равное единице.
- У класса Person есть метод, который возвращает строку, включающую в себя всю информацию о сотруднике.
- Класс Person содержит деструктор, который выводит на экран фразу "До свидания, мистер …" (вместо троеточия должны выводиться имя и фамилия объекта).
- В основной ветке программы создайте три объекта класса Person . Посмотрите информацию о сотрудниках и увольте самое слабое звено.
- В конце программы добавьте функцию input() , чтобы скрипт не завершился сам, пока не будет нажат Enter . Иначе вы сразу увидите как удаляются все объекты при завершении работы программы.
Курс с примерами решений практических работ:
pdf-версия
X Скрыть Наверх
Объектно-ориентированное программирование на Python
Несколько конструкторов с разным количеством аргументов
В данном случае можно создавать экземпляры класса только со вторым констуктором, в то время как запись x = a(42) вызовет ошибку.
Отслеживать
51.2k 86 86 золотых знаков 266 266 серебряных знаков 505 505 бронзовых знаков
задан 13 фев 2013 в 19:16
119 1 1 золотой знак 3 3 серебряных знака 10 10 бронзовых знаков
4 ответа 4
Сортировка: Сброс на вариант по умолчанию
Если быть кратким то НЕТ.
Более детально посмотрите обсуждение вот ЗДЕСЬ. Там и варианты решений есть такие как использование необязательных или ключевых аргументов.
Отслеживать
3 4 4 бронзовых знака
ответ дан 13 фев 2013 в 19:21
3,724 13 13 серебряных знаков 16 16 бронзовых знаков
В Python'е перегрузок функций (а конструктор, по факту - это функция) нет в принципе. В вашем случае, вызывается всегда второй конструктор, ибо инструкция def означает "создать объект функции и присвоить этот объект написанному имени", то есть, сначала вы присваиваете имени __init__ одну функцию (с параметром b ), а затем - тому же имени - другую функцию, уже без параметра b .
Поведение, которого вы добиваетесь, можно получить, используя параметры по умолчанию, например:
def __init__(self, b=None): # Здесь лучше придумать что-то отличное от проверки на None # больше соответствующее вашей задаче. Возможно, вам просто подойдет # какое-то значение по умолчанию. if b is None: pass else: pass # . a = a() # b будет равно None по умолчанию b = a(42) # b будет равно 42