Abstraction એટલે એક object શું કરે છે તે દર્શાવવું જ્યારે તે તે કેવી રીતે કરે છે તે છુપાવવું. તમે એક સરળ, સ્થિર ઇન્ટરફેસ સાથે ક્રિયાપ્રતિક્રિયા કરો છો અને તેની પાછળના જટિલ અમલીકરણને અવગણો છો.
શું વિરુદ્ધ કેવી રીતે
from abc import ABC, abstractmethod
class PaymentGateway(ABC): # the abstraction: "what"
@abstractmethod
def charge(self, amount): ... # callers only need this contract
class StripeGateway(PaymentGateway): # one "how"
def charge(self, amount):
# talk to Stripe's API, handle tokens, retries...
return f"charged {amount} via Stripe"
class PayPalGateway(PaymentGateway): # another "how"
def charge(self, amount):
return f"charged {amount} via PayPal"
def checkout(gateway: PaymentGateway, amount):
return gateway.charge(amount) # depends only on the abstraction
checkout ક્યારેય જાણતું નથી કે તે Stripe છે કે PayPal — તે ચાર્જ કરવાના વિચાર પર આધાર રાખે છે, વિગતો પર નહીં.
Abstraction વિરુદ્ધ encapsulation
તેઓ સંબંધિત પણ અલગ છે: encapsulation તેને સુરક્ષિત કરવા માટે સ્થિતિ છુપાવે છે; abstraction ઇન્ટરફેસને સરળ બનાવવા માટે જટિલતા છુપાવે છે. Encapsulation સુરક્ષા વિશે છે; abstraction શું બતાવવું તે વિશે છે.
ખતરો
Leaky abstractions (જ્યાં અમલીકરણની વિગતો બહાર આવે છે) અને અકાળે abstractions (તમે સમસ્યા સમજો તે પહેલાં બનાવવામાં આવ્યા હતા) બંને નુકસાન પહોંચાડે છે. જે સાચવી બદલાય તે abstractions બનાવો.
તે શા માટે મહત્વપૂર્ણ છે
Abstraction એ જટિલતાને નિયંત્રણમાં લેવાનો માર્ગ છે: કૉલરો સમગ્ર સબસિસ્ટમ ને બદલે એક નાના ઇન્ટરફેસ વિશે વિચાર કરે છે.
તે અમલીકરણો સ્વિચ કરવાનું સક્ષમ કરે છે — નવો ચુકવણી પ્રદાતા ઉમેરવો એક વર્ગને સ્પર્શ કરે છે, દરેક કૉલરને નહીં — જે લવચક, પરીક્ષણીય ડિઝાઇનનો આધાર છે.