Python super() – Python 3 super()

La funzione super() di Python ci permette di fare riferimento esplicito alla classe genitore. È utile nel caso di ereditarietà quando vogliamo chiamare le funzioni della classe genitore.

Python super

Per capire la funzione super di Python, è necessario conoscere l’ereditarietà in Python. Nell’ereditarietà in Python, le sottoclassi ereditano dalla superclasse. La funzione super() di Python ci permette di fare riferimento alla superclasse implicitamente. Quindi, Python super semplifica e rende più comodo il nostro compito. Mentre facciamo riferimento alla superclasse dalla sottoclasse, non dobbiamo scrivere esplicitamente il nome della superclasse. Nelle sezioni seguenti, discuteremo della funzione super di Python.

Esempio di funzione super di Python

Innanzitutto, date un’occhiata al seguente codice che abbiamo usato nel nostro tutorial sull’ereditarietà in Python. In quel codice di esempio, la superclasse era Person e la sottoclasse era Student. Quindi il codice è mostrato di seguito.

class Person:
    # inizializzazione delle variabili
    name = ""
    age = 0

    # definizione del costruttore
    def __init__(self, person_name, person_age):
        self.name = person_name
        self.age = person_age

        # definizione dei metodi della classe

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

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


# definizione della sottoclasse inizia qui
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


# fine della definizione della sottoclasse


# Creare un oggetto della superclasse
person1 = Person("Richard", 23)
# chiamare i metodi membri degli oggetti
person1.show_age()
# Creare un oggetto della sottoclasse
student1 = Student("Max", 22, "102")
print(student1.get_id())
student1.show_name()

Nell’esempio sopra, abbiamo chiamato la funzione della classe genitore come:

Person.__init__(self, student_name, student_age) 

Possiamo sostituire questo con una chiamata alla funzione super di python come mostrato di seguito.

super().__init__(student_name, student_age)

L’output rimarrà lo stesso in entrambi i casi, come mostrato nell’immagine qui sotto.

Python 3 super

Nota che la sintassi sopra è per la funzione super di python 3. Se sei su versioni di python 2.x, allora è leggermente diversa e dovrai fare le seguenti modifiche:

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

La prima modifica è avere object come classe di base per Person. È necessario utilizzare la funzione super nelle versioni di Python 2.x. Altrimenti, otterrai il seguente errore.

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

La seconda modifica è nella sintassi della funzione super stessa. Come puoi vedere, la funzione super di python 3 è molto più facile da usare e la sintassi è anche più pulita.

Funzione super di Python con ereditarietà a più livelli

Come abbiamo già detto in precedenza, la funzione super() di Python ci permette di fare riferimento alla superclasse implicitamente. Ma nel caso di ereditarietà a più livelli a quale classe farà riferimento? Beh, la funzione super() di Python farà sempre riferimento alla superclasse immediata. Inoltre, la funzione super() di Python non solo può fare riferimento alla funzione __init__() ma può anche chiamare tutte le altre funzioni della superclasse. Quindi, nell’esempio seguente, vedremo questo.

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)

Vediamo l’output dell’esempio super di Python 3 sopra con l’ereditarietà a più livelli.

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

Quindi, dall’output possiamo vedere chiaramente che la funzione __init__() della classe C è stata chiamata prima, quindi la classe B e dopo quella la classe A. La stessa cosa è successa chiamando la funzione sub_method().

Perché abbiamo bisogno della funzione super di Python

Se hai esperienza precedente nel linguaggio Java, allora dovresti sapere che la classe base è chiamata anche da un oggetto \texttt{super} là. Quindi, questo concetto è effettivamente utile per i programmatori. Tuttavia, Python mantiene anche la possibilità per il programmatore di utilizzare il nome della superclasse per fare riferimento ad esse. E, se il tuo programma contiene ereditarietà a più livelli, allora questa funzione \texttt{super()} ti sarà utile. Quindi, questo è tutto riguardo alla funzione super di Python. Spero che tu abbia capito questo argomento. Utilizza il riquadro dei commenti per eventuali domande.

Puoi controllare lo script completo di Python e altri esempi di Python dal nostro \textit{GitHub Repository}.

Riferimento: \textit{Documentazione Ufficiale}