KAHIBARO Bookshelves
Discord Login Register

13.5. کپسوله‌سازی

مفهوم کپسوله‌سازی در عمل

کپسوله‌سازی (Encapsulation) یکی از ایده‌های مهم در برنامه‌نویسی شی‌گرا است که روی «پنهان کردن جزئیات داخلی» و «کنترل دسترسی» به داده‌ها تمرکز دارد. در این بخش فرض می‌کنیم با مفهوم کلی کلاس، شیء، ویژگی و متد آشنا هستید و فقط روی خود کپسوله‌سازی تمرکز می‌کنیم.

ایدهٔ اصلی کپسوله‌سازی

کپسوله‌سازی یعنی:

  • داده‌ها (ویژگی‌ها) و رفتارها (متدها) در یک کلاس کنار هم قرار بگیرند.
  • از بیرون کلاس، فقط بخش‌های لازم قابل دسترسی باشند.
  • تغییرات داخلی کلاس، کم‌ترین اثر را روی بقیهٔ برنامه بگذارد.

به زبان ساده: «کاربر کلاس باید بداند چطور از کلاس استفاده کند، نه این‌که داخل آن دقیقاً چه می‌گذرد».

در پایتون سیستم «دسترسی سخت‌گیرانه» مثل بعضی زبان‌ها (مثل جاوا) ندارد، اما الگوها و قراردادهایی دارد که با استفاده از آن‌ها می‌توانیم به کپسوله‌سازی نزدیک شویم.

نام‌گذاری ویژگی‌ها برای کنترل دسترسی

پایتون سطح دسترسی رسمی مثل public و private ندارد، اما با نام‌گذاری می‌توانیم منظور خودمان را منتقل کنیم.

۱. ویژگی‌های عمومی (Public)

نام عادی بدون خط زیر (_) در ابتدا:

python
class Person:
    def __init__(self, name, age):
        self.name = name      # عمومی
        self.age = age        # عمومی
  • انتظار می‌رود از بیرون کلاس مستقیماً به آن‌ها دسترسی داشته باشیم:
python
  p = Person("Ali", 20)
  print(p.name)
  p.age = 21

۲. ویژگی‌های «داخلی» (با یک زیرخط `_`)

پیش‌وند یک خط زیر: _
این یعنی «این ویژگی برای استفادهٔ داخلی کلاس است، نه برای استفادهٔ مستقیم بیرون».

python
class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner        # عمومی
        self._balance = balance   # داخلی (protected به‌صورت قراردادی)
  • پایتون از لحاظ فنی دسترسی را محدود نمی‌کند:
python
  acc = BankAccount("Sara", 1000)
  print(acc._balance)   # از نظر فنی می‌شود، اما توصیه نمی‌شود
  • این یک «قرارداد» بین برنامه‌نویسان است؛ یعنی: اگر _ دیدی، مستقیم دست نزن مگر این‌که دقیقاً بدانی چه می‌کنی.

۳. ویژگی‌های «تقریباً خصوصی» (با دو زیرخط `__`)

پیش‌وند دو خط زیر: __
این کار باعث «name mangling» می‌شود؛ یعنی نام ویژگی در داخل کلاس تغییر داده می‌شود تا به‌طور تصادفی از بیرون به آن دسترسی پیدا نشود.

python
class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance   # تقریباً خصوصی
acc = BankAccount("Sara", 1000)
print(acc.owner)        # مشکلی نیست
# print(acc.__balance)  # خطا می‌دهد

پایتون نام __balance را داخل کلاس به چیزی شبیه _BankAccount__balance تبدیل می‌کند.
از بیرون می‌توان با این نام طولانی به آن رسید، اما این کار اصلاً توصیه نمی‌شود و فقط برای درک مکانیزم مهم است.

python
print(acc._BankAccount__balance)  # از لحاظ فنی ممکن است، ولی کار درستی نیست

هدف: جلوگیری از دسترسی اتفاقی، نه قفل کردن کامل.

چرا بهتر است داده‌ها را مستقیماً در دسترس نگذاریم؟

فرض کنید کلاس BankAccount داشته باشیم:

python
class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

از بیرون:

python
acc = BankAccount("Ali", 1000)
acc.balance = -5000  # منطقی نیست، ولی امکان‌پذیر است!

اینجا:

  • هیچ کنترلی روی مقدار balance نداریم.
  • هر کسی می‌تواند هر مقداری بگذارد، حتی مقدار نامعتبر.

با کپسوله‌سازی، دادهٔ «حساس» را مخفی می‌کنیم و فقط از طریق متدهای کنترل‌شده اجازهٔ تغییر می‌دهیم.

