Python: ¿Cómo hago una subclase de una superclase?

Question

En Python, ¿cómo se hace una subclase de una superclase?

Answer 1

class Subclass (SuperClass): 
     # Subclass stuff here 

Answer 2

class Class1(object): 
    pass 

class Class2(Class1): 
    pass 

Clase 2 es una sub-clase de Class1

Answer 3

que utilice:

class DerivedClassName(BaseClassName): 

Para más detalles, ver el Python docs, section 9.5.

Answer 4

class MySubClass(MySuperClass): 
    def __init__(self): 
     MySuperClass.__init__(self) 

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

El section on inheritance en la documentación de Python explica con más detalle

Answer 5

class Mammal(object): 
#mammal stuff 

class Dog(Mammal): 
#doggie stuff 

Answer 6

subclases en Python se realiza de la siguiente manera:

class WindowElement: 
    def print(self): 
     pass 

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

Aquí es una tutorial sobre Python que también contiene las clases y subclases.

Answer 7

Un poco heroico ejemplo:

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 __name__ == "__main__": 
    sm = SuperMan() 
    print sm.getName() 
    sm2 = SuperManII() 
    print sm2.getName() 

Answer 8

El uso de "super" (ver Python Built-in, super) puede ser un poco mejor método de llamar a los padres para la inicialización:

# Initialize using Parent 
# 
class MySubClass(MySuperClass): 
    def __init__(self): 
     MySuperClass.__init__(self) 

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

Answer 9

Hay otra manera de hacer las subclases en pitón de forma dinámica con una función type():

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

Por lo general, desea utilizar este método cuando trabaje con metaclases. Cuando quieres hacer algunas automatizaciones de nivel inferior, eso altera la forma en que python crea la clase. Lo más probable es que nunca necesites hacerlo de esta manera, pero cuando lo haces, entonces ya sabrás lo que estás haciendo.

Answer 10

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()) 

Answer 11

En las respuestas anteriores, el super se inicializa sin argumentos (palabra clave). A menudo, sin embargo, le gustaría hacer eso, así como transmitir algunos argumentos 'personalizados'. Este es un ejemplo que ilustra este caso de uso:

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 

Esta es una subclase de list que, cuando se inicializa, ordena inmediatamente en sí en la dirección especificada por el argumento reverse palabra clave, como los siguientes ensayos ilustran:

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 __name__ == "__main__": 
    pytest.main([__file__]) 

Gracias a la transferencia de *args a super, la lista se puede inicializar y completar con elementos en lugar de estar vacía. (Tenga en cuenta que reverse es un argumento de palabra clave solo de acuerdo con PEP 3102).