Python OOP — Private Methods & Private Variables

The Story That Explains Private Members 🏠Private Members समझाने वाली कहानी 🏠一个讲清私有成员的故事 🏠

The Problem — Python Makes Everything Public by Default 🚪समस्या — Python में डिफ़ॉल्ट रूप से सब Public है 🚪问题 — Python 默认一切都是公有的 🚪

When you write self.balance = 1000 in __init__, any caller can reach into the object and set acc.balance = -99999999. Nothing stops them. That is fine for a quick script, but for a real class it is a disaster.

जब आप __init__ में self.balance = 1000 लिखते हैं, तो कोई भी caller object में पहुँचकर acc.balance = -99999999 कर सकता है। कुछ नहीं रोकता। छोटी script के लिए ठीक है, पर असली class के लिए यह आफ़त है।

当你在 __init__ 里写 self.balance = 1000，任何调用方都能伸手进对象，设置 acc.balance = -99999999。没有东西能阻止。对小脚本无所谓，对真正的类却是灾难。

class BankAccount:
    def __init__(self, holder, balance):
        self.holder  = holder
        self.balance = balance         # public - anyone can touch it

acc = BankAccount("Alice", 1000)

# Nothing stops this - the whole class contract is gone
acc.balance = -99999999
print(acc.balance)                 # no validation, no history, no protection

One Underscore _protected — "Please Knock" 🚪एक Underscore _protected — "कृपया दस्तक दें" 🚪一个下划线 _protected — "请敲门" 🚪

A name that starts with one underscore (self._log, self._retries) tells every reader: "this is internal to the class — don't touch it from outside unless you know what you're doing." Python itself does nothing special: no renaming, no errors. It is a pure convention that the whole community respects.

एक underscore से शुरू होने वाला नाम (self._log, self._retries) हर पढ़ने वाले को बताता है: "यह class का अंदरूनी है — जब तक पता न हो, बाहर से न छुएँ।" Python ख़ुद कुछ ख़ास नहीं करता: न नाम बदलना, न errors। यह शुद्ध परंपरा है जिसे पूरा community मानता है।

以 一个下划线 开头的名字（self._log、self._retries）告诉每位读者："这是类的内部细节 — 除非你清楚自己在做什么，否则别从外部碰它。"Python 本身不做任何特殊处理：不改名，不报错。这纯粹是整个社区都遵守的约定。

class BankAccount:
    def __init__(self, holder, balance):
        self.holder   = holder         # public - okay to read/write
        self._log     = []             # protected - internal, but subclasses may extend it
        self._version = 1              # protected - internal bookkeeping

acc = BankAccount("Alice", 1000)

# You CAN still touch _log from outside - Python doesn't stop you...
print(acc._log)
print(acc.__dict__)                # no renaming: the names are stored as written

# ...but every Python developer reads "_log" as "internal - don't touch."

Two Underscores __private — Name Mangling Locks the Safe 🔒दो Underscores __private — Name Mangling तिजोरी बंद करता है 🔒两个下划线 __private — 名字改编锁上保险箱 🔒

A name that starts with two underscores (and does not end with two) triggers Python's name mangling. Inside the class, Python quietly renames self.__balance to self._BankAccount__balance. Anyone who tries the obvious acc.__balance from outside gets an AttributeError.

दो underscores से शुरू होने वाला नाम (जो दो पर ख़त्म न हो) Python की name mangling चालू करता है। Class के अंदर Python चुपचाप self.__balance का नाम self._BankAccount__balance कर देता है। बाहर से सीधा acc.__balance आज़माने वाले को AttributeError मिलता है।

以 两个下划线 开头（且不以两个下划线结尾）的名字会触发 Python 的 名字改编。在类内部，Python 悄悄把 self.__balance 改名为 self._BankAccount__balance。任何人从外部直接尝试 acc.__balance 都会得到 AttributeError。

class BankAccount:
    def __init__(self, holder, balance):
        self.holder    = holder
        self.__balance = balance       # private - Python will rename it
        self.__pin     = None          # private - this must never leak

    def show(self):
        # Inside the class, __balance works as expected
        print(f"{self.holder}: ${self.__balance}")

acc = BankAccount("Alice", 1000)
acc.show()

# -- The obvious access from outside FAILS --
try:
    print(acc.__balance)