کپسوله‌سازی با متدهای کنترل‌شده (getter / setter ساده)

روش متداول: ویژگی را مخفی می‌کنیم و متدهایی برای خواندن و تغییر آن می‌نویسیم.

python
class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance   # مخفی
    def get_balance(self):
        return self.__balance
    def deposit(self, amount):
        if amount <= 0:
            print("مبلغ واریزی باید مثبت باشد.")
            return
        self.__balance += amount
    def withdraw(self, amount):
        if amount <= 0:
            print("مبلغ برداشت باید مثبت باشد.")
            return
        if amount > self.__balance:
            print("موجودی کافی نیست.")
            return
        self.__balance -= amount

استفاده:

python
acc = BankAccount("Ali", 1000)
acc.deposit(500)          # افزایش کنترل‌شده
print(acc.get_balance())  # خواندن موجودی
acc.withdraw(3000)        # پیام خطا، بدون خراب کردن وضعیت داخلی

مزیت‌ها:

  • نمی‌توانیم بدون کنترل، موجودی را تغییر دهیم.
  • قوانین کسب‌وکار (مثلاً جلو گیری از موجودی منفی) داخل کلاس «کپسوله» شده‌اند.
  • اگر بعداً بخواهیم نحوهٔ محاسبهٔ موجودی را عوض کنیم، بقیهٔ کد نیازی به تغییر ندارد؛ فقط داخل کلاس را ویرایش می‌کنیم.

استفاده از `property` برای دسترسی شبیه ویژگی، با کنترل داخلی

بعضی وقت‌ها نمی‌خواهیم همیشه get_... و set_... صدا بزنیم؛ در عین حال می‌خواهیم کنترل داشته باشیم.
در پایتون می‌توانیم از @property استفاده کنیم.

یک مثال ساده با `property`

python
class Person:
    def __init__(self, name, age):
        self.name = name        # عمومی
        self.__age = age        # مخفی
    @property
    def age(self):
        # این متد مثل یک ویژگی خوانده می‌شود
        return self.__age
    @age.setter
    def age(self, value):
        # این متد هنگام تنظیم مقدار فراخوانی می‌شود
        if value < 0:
            print("سن نمی‌تواند منفی باشد.")
        else:
            self.__age = value

استفاده:

python
p = Person("Sara", 20)
print(p.age)   # در ظاهر شبیه ویژگی است، در واقع متد @property صدا زده می‌شود
p.age = 25     # در ظاهر انتساب عادی است، در واقع age.setter اجرا می‌شود
p.age = -5     # پیام خطا، مقدار تغییر نمی‌کند

اینجا:

  • کد بیرون کلاس، مثل قبل و ساده از p.age استفاده می‌کند.
  • اما در پشت صحنه، ما کنترل کامل روی مقدار داریم.
  • اگر بعداً بخواهیم منطق را عوض کنیم (مثلاً تبدیل سال به ماه و ...)، می‌توانیم فقط داخل کلاس را تغییر دهیم، بدون این‌که کد جاهای دیگر را دست بزنیم.

کپسوله‌سازی در سطح متدها

تا این‌جا بیشتر دربارهٔ «ویژگی‌ها» صحبت کردیم، اما متدها هم می‌توانند «داخلی» باشند.

متدهای داخلی (با `_` و `__`)

گاهی متدی فقط برای کمک به بقیهٔ متدهای کلاس است و قرار نیست مستقیماً از بیرون فراخوانی شود.

python
class TextProcessor:
    def __init__(self, text):
        self.text = text
    def _normalize_spaces(self, s):
        # متد داخلی کمکی
        return " ".join(s.split())
    def clean(self):
        # متد عمومی
        cleaned = self._normalize_spaces(self.text)
        return cleaned.strip().lower()
  • فراخوانی پیشنهادی از بیرون:
python
  tp = TextProcessor("  Salam   DonyA  ")
  print(tp.clean())       # استفاده از متد عمومی
  • هرچند می‌شود tp._normalize_spaces(...) را صدا زد، اما طبق قرارداد «نباید» این کار را بکنیم، چون این متد برای استفادهٔ داخلی است.

اگر بخواهیم از name mangling استفاده کنیم:

python
class TextProcessor:
    def __init__(self, text):
        self.text = text
    def __normalize_spaces(self, s):
        return " ".join(s.split())
    def clean(self):
        cleaned = self.__normalize_spaces(self.text)
        return cleaned.strip().lower()

از بیرون:

python
tp = TextProcessor("  Salam   DonyA  ")
print(tp.clean())
# tp.__normalize_spaces("  hi  ")  # خطا

