L'ereditarietà è un aspetto importante del paradigma orientato agli oggetti. L'ereditarietà fornisce la riusabilità del codice al programma perché possiamo utilizzare una classe esistente per creare una nuova classe invece di crearla da zero.
Nell'ereditarietà, la classe figlia acquisisce le proprietà e può accedere a tutti i membri dati e alle funzioni definiti nella classe genitore. Una classe figlia può anche fornire la sua implementazione specifica alle funzioni della classe genitore. In questa sezione del tutorial discuteremo in dettaglio l'ereditarietà.
educazione shloka mehta
In Python, una classe derivata può ereditare la classe base semplicemente menzionando la base tra parentesi dopo il nome della classe derivata. Considera la seguente sintassi per ereditare una classe base nella classe derivata.
Sintassi
class derived-class(base class):
Una classe può ereditare più classi menzionandole tutte all'interno della parentesi. Considera la seguente sintassi.
Sintassi
class derive-class(, , ..... ):
Esempio 1
class Animal: def speak(self): print('Animal Speaking') #child class Dog inherits the base class Animal class Dog(Animal): def bark(self): print('dog barking') d = Dog() d.bark() d.speak()
Produzione:
dog barking Animal Speaking
Eredità multilivello di Python
L'ereditarietà multilivello è possibile in Python come altri linguaggi orientati agli oggetti. L'ereditarietà multilivello viene archiviata quando una classe derivata eredita un'altra classe derivata. Non esiste alcun limite al numero di livelli fino al quale l'eredità multilivello viene archiviata in Python.
La sintassi dell'ereditarietà multilivello è riportata di seguito.
Sintassi
class class1: class class2(class1): class class3(class2): . .
Esempio
class Animal: def speak(self): print('Animal Speaking') #The child class Dog inherits the base class Animal class Dog(Animal): def bark(self): print('dog barking') #The child class Dogchild inherits another child class Dog class DogChild(Dog): def eat(self): print('Eating bread...') d = DogChild() d.bark() d.speak() d.eat()
Produzione:
dog barking Animal Speaking Eating bread...
Python Ereditarietà multipla
Python ci fornisce la flessibilità necessaria per ereditare più classi base nella classe figlia.
Di seguito viene fornita la sintassi per eseguire l'ereditarietà multipla.
Sintassi
class Base1: class Base2: . . . class BaseN: class Derived(Base1, Base2, ...... BaseN):
Esempio
class Calculation1: def Summation(self,a,b): return a+b; class Calculation2: def Multiplication(self,a,b): return a*b; class Derived(Calculation1,Calculation2): def Divide(self,a,b): return a/b; d = Derived() print(d.Summation(10,20)) print(d.Multiplication(10,20)) print(d.Divide(10,20))
Produzione:
30 200 0.5
Il metodo issubclass(sub,sup).
Il metodo issubclass(sub, sup) viene utilizzato per verificare le relazioni tra le classi specificate. Restituisce vero se la prima classe è la sottoclasse della seconda classe, falso altrimenti.
Considera il seguente esempio.
Esempio
class Calculation1: def Summation(self,a,b): return a+b; class Calculation2: def Multiplication(self,a,b): return a*b; class Derived(Calculation1,Calculation2): def Divide(self,a,b): return a/b; d = Derived() print(issubclass(Derived,Calculation2)) print(issubclass(Calculation1,Calculation2))
Produzione:
True False
Il metodo isinstance (oggetto, classe).
Il metodo isinstance() viene utilizzato per verificare la relazione tra oggetti e classi. Restituisce vero se il primo parametro, ovvero obj, è l'istanza del secondo parametro, ovvero class.
Considera il seguente esempio.
Esempio
class Calculation1: def Summation(self,a,b): return a+b; class Calculation2: def Multiplication(self,a,b): return a*b; class Derived(Calculation1,Calculation2): def Divide(self,a,b): return a/b; d = Derived() print(isinstance(d,Derived))
Produzione:
True
Metodo prioritario
Possiamo fornire un'implementazione specifica del metodo della classe genitore nella nostra classe figlia. Quando il metodo della classe genitore è definito nella classe figlia con un'implementazione specifica, il concetto viene chiamato overriding del metodo. Potrebbe essere necessario eseguire l'override del metodo nello scenario in cui è necessaria la diversa definizione di un metodo della classe genitore nella classe figlia.
la sottostringa Java contiene
Considera il seguente esempio per eseguire l'override del metodo in Python.
Esempio
class Animal: def speak(self): print('speaking') class Dog(Animal): def speak(self): print('Barking') d = Dog() d.speak()
Produzione:
Barking
Esempio di vita reale di override del metodo
class Bank: def getroi(self): return 10; class SBI(Bank): def getroi(self): return 7; class ICICI(Bank): def getroi(self): return 8; b1 = Bank() b2 = SBI() b3 = ICICI() print('Bank Rate of interest:',b1.getroi()); print('SBI Rate of interest:',b2.getroi()); print('ICICI Rate of interest:',b3.getroi());
Produzione:
Bank Rate of interest: 10 SBI Rate of interest: 7 ICICI Rate of interest: 8
Astrazione dei dati in Python
L'astrazione è un aspetto importante della programmazione orientata agli oggetti. In Python possiamo anche nascondere i dati aggiungendo il doppio carattere di sottolineatura (___) come prefisso all'attributo che deve essere nascosto. Dopodiché l'attributo non sarà visibile all'esterno della classe attraverso l'oggetto.
Considera il seguente esempio.
Esempio
class Employee: __count = 0; def __init__(self): Employee.__count = Employee.__count+1 def display(self): print('The number of employees',Employee.__count) emp = Employee() emp2 = Employee() try: print(emp.__count) finally: emp.display()
Produzione:
The number of employees 2 AttributeError: 'Employee' object has no attribute '__count'