except AttributeError as e:
    print("Blocked:", e)

# -- What Python actually did: it renamed the attribute --
print(acc.__dict__)

# -- You COULD still reach it by the mangled name, but everyone knows you are cheating --
print(acc._BankAccount__balance)

Public vs Protected vs Private — Three Access Levels 🚦Public बनाम Protected बनाम Private — तीन Access Levels 🚦公有、受保护与私有 — 三种访问级别 🚦

Three attributes on one BankAccount. Watch what happens when outside code tries each of them: public works at once, protected works with a "you shouldn't" warning, private fails with an AttributeError.

एक BankAccount पर तीन attributes। देखें कि बाहर का code हर एक को आज़माता है तो क्या होता है: public तुरंत चलता है, protected "नहीं करना चाहिए" की चेतावनी के साथ चलता है, private AttributeError से fail होता है।

一个 BankAccount 上有三个属性。看看外部代码逐个尝试时会发生什么：公有立即可用，受保护的能用但带着"不该这样"的警告，私有的直接 AttributeError。

🚦 Simulator: Access Tester🚦 Simulator: Access Tester🚦 模拟器：访问测试器

Try 11 expressions on acc = BankAccount("Alice", 1000, "1234") — the class from Section 08. The matching zone of the object lights up, and you see the real result or error.

acc = BankAccount("Alice", 1000, "1234") पर 11 expressions आज़माएँ — Section 08 की class। Object का मिलता-जुलता हिस्सा चमकता है, और आपको असली नतीजा या error दिखता है।

在 acc = BankAccount("Alice", 1000, "1234")（第 08 节的类）上尝试 11 个表达式。对象中对应的区域会亮起，并显示真实的结果或错误。

How Name Mangling Works 🔤Name Mangling कैसे काम करता है 🔤名字改编是怎样工作的 🔤

When Python compiles the class body, any name that starts with __ (and does not end with __) is rewritten. The rule is simple: add _ClassName in front. Inside the class, self.__balance and the mangled name are the same thing. From outside, only the mangled name works.

जब Python class body को compile करता है, तो हर वह नाम जो __ से शुरू हो (और __ पर ख़त्म न हो) दोबारा लिखा जाता है। नियम आसान है: आगे _ClassName जोड़ दो। Class के अंदर self.__balance और mangled नाम एक ही चीज़ हैं। बाहर से सिर्फ़ mangled नाम चलता है।

Python 编译类体时，任何以 __ 开头（且不以 __ 结尾）的名字都会被改写。规则很简单：在前面加上 _ClassName。在类内部，self.__balance 和改编后的名字是同一个东西；在外部，只有改编后的名字才有效。

class Report:
    def __init__(self):
        self.__init_done = True          # starts with __ but does not end with __ -> mangled

    def __str__(self):                   # dunder: begins AND ends with __ -> NOT mangled
        return "Report object"

r = Report()
print(r.__dict__)
print(str(r), r.__str__())               # dunders are normal, public names

🔤 Simulator: Name Mangler🔤 Simulator: Name Mangler🔤 模拟器：名字改编器

Type any class name and attribute name (or click a preset). The checker walks through Python's rule and shows the stored name, plus what happens from outside. It matched real Python on all 45 preset combinations — including odd cases like a class named ___.

कोई भी class नाम और attribute नाम लिखें (या preset दबाएँ)। Checker Python के नियम को क़दम-दर-क़दम चलाकर रखा गया नाम दिखाता है, और बाहर से क्या होता है वह भी। यह सभी 45 preset combinations पर असली Python से मिला — ___ नाम की class जैसे अजीब cases भी।

输入任意类名和属性名（或点击预设）。检查器按 Python 的规则一步步走，显示存储的名字，以及从外部访问时会怎样。它在全部 45 个预设组合上与真实 Python 一致 — 包括类名为 ___ 这样的特殊情况。

Private Methods — Helpers That Should Never Be Called From Outside 🧰Private Methods — ऐसे Helpers जिन्हें बाहर से कभी न बुलाया जाए 🧰私有方法 — 不应从外部调用的辅助方法 🧰

Everything about private variables applies to private methods too. A method whose name starts with __ is mangled exactly like an attribute. Use this to hide implementation details — checking, formatting, internal setup — that callers should never care about.