این کار دسترسی «اتفاقی» از بیرون را سخت‌تر می‌کند.

مزیت‌های عملی کپسوله‌سازی

خلاصهٔ مزیت‌ها در کد واقعی:

  1. جلوگیری از خراب شدن داده‌ها
    • با متدهای کنترل‌شده، جلوی مقدارهای نامعتبر را می‌گیریم (مثل سن منفی، موجودی منفی و ...).
  2. تغییر راحت‌تر و بدون شکستن کدهای دیگر
    • اگر منطق داخلی عوض شود (مثل فرمول محاسبهٔ مالیات)، لازم نیست همهٔ جاهایی که از کلاس استفاده می‌کنند را تغییر دهیم، چون آن‌ها فقط از متدهای عمومی استفاده می‌کنند.
  3. استفادهٔ ساده‌تر برای دیگران
    • کاربران کلاس فقط متدها و ویژگی‌های عمومی را می‌بینند و لازم نیست درگیر جزئیات داخلی شوند.
  4. ساخت «رابط» (Interface) تمیز
    • کلاس می‌تواند چند متد عمومی و واضح داشته باشد که نشان می‌دهد «با من چطور کار کن»، و بقیهٔ متدها/ویژگی‌ها پنهان بمانند.

یک مثال جمع‌بندی: کلاس دما با کنترل واحد

در این مثال، دما را داخلی به صورت سلسیوس نگه می‌داریم، اما اجازه می‌دهیم کاربر با سلسیوس یا فارنهایت کار کند، بدون این‌که بداند داخل چه می‌شود.

python
class Temperature:
    def __init__(self, celsius):
        self.__celsius = celsius   # دمای داخلی همیشه در سلسیوس است
    @property
    def celsius(self):
        return self.__celsius
    @celsius.setter
    def celsius(self, value):
        self.__celsius = value
    @property
    def fahrenheit(self):
        # تبدیل سلسیوس به فارنهایت
        return self.__celsius * 9 / 5 + 32
    @fahrenheit.setter
    def fahrenheit(self, value):
        # تبدیل فارنهایت به سلسیوس
        self.__celsius = (value - 32) * 5 / 9

استفاده:

python
t = Temperature(0)
print(t.celsius)      # 0
print(t.fahrenheit)   # 32.0
t.fahrenheit = 212    # تنظیم با فارنهایت
print(t.celsius)      # 100.0

در این‌جا:

  • دادهٔ واقعی (سلسیوس) در کلاس کپسوله شده است.
  • کاربر می‌تواند با دو «رابط» (celsius و fahrenheit) کار کند، بدون دانستن جزئیات تبدیل.

نکاتی برای تمرین کپسوله‌سازی

برای تمرین:

  • کلاسی بسازید که اطلاعات دانشجو را نگه دارد:
    • نام (عمومی)
    • شمارهٔ دانشجویی (عمومی)
    • نمره‌ها (مخفی)
    • متدی برای افزودن نمره با کنترل این‌که بین ۰ و ۲۰ باشد.
    • متدی برای محاسبهٔ میانگین.
  • کلاس «محصول فروشگاه» بسازید:
    • قیمت را به‌صورت مخفی نگه دارید.
    • فقط قیمت‌های مثبت قبول کنید.
    • ویژگی‌ای (property) برای نمایش قیمت با مالیات (مثلاً ۹٪) اضافه کنید.

در حین طراحی، همیشه بپرسید:

«کدام قسمت‌ها باید برای بقیهٔ برنامه قابل دیدن باشد و کدام‌ها فقط برای استفادهٔ داخلی این کلاس است؟»

پاسخ به این سؤال، شما را به سمت کپسوله‌سازی خوب راهنمایی می‌کند.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

Where to Move

