Comment initialiser la (super) classe de base?
class SuperClass(object):
def __init__(self, x):
self.x = x
class SubClass(SuperClass):
def __init__(self, y):
self.y = y
Utilisez un super
objet pour vous assurer d'obtenir la méthode suivante (en tant que méthode liée) dans l'ordre de résolution de la méthode. Dans Python 2, vous devez passer le nom de la classe et self
à super pour rechercher la __init__
méthode liée :
class SubClass(SuperClass):
def __init__(self, y):
super(SubClass, self).__init__('x')
self.y = y
Dans Python 3, il y a un peu de magie qui rend les arguments super
inutiles - et comme avantage secondaire, cela fonctionne un peu plus vite:
class SubClass(SuperClass):
def __init__(self, y):
super().__init__('x')
self.y = y
Le codage en dur du parent comme celui-ci ci-dessous vous empêche d'utiliser l'héritage multiple coopératif:
class SubClass(SuperClass):
def __init__(self, y):
SuperClass.__init__(self, 'x') # don't do this
self.y = y
Notez que __init__
peut uniquement renvoyerNone
- il est destiné à modifier l'objet sur place.
Quelque chose __new__
Il existe un autre moyen d'initialiser les instances - et c'est le seul moyen pour les sous-classes de types immuables en Python. Il est donc nécessaire si vous souhaitez sous str
- classer ou tuple
ou un autre objet immuable.
Vous pourriez penser que c'est une méthode de classe car elle obtient un argument de classe implicite. Mais c'est en fait une méthode statique . Donc , vous devez appeler __new__
avec cls
explicitement.
Nous renvoyons généralement l'instance à partir de __new__
, donc si vous le faites, vous devez également appeler votre base __new__
via super
également dans votre classe de base. Donc, si vous utilisez les deux méthodes:
class SuperClass(object):
def __new__(cls, x):
return super(SuperClass, cls).__new__(cls)
def __init__(self, x):
self.x = x
class SubClass(object):
def __new__(cls, y):
return super(SubClass, cls).__new__(cls)
def __init__(self, y):
self.y = y
super(SubClass, self).__init__('x')
Python 3 évite un peu la bizarrerie des super appels causés par le fait d' __new__
être une méthode statique, mais vous devez toujours passer cls
à la __new__
méthode non liée :
class SuperClass(object):
def __new__(cls, x):
return super().__new__(cls)
def __init__(self, x):
self.x = x
class SubClass(object):
def __new__(cls, y):
return super().__new__(cls)
def __init__(self, y):
self.y = y
super().__init__('x')