Private variables की हर बात private methods पर भी लागू होती है। __ से शुरू होने वाले method का नाम ठीक attribute की तरह mangle होता है। इसका इस्तेमाल उन अंदरूनी बातों को छिपाने में करें — जाँच, formatting, अंदरूनी setup — जिनसे callers को कोई मतलब नहीं होना चाहिए।

关于私有 变量 的一切同样适用于私有 方法。名字以 __ 开头的方法会像属性一样被改编。用它来隐藏实现细节 — 检查、格式化、内部设置 — 这些都是调用方不该关心的。

class User:
    def __init__(self, username, password):
        self.username = username
        self.__password_hash = self.__hash(password)   # uses a private method

    # -- Public API -------------------------------------
    def check_password(self, guess):
        return self.__password_hash == self.__hash(guess)

    # -- Private helper - never called from outside -----
    def __hash(self, s):
        # In real code you would use a proper hashing library. Toy here.
        return hex(hash(s))

alice = User("alice", "secret")
print(alice.check_password("secret"))
print(alice.check_password("guess"))

# Calling the private helper from outside -> AttributeError
try:
    alice.__hash("anything")
except AttributeError as e:
    print("Blocked:", e)

print("_User__hash" in dir(User))         # the method was renamed too

The output of hash() changes between runs, but the True / False results do not — the same text always matches itself within one run.

hash() का output हर run में बदलता है, पर True / False नतीजे नहीं बदलते — एक run के अंदर वही text हमेशा ख़ुद से मेल खाता है।

hash() 的输出每次运行都会变，但 True / False 的结果不变 — 在同一次运行中，相同的文本总是与自己匹配。

🧰 Simulator: Private Helpers Step by Step🧰 Simulator: Private Helpers क़दम-दर-क़दम🧰 模拟器：私有辅助方法逐步演示

Step through acc.withdraw(200, pin). Watch the public method open frames for the private helpers on the call stack, and watch the object's __dict__ hold the mangled names. Switch to the wrong PIN to see __verify() stop everything. Recorded with sys.settrace.

acc.withdraw(200, pin) को step करें। देखें कि public method call stack पर private helpers के frames खोलता है, और object का __dict__ mangled नाम रखता है। ग़लत PIN चुनें और देखें कि __verify() सब रोक देता है। sys.settrace से रिकॉर्ड।

逐步运行 acc.withdraw(200, pin)。看公有方法在调用栈上为私有辅助方法打开帧，再看对象的 __dict__ 保存的是 改编后 的名字。切换到错误的 PIN，看 __verify() 如何拦下一切。由 sys.settrace 记录。

Practical Example — BankAccount With a Private Balance and PIN 🏦व्यावहारिक उदाहरण — Private Balance और PIN वाला BankAccount 🏦实例 — 带私有余额和 PIN 的 BankAccount 🏦

A realistic small class that uses all three levels together: a public API, protected logging that subclasses may extend, and private state (balance, PIN) that only the class itself touches, through private helper methods.

एक छोटी, असली-जैसी class जो तीनों स्तर एक साथ इस्तेमाल करती है: public API, protected logging जिसे subclasses बढ़ा सकती हैं, और private state (balance, PIN) जिसे सिर्फ़ class ख़ुद, private helper methods के ज़रिए, छूती है।

一个贴近现实的小类，同时使用三种级别：公有 API、子类可扩展的受保护日志，以及只有类自己通过私有辅助方法才能触碰的私有状态（余额、PIN）。

class BankAccount:
    def __init__(self, holder, opening_balance, pin):
        if not BankAccount.__is_valid_pin(pin):
            raise ValueError("PIN must be 4 digits")
        self.holder    = holder            # public - the customer's name
        self._log      = []                # protected - subclasses may extend
        self.__balance = opening_balance   # private - the whole point of a bank
        self.__pin     = pin               # private - should NEVER leak

    # == PUBLIC API - the only entry points ==
    def deposit(self, amount, pin):
        self.__verify(pin)
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self.__balance += amount
        self.__log_txn("deposit", amount)

    def withdraw(self, amount, pin):
        self.__verify(pin)
        if amount > self.__balance:
            raise ValueError("Insufficient funds")
        self.__balance -= amount
        self.__log_txn("withdraw", amount)

    def get_balance(self, pin):
        # Even reading the balance requires the PIN
        self.__verify(pin)
        return self.__balance

    # == PRIVATE HELPERS - hidden implementation details ==
    def __verify(self, pin):
        if pin != self.__pin:
            raise PermissionError("Wrong PIN")

    def __log_txn(self, action, amount):
        self._log.append((action, amount))

    @staticmethod
    def __is_valid_pin(pin):
        return isinstance(pin, str) and len(pin) == 4 and pin.isdigit()