Move chapter:

  • ☰ 1. فصل ۱: برنامه‌نویسی چیست؟
    • ☰ 1.1. برنامهٔ کامپیوتری چیست؟
      • ☰ 1.2. پایتون چیست؟
        • ☰ 1.3. پایتون کجا استفاده می‌شود؟
          • ☰ 1.4. چگونه برنامه‌نویسی به حل مسائل کمک می‌کند
            • ☰ 1.5. اولین برنامهٔ پایتون شما
            • ☰ 2. فصل ۲: راه‌اندازی پایتون
              • ☰ 2.1. نصب پایتون (ویندوز / macOS / لینوکس)
                • ☰ 2.2. استفاده از پایتون در ترمینال
                  • ☰ 2.3. استفاده از یک IDE (IDLE / VS Code)
                    • ☰ 2.4. اجرای اسکریپت‌های پایتون
                      • ☰ 2.5. حالت تعاملی پایتون
                      • ☰ 3. فصل ۳: متغیرها و انواع داده
                        • ☰ 3.1. متغیر چیست؟
                          • ☰ 3.2. ایجاد متغیرها
                            • ☰ 3.3. اعداد (`int`، `float`)
                              • ☰ 3.4. متن (`str`)
                                • ☰ 3.5. مقادیر بولی (`True`، `False`)
                                  • ☰ 3.6. بررسی نوع داده با `type()`
                                  • ☰ 4. فصل ۴: عملیات پایه
                                    • ☰ 4.1. عملیات حسابی
                                      • ☰ 4.2. کار با اعداد
                                        • ☰ 4.3. عملیات روی رشته‌ها
                                          • ☰ 4.4. ترکیب متن و متغیرها
                                            • ☰ 4.5. کامنت‌ها در پایتون
                                            • ☰ 5. فصل ۵: ورودی و خروجی کاربر
                                              • ☰ 5.1. دریافت ورودی از کاربر
                                                • ☰ 5.2. تبدیل ورودی به عدد
                                                  • ☰ 5.3. قالب‌بندی خروجی
                                                    • ☰ 5.4. نوشتن برنامه‌های تعاملی
                                                    • ☰ 6. فصل ۶: شرط‌ها (if / else)
                                                      • ☰ 6.1. عملگرهای مقایسه‌ای
                                                        • ☰ 6.2. عملگرهای منطقی
                                                          • ☰ 6.3. if، elif، else
                                                            • ☰ 6.4. شرط‌های تو در تو
                                                              • ☰ 6.5. اشتباهات رایج مبتدیان
                                                              • ☰ 7. فصل ۷: حلقه‌ها
                                                                • ☰ 7.1. چرا حلقه‌ها مفید هستند؟
                                                                  • ☰ 7.2. حلقه‌های while
                                                                    • ☰ 7.3. حلقه‌های for
                                                                      • ☰ 7.4. شمارنده‌های حلقه
                                                                        • ☰ 7.5. break و continue
                                                                          • ☰ 7.6. تمرین‌های حلقه
                                                                          • ☰ 8. فصل ۸: مجموعه‌های داده
                                                                            • ☰ 8.1. لیست‌ها (Lists)
                                                                              • ☰ 8.2. تاپل‌ها (Tuples)
                                                                                • ☰ 8.3. دیکشنری‌ها (Dictionaries)
                                                                                  • ☰ 8.4. مجموعه‌ها (Sets – مقدماتی)
                                                                                    • ☰ 8.5. انتخاب ساختار دادهٔ مناسب
                                                                                    • ☰ 9. فصل ۹: توابع
                                                                                      • ☰ 9.1. چرا توابع مهم هستند؟
                                                                                        • ☰ 9.2. تعریف توابع
                                                                                          • ☰ 9.3. پارامترها و آرگومان‌ها
                                                                                            • ☰ 9.4. مقادیر بازگشتی
                                                                                              • ☰ 9.5. محدودهٔ متغیرها (محلی در برابر سراسری)
                                                                                                • ☰ 9.6. استفادهٔ مجدد از کد
                                                                                                • ☰ 10. فصل ۱۰: کار با فایل‌ها
                                                                                                  • ☰ 10.1. فایل چیست؟
                                                                                                    • ☰ 10.2. خواندن فایل‌های متنی
                                                                                                      • ☰ 10.3. نوشتن و افزودن به فایل‌ها
                                                                                                        • ☰ 10.4. مسیر فایل‌ها
                                                                                                          • ☰ 10.5. برنامه‌های ساده مبتنی بر فایل
                                                                                                          • ☰ 11. فصل ۱۱: خطاها و اشکال‌زدایی
                                                                                                            • ☰ 11.1. انواع خطاها
                                                                                                              • ☰ 11.2. خواندن پیام‌های خطا
                                                                                                                • ☰ 11.3. خطاهای رایج مبتدیان
                                                                                                                  • ☰ 11.4. try و except
                                                                                                                    • ☰ 11.5. راهبردهای اشکال‌زدایی
                                                                                                                    • ☰ 12. فصل ۱۲: استفاده از کتابخانه‌های پایتون
                                                                                                                      • ☰ 12.1. کتابخانه چیست؟
                                                                                                                        • ☰ 12.2. وارد کردن ماژول‌ها
                                                                                                                          • ☰ 12.3. کتابخانه‌های استاندارد
                                                                                                                            • ☰ 12.3.1. math
                                                                                                                              • ☰ 12.3.2. random
                                                                                                                                • ☰ 12.3.3. datetime
                                                                                                                                • ☰ 12.4. نصب کتابخانه‌های خارجی با pip
                                                                                                                                • ☰ 13. فصل ۱۳: برنامه‌نویسی شی‌گرا (OOP)
                                                                                                                                  • ☰ 13.1. برنامه‌نویسی شی‌گرا چیست؟
                                                                                                                                    • ☰ 13.2. کلاس‌ها و اشیاء
                                                                                                                                      • ☰ 13.3. ویژگی‌ها و متدها
                                                                                                                                        • ☰ 13.4. متد `__init__`
                                                                                                                                          • ☰ 13.5. کپسوله‌سازی
                                                                                                                                            • ☰ 13.6. وراثت (مقدماتی)
                                                                                                                                              • ☰ 13.7. مثال‌های سادهٔ شی‌گرا
                                                                                                                                              • ☰ 14. فصل ۱۴: خودکارسازی با پایتون
                                                                                                                                                • ☰ 14.1. خودکارسازی چیست؟
                                                                                                                                                  • ☰ 14.2. خودکار کردن وظایف ساده
                                                                                                                                                    • ☰ 14.3. کار با فایل‌ها و پوشه‌ها
                                                                                                                                                      • ☰ 14.4. خودکارسازی پردازش متن
                                                                                                                                                        • ☰ 14.5. زمان‌بندی اجرای اسکریپت‌ها
                                                                                                                                                          • ☰ 14.6. مثال‌های کاربردی خودکارسازی
                                                                                                                                                          • ☰ 15. فصل ۱۵: توسعهٔ وب با پایتون
                                                                                                                                                            • ☰ 15.1. وب چگونه کار می‌کند؟ (نمای کلی)
                                                                                                                                                              • ☰ 15.2. آشنایی با Flask
                                                                                                                                                                • ☰ 15.3. ساخت یک وب‌سرور ساده
                                                                                                                                                                  • ☰ 15.4. مسیرها و قالب‌ها (Templates)
                                                                                                                                                                    • ☰ 15.5. پردازش ورودی کاربر (فرم‌ها)
                                                                                                                                                                      • ☰ 15.6. API های بسیار ساده
                                                                                                                                                                      • ☰ 16. فصل ۱۶: علم داده با پایتون
                                                                                                                                                                        • ☰ 16.1. علم داده چیست؟
                                                                                                                                                                          • ☰ 16.2. کار با داده‌ها
                                                                                                                                                                            • ☰ 16.3. آشنایی با NumPy
                                                                                                                                                                              • ☰ 16.4. آشنایی با pandas
                                                                                                                                                                                • ☰ 16.5. مصورسازی داده با matplotlib
                                                                                                                                                                                  • ☰ 16.6. مثال‌های سادهٔ تحلیل داده
                                                                                                                                                                                  • ☰ 17. فصل ۱۷: پروژه‌های کوچک
                                                                                                                                                                                    • ☰ 17.1. بازی حدس عدد
                                                                                                                                                                                      • ☰ 17.2. ماشین‌حساب ساده
                                                                                                                                                                                        • ☰ 17.3. فهرست کارها (To-Do List)
                                                                                                                                                                                          • ☰ 17.4. تولیدکنندهٔ رمز عبور
                                                                                                                                                                                            • ☰ 17.5. برنامهٔ آزمون (Quiz)
                                                                                                                                                                                              • ☰ 17.6. پروژهٔ کوچک وب یا داده
                                                                                                                                                                                              • ☰ 18. فصل ۱۸: گام‌های بعدی
                                                                                                                                                                                                • ☰ 18.1. چگونه پایتون را تمرین کنیم
                                                                                                                                                                                                  • ☰ 18.2. نوشتن کد تمیز و خوانا
                                                                                                                                                                                                    • ☰ 18.3. انتخاب یک حوزهٔ تخصصی
                                                                                                                                                                                                      • ☰ 18.3.1. توسعهٔ وب
                                                                                                                                                                                                        • ☰ 18.3.2. علم داده
                                                                                                                                                                                                          • ☰ 18.3.3. خودکارسازی
                                                                                                                                                                                                            • ☰ 18.3.4. توسعهٔ نرم‌افزار
                                                                                                                                                                                                            • ☰ 18.4. منابع یادگیری و انجمن‌ها
                                                                                                                                                                                                            • ☰ 19. پیوست
                                                                                                                                                                                                              • ☰ 19.1. برگهٔ تقلب دستور زبان پایتون
                                                                                                                                                                                                                • ☰ 19.2. خطاهای رایج و راه‌حل‌ها
                                                                                                                                                                                                                  • ☰ 19.3. واژه‌نامهٔ اصطلاحات