Abstraction का अर्थ है कि एक ऑब्जेक्ट क्या करता है यह दिखाना जबकि वह कैसे करता है यह छुपाना। आप एक सरल, स्थिर इंटरफेस के साथ इंटरैक्ट करते हैं और इसके पीछे की गड़बड़ व्यावहारिकता को अनदेखा करते हैं।
क्या बनाम कैसे
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 (समस्या को समझने से पहले बनाए गए) दोनों नुकसान पहुंचाते हैं। जो वास्तव में बदलता है उसे अमूर्त बनाएं।
यह क्यों महत्वपूर्ण है
Abstraction वह तरीका है जिससे आप जटिलता को नियंत्रित करते हैं: कॉलर्स पूरे subsystem के बजाय एक छोटे इंटरफेस के बारे में सोचते हैं।
यह कार्यान्वयन को स्वैप करने में सक्षम बनाता है — एक नया भुगतान प्रदाता जोड़ना एक वर्ग को छूता है, हर कॉलर को नहीं — जो लचीले, परीक्षण योग्य डिजाइन का आधार है।