Super Python

Resumo : neste tutorial, você aprenderá como usar o Python super()para delegar à classe pai ao substituir métodos.

Introdução ao super Python

Primeiro, defina uma Employee classe :

class Employee:
    def __init__(self, name, base_pay, bonus):
        self.name = name
        self.base_pay = base_pay
        self.bonus = bonus

    def get_pay(self):
        return self.base_pay + self.bonusLinguagem de código:  Python  ( python )

A Employeeclasse tem três variáveis ​​de instância name ,, base_paye bonus. Também possui o get_pay()método que retorna o total de base_pay e bônus.

Segundo, defina a SalesEmployeeclasse que herda da Employeeclasse:

class SalesEmployee(Employee):
    def __init__(self, name, base_pay, bonus, sales_incentive):
        self.name = name
        self.base_pay = base_pay
        self.bonus = bonus
        self.sales_incentive = sales_incentive

    def get_pay(self):
        return self.base_pay + self.bonus + self.sales_incentiveLinguagem de código:  Python  ( python )

A SalesEmployeeclasse tem quatro variáveis ​​de instância name, base_pay, bonuse sales_incentive. Possui o get_pay()método que substitui o get_pay()método da Employeeclasse.

super().__init__()

O __init__()método da SalesEmployeeclasse possui algumas partes que são iguais às do __init__()método da Employeeclasse.

Para evitar duplicação, você pode chamar o __init__()método da Employeeclasse a partir do __init__()método da SalesEmployeeclasse.

Para referenciar a Employeeclasse na SalesEmployeeclasse, você usa o arquivo super(). O super()retorna uma referência da classe pai de uma classe filha.

O seguinte redefine a SalesEmployeeclasse que usa super()para chamar o __init__()método da Employeeclasse:

class SalesEmployee(Employee):
    def __init__(self, name, base_pay, bonus, sales_incentive):
        super().__init__(name, base_pay, bonus)
        self.sales_incentive = sales_incentive

    def get_pay(self):
        return self.base_pay + self.bonus + self.sales_incentiveLinguagem de código:  Python  ( python )

Quando você cria uma instância da SalesEmployeeclasse, Python executará o __init__()método na SalesEmployeeclasse. Por sua vez, este __init__()método chama o __init__()método da Employeeclasse para inicializar name, base_pay, e bonus.

Delegar para outros métodos na classe pai

O get_pay()método da SalesEmployeeclasse possui alguma lógica que já está definida no get_pay()método da Employeeclasse. Portanto, você pode reutilizar essa lógica no get_pay()método da SalesEmployeeclasse.

Para fazer isso, você pode chamar o get_pay()método da Employeeclasse no get_pay()método da SalesEmployeeclasse da seguinte forma:

class SalesEmployee(Employee):
    def __init__(self, name, base_pay, bonus, sales_incentive):
        super().__init__(name, base_pay, bonus)
        self.sales_incentive = sales_incentive

    def get_pay(self):
        return super().get_pay() + self.sales_incentiveLinguagem de código:  Python  ( python )

O seguinte chama o get_pay()método da Employeeclasse a partir do get_pay()método da SalesEmployeeclasse:

super().get_pay()Linguagem de código:  Python  ( python )

Quando você chama o get_pay()método de uma instância da SalesEmployeeclasse, ele chama o get_pay()método da classe pai ( Employee) e retorna a soma do resultado do super().get_pay()método com o sales_incentive.

Junte tudo

O seguinte mostra o código completo:

class Employee:
    def __init__(self, name, base_pay, bonus):
        self.name = name
        self.base_pay = base_pay
        self.bonus = bonus

    def get_pay(self):
        return self.base_pay + self.bonus


class SalesEmployee(Employee):
    def __init__(self, name, base_pay, bonus, sales_incentive):
        super().__init__(name, base_pay, bonus)
        self.sales_incentive = sales_incentive

    def get_pay(self):
        return super().get_pay() + self.sales_incentive


if __name__ == '__main__':
    sales_employee = SalesEmployee('John', 5000, 1000, 2000)
    print(sales_employee.get_pay())  # 8000Linguagem de código:  Python  ( python )

Resumo

• Use super()para chamar os métodos de uma classe pai de uma classe filha.