In questo tutorial, discuteremo il concetto di astrazione in Python per un approccio di programmazione orientato agli oggetti.
Essenzialmente, Abstraction si concentra sul nascondere all`utente le implementazioni interne di un processo o metodo. Pertanto, l`utente sa cosa sta facendo, ma non sa come viene svolto il lavoro.
& nbsp;
Cos`è l`astrazione in Python?
Ad esempio, le persone non pensano a un`auto come a un insieme di migliaia di singole parti. Invece, lo vedono come un oggetto ben definito con il suo comportamento unico. Questa astrazione consente alle persone di guidare un`auto senza essere consapevoli della complessità delle parti che la compongono. Possono ignorare i dettagli della trasmissione del motore e dei sistemi di frenatura. Invece, possono usare l`intero oggetto.
Un modo potente per manipolare l`astrazione e l`uso della classificazione gerarchica. Questo ci permette di stratificare la semantica di sistemi complessi, scomponendoli in parti più gestibili. All`esterno, l`auto è un oggetto unico. Una volta dentro, vedi che l`auto è composta da diversi sottosistemi: sterzo, freni, impianto audio, cinture di sicurezza, ecc. A loro volta, ognuno di questi sottosistemi è costituito da blocchi più piccoli.
Il punto è che guidiamo un`auto (o qualsiasi altro sistema complesso) utilizzando astrazioni gerarchiche.
Questo può essere applicato anche a programmi per computer che utilizzano concetti OOP. Questa è l`essenza della programmazione orientata agli oggetti.
Classi e metodi astratti in Python
Per dichiarare una classe astratta, dobbiamo prima importare il modulo abc . Diamo un`occhiata a un esempio.
da abc import ABC class abs_class (ABC): metodi #abstract
Qui abs_class &è un abstract classe all`interno della quale possono essere definiti metodi astratti o qualsiasi altro metodo.
Come proprietà, le classi astratte possono avere un numero qualsiasi di metodi astratti, coesistenti con qualsiasi numero di altri metodi. Ad esempio, possiamo vedere di seguito.
from abc import ABC, classe abstractmethod abs_class (ABC): #normal method def method (self): # definizione del metodo @abstractmethod def Abs_method (auto): #Abs_method definizione
Qui method() &metodo normale, mentre Abs_method() &un metodo astratto che implementa @abstractmethod dal modulo abc.
Esempio
Ora che conosciamo classi e metodi astratti, diamo un`occhiata a un esempio.
from abc import ABC, abstractmethod class Absclass (ABC): def print (self, x): print ("Valore passato:", x) @abstractmethod def task (self): print ("Siamo all`interno dell`attività di classe_test") classe test_class (Absclass): def attività (self): print ("Siamo all`interno dell`attività di classe_test") classe esempio_classe (Absclass): def attività (self ): print ("Siamo all`interno dell`attività di classe_esempio") #oggetto di classe_test creato oggetto_test = classe_test () oggetto_test.task () oggetto_test.print (100) #oggetto di classe_esempio creato ex oggetto_ample = classe_esempio () oggetto_esempio.task ( ) example_obj .print (200) print ("test_obj è un`istanza di Absclass?", isinstance (test_obj, Absclass)) print ("example_obj è un`istanza di Absclass?", isinstance (example_obj, Absclass)) Output:
dove,
task() e il metodo print() che sono visibili all`utente. Le altre due classi ereditate da questa classe astratta sono &queste sono class_test e class_example . Entrambi hanno il proprio metodo task() (un`estensione del metodo astratta).
Dopo che l`utente ha creato oggetti dalle classi test_class ed example_class e ha chiamato il metodo task() per entrambi, entrano in gioco le definizioni del metodo nascosto task() all`interno di entrambe le classi. Queste definizioni sono nascoste all`utente. Il metodo astratto task() dalla classe astratta Absclass non viene mai effettivamente chiamato.
Ma quando print() viene chiamato come per test_obj e example_obj, il metodo print() viene chiamato perché non è un metodo astratto.
Nota: non possiamo istanziare una classe astratta . Ciò provoca un errore.