Python super() – Python 3 super()

class Person:
def __init__(self, name, age):
self.name = name
self.age = age

def display_info(self):
print(f”Name: {self.name}, Age: {self.age}”)

class Student(Person):
def __init__(self, name, age, student_id):
super().__init__(name, age)
self.student_id = student_id

def display_student_info(self):
super().display_info()
print(f”Student ID: {self.student_id}”)

# Example usage
student = Student(“John Doe”, 20, “ST12345”)
student.display_student_info()
“`

Python super

Para entender sobre a função super() em Python, é necessário compreender a Herança em Python. Na herança em Python, as subclasses herdam da superclasse. A função super() em Python nos permite referenciar a superclasse implicitamente, facilitando e tornando mais confortável nossa tarefa ao referenciar a superclasse a partir da subclasse. Assim, ao referenciar a superclasse da subclasse, não precisamos escrever explicitamente o nome da superclasse. Nas seções seguintes, discutiremos a função super() em Python.

Exemplo da função super() em Python

Primeiramente, observe o código a seguir que usamos em nosso tutorial sobre Herança em Python. No código de exemplo, a superclasse era Person e a subclasse era Student. O código é mostrado abaixo.

class Person:
    # inicializando as variáveis
    name = ""
    age = 0

    # definindo o construtor
    def __init__(self, person_name, person_age):
        self.name = person_name
        self.age = person_age

        # definindo os métodos da classe

    def show_name(self):
        print(self.name)

    def show_age(self):
        print(self.age)


# definição da subclasse começa aqui
class Student(Person):
    studentId = ""

    def __init__(self, student_name, student_age, student_id):
        Person.__init__(self, student_name, student_age)
        self.studentId = student_id

    def get_id(self):
        return self.studentId  # returns the value of student id


# fim da definição da subclasse


# Criar um objeto da superclasse
person1 = Person("Richard", 23)
# chamar os métodos membros dos objetos
person1.show_age()
# Criar um objeto da subclasse
student1 = Student("Max", 22, "102")
print(student1.get_id())
student1.show_name()

No exemplo acima, chamamos a função da classe pai como:

Person.__init__(self, student_name, student_age) 

Podemos substituir isso pela chamada da função super do Python, conforme abaixo.

super().__init__(student_name, student_age)

A saída permanecerá a mesma em ambos os casos, como mostrado na imagem abaixo.

Python 3 super

Observe que a sintaxe acima é para a função super do Python 3. Se você estiver nas versões Python 2.x, então é ligeiramente diferente e você terá que fazer as seguintes alterações:

class Person(object):
...
        super(Student, self).__init__(student_name, student_age)

A primeira alteração é ter object como a classe base para Person. É necessário usar a função super nas versões Python 2.x. Caso contrário, você receberá o seguinte erro.

Traceback (most recent call last):
  File "super_example.py", line 40, in <module>
    student1 = Student("Max", 22, "102")
  File "super_example.py", line 25, in __init__
    super(Student, self).__init__(student_name, student_age)
TypeError: must be type, not classobj

A segunda mudança está na sintaxe da própria função super. Como você pode ver, a função super do Python 3 é muito mais fácil de usar e a sintaxe também é mais limpa.

Função super do Python com herança multinível

Conforme mencionamos anteriormente, a função super() do Python nos permite referenciar a superclasse implicitamente. Mas, no caso de heranças multiníveis, a qual classe ela se referirá? Bem, a função super() do Python sempre se referirá à superclasse imediata. Além disso, a função super() do Python não apenas pode referenciar a função __init__(), mas também pode chamar todas as outras funções da superclasse. Portanto, no exemplo a seguir, veremos isso.

class A:
    def __init__(self):
        print('Initializing: class A')

    def sub_method(self, b):
        print('Printing from class A:', b)


class B(A):
    def __init__(self):
        print('Initializing: class B')
        super().__init__()

    def sub_method(self, b):
        print('Printing from class B:', b)
        super().sub_method(b + 1)


class C(B):
    def __init__(self):
        print('Initializing: class C')
        super().__init__()

    def sub_method(self, b):
        print('Printing from class C:', b)
        super().sub_method(b + 1)


if __name__ == '__main__':
    c = C()
    c.sub_method(1)

Vamos ver a saída do exemplo de herança multinível com super do Python 3 acima.

Initializing: class C
Initializing: class B
Initializing: class A
Printing from class C: 1
Printing from class B: 2
Printing from class A: 3

Portanto, a partir da saída, podemos ver claramente que a função __init__() da classe C foi chamada primeiro, depois a classe B e, após isso, a classe A. Algo semelhante aconteceu ao chamar a função sub_method().

Por que precisamos da função super do Python

Se você tem experiência prévia na linguagem Java, então você deve saber que a classe base também é chamada por um objeto super lá. Portanto, esse conceito é realmente útil para os programadores. No entanto, o Python também mantém a facilidade para o programador usar o nome da superclasse para se referir a elas. E, se seu programa contém herança de vários níveis, então essa função super() é útil para você. Então, isso é tudo sobre a função super do Python. Espero que você tenha entendido esse tópico. Por favor, use a caixa de comentários para qualquer dúvida.

Você pode verificar o script completo do Python e mais exemplos de Python em nosso Repositório no GitHub.

Referência: Documentação Oficial