# -- Normal use - everything goes through the public API --
acc = BankAccount("Alice", opening_balance=1000, pin="1234")
acc.deposit(500, pin="1234")
acc.withdraw(200, pin="1234")
print("Balance:", acc.get_balance(pin="1234"))
print("Log:    ", acc._log)                    # protected - visible but internal

# -- Attempts to bypass the API --
try: acc.withdraw(100, pin="9999")
except PermissionError as e: print("Blocked:", e)   # wrong PIN

try: print(acc.__balance)
except AttributeError as e: print("Blocked:", e)    # direct read fails

try: acc.__verify("9999")
except AttributeError as e: print("Blocked:", e)    # the private helper cannot be called

try: BankAccount("Bob", 50, pin="12")
except ValueError as e: print("Blocked:", e)        # the private static check ran in __init__

The last line shows one more private helper at work: the static method __is_valid_pin (also mangled) rejects a 2-digit PIN inside __init__.

आख़िरी line एक और private helper को काम करते दिखाती है: static method __is_valid_pin (यह भी mangled) __init__ के अंदर 2 अंकों वाला PIN ठुकरा देता है।

最后一行展示了另一个私有辅助方法：静态方法 __is_valid_pin（同样被改编）在 __init__ 中拒绝了 2 位数的 PIN。

🏦 Simulator: Bank Vault🏦 Simulator: Bank Vault🏦 模拟器：银行金库

Use the public API with the right or wrong PIN. Then try the three tricks: write acc.__balance from outside, read it back, and cheat with the mangled name. The live __dict__ shows what really changes. Checked against the real class on 300 random sequences.

सही या ग़लत PIN के साथ public API इस्तेमाल करें। फिर तीन चालें आज़माएँ: बाहर से acc.__balance लिखें, उसे वापस पढ़ें, और mangled नाम से धोखा दें। Live __dict__ दिखाता है कि असल में क्या बदलता है। असली class से 300 random sequences पर जाँचा गया।

用正确或错误的 PIN 调用公有 API。然后试试三个把戏：从外部写 acc.__balance、再读回来、以及用改编后的名字作弊。实时的 __dict__ 显示真正改变了什么。已在 300 个随机序列上与真实类核对。

Public API vs Private Implementation — The Contract 🤝Public API बनाम Private Implementation — अनुबंध 🤝公有 API 与私有实现 — 契约 🤝

Common Mistakes (and Fixes) 🩹आम ग़लतियाँ (और उनके हल) 🩹常见错误（及修正）🩹

The obj.__attr = value trap, run for real:

obj.__attr = value वाला जाल, असली run में:

obj.__attr = value 陷阱的真实运行：

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

acc = BankAccount(1000)
acc.__balance = 0                  # outside the class: NO mangling happens here
print(acc.__dict__)                # a brand-new attribute named literally "__balance"
print(acc._BankAccount__balance)   # the real balance is untouched

🩺 Simulator: Bug Doctor🩺 Simulator: Bug Doctor🩺 模拟器：Bug 医生

Four of these mistakes, run for real. Buggy code on the left, fixed code on the right, changed lines marked. Two of them give no error — just a wrong or unsafe result.

इनमें से चार ग़लतियाँ, असली run में। बाईं ओर buggy code, दाईं ओर ठीक किया हुआ, बदली lines चिह्नित। इनमें से दो कोई error नहीं देतीं — बस ग़लत या असुरक्षित नतीजा।

其中四个错误的真实运行。左边是有 bug 的代码，右边是修正后的代码，改动的行已标出。其中两个 不报错 — 只是结果错误或不安全。

Quick Reference 📋Quick Reference 📋速查表 📋

Golden Rules and Quiz 🏆सुनहरे नियम और Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题