web-dev-qa-db-fra.com

Python: Comment créer une sous-classe à partir d'une super-classe?

En Python, comment créer une sous-classe à partir d'une super-classe?

pythonclass
78
dave.j.lott
# Initialize using Parent
#
class MySubClass(MySuperClass):
    def __init__(self):
        MySuperClass.__init__(self)

Ou, mieux encore, l'utilisation de la fonction intégrée de Python, super() (voir la documentation Python 2 / Python ) peut être un méthode légèrement meilleure d’appel du parent pour l’initialisation:

# Better initialize using Parent (less redundant).
#
class MySubClassBetter(MySuperClass):
    def __init__(self):
        super(MySubClassBetter, self).__init__()

Ou, exactement la même chose que juste ci-dessus, sauf que vous utilisez la forme à argument zéro de super(), qui ne fonctionne que dans une définition de classe:

class MySubClassBetter(MySuperClass):
    def __init__(self):
        super().__init__()
82
thompsongunner

Un petit exemple héroïque:

class SuperHero(object): #superclass, inherits from default object
    def getName(self):
        raise NotImplementedError #you want to override this on the child classes

class SuperMan(SuperHero): #subclass, inherits from SuperHero
    def getName(self):
        return "Clark Kent"

class SuperManII(SuperHero): #another subclass
    def getName(self):
       return "Clark Kent, Jr."

if __== "__main__":
    sm = SuperMan()
    print sm.getName()
    sm2 = SuperManII()
    print sm2.getName()
61
ewall
class MySubClass(MySuperClass):
    def __init__(self):
        MySuperClass.__init__(self)

        # <the rest of your custom initialization code goes here>

La section sur l'héritage dans la python) l'explique plus en détail

36
Bryan Oakley
class Class1(object):
    pass

class Class2(Class1):
    pass

Class2 est une sous-classe de Class1

14
workmad3

Dans les réponses ci-dessus, le super est initialisé sans aucun argument (mot-clé). Cependant, vous aimeriez souvent le faire et transmettre vos propres arguments "personnalisés". Voici un exemple illustrant ce cas d'utilisation:

class SortedList(list):
    def __init__(self, *args, reverse=False, **kwargs):
        super().__init__(*args, **kwargs)       # Initialize the super class
        self.reverse = reverse
        self.sort(reverse=self.reverse)         # Do additional things with the custom keyword arguments

Il s'agit d'une sous-classe de list qui, une fois initialisée, se trie immédiatement dans la direction spécifiée par l'argument de mot clé reverse, comme l'illustrent les tests suivants:

import pytest

def test_1():
    assert SortedList([5, 2, 3]) == [2, 3, 5]

def test_2():
    SortedList([5, 2, 3], reverse=True) == [5, 3, 2]

def test_3():
    with pytest.raises(TypeError):
        sorted_list = SortedList([5, 2, 3], True)   # This doesn't work because 'reverse' must be passed as a keyword argument

if __== "__main__":
    pytest.main([__file__])

Merci à la transmission de *args à super, la liste peut être initialisée et renseignée avec des éléments au lieu d’être vide. (Notez que reverse est un argument composé uniquement de mots-clés conformément à PEP 3102 ).

7
Kurt Peek

Il existe un autre moyen de créer des sous-classes dans python de manière dynamique avec une fonction type():

SubClass = type('SubClass', (BaseClass,), {'set_x': set_x})  # Methods can be set, including __init__()

Vous souhaitez généralement utiliser cette méthode lorsque vous travaillez avec des métaclasses. Lorsque vous souhaitez effectuer des automatisations de niveau inférieur, cela modifie la manière dont python crée une classe. Très probablement, vous n'aurez jamais besoin de le faire de cette manière, mais lorsque vous le ferez, vous le ferez déjà. Sais ce que tu fais.

4
Pol
class Subclass (SuperClass):
      # Subclass stuff here
3
Wernsey

Tu utilises:

class DerivedClassName(BaseClassName):

Pour plus de détails, voir section Python docs, section 9.5 .

3
Reed Copsey
class Mammal(object): 
#mammal stuff

class Dog(Mammal): 
#doggie stuff
2
Chris Ballance
class BankAccount:

  def __init__(self, balance=0):
    self.balance = int(balance)

  def checkBalance(self): ## Checking opening balance....
    return self.balance

  def deposit(self, deposit_amount=1000): ## takes in cash deposit amount and updates the balance accordingly.
    self.deposit_amount = deposit_amount
    self.balance += deposit_amount
    return self.balance

  def withdraw(self, withdraw_amount=500): ## takes in cash withdrawal amount and updates the balance accordingly
    if self.balance < withdraw_amount: ## if amount is greater than balance return `"invalid transaction"`
        return 'invalid transaction'
    else:
      self.balance -= withdraw_amount
      return self.balance


class MinimumBalanceAccount(BankAccount): #subclass MinimumBalanceAccount of the BankAccount class

    def __init__(self,balance=0, minimum_balance=500):
        BankAccount.__init__(self, balance=0)
        self.minimum_balance = minimum_balance
        self.balance = balance - minimum_balance
        #print "Subclass MinimumBalanceAccount of the BankAccount class created!"

    def MinimumBalance(self):
        return self.minimum_balance

c = BankAccount()
print(c.deposit(50))
print(c.withdraw(10))

b = MinimumBalanceAccount(100, 50)
print(b.deposit(50))
print(b.withdraw(10))
print(b.MinimumBalance())
1
Antiomic

Le sous-classement dans Python se fait comme suit:

class WindowElement:
    def print(self):
        pass

class Button(WindowElement):
    def print(self):
        pass

Voici un tutoriel à propos de Python qui contient également des classes et des sous-classes.

0
dmeister