Python OOP — Properties, Getter, Setter & Deleter Explained

The Story That Explains Properties 🏦Properties समझाने वाली कहानी 🏦一个讲清属性（property）的故事 🏦

The Problem Properties Solve 🧩Properties कौन-सी समस्या हल करती हैं 🧩属性要解决的问题 🧩

There are three ways to let callers reach data in a class. Two of them have serious downsides. Properties are the third — and the reason they exist.

Callers को class के data तक पहुँचने देने के तीन तरीक़े हैं। दो में गंभीर कमियाँ हैं। Properties तीसरा तरीक़ा हैं — और इसी वजह से वे बनीं।

让调用方访问类中数据有三种方式。其中两种有严重缺点。属性是第三种 — 也是它存在的原因。

# -- Option 1: public attribute - unsafe --------------------
class BankAccount:
    def __init__(self, balance):
        self.balance = balance

acc = BankAccount(1000)
acc.balance = -999999              # nothing stops this - the class contract is gone
print("Option 1:", acc.balance)


# -- Option 2: Java-style getter/setter methods - wordy -------
class BankAccount:
    def __init__(self, balance):
        self._balance = balance

    def get_balance(self):
        return self._balance

    def set_balance(self, value):
        if value < 0:
            raise ValueError("Balance cannot be negative")
        self._balance = value

acc = BankAccount(1000)
print("Option 2:", acc.get_balance())   # works, but every read is a method call
acc.set_balance(1500)                   # works - but the API is wordy


# -- Option 3: @property - safe AND clean ---------------------
class BankAccount:
    def __init__(self, balance):
        self.balance = balance         # goes through the setter - automatic validation

    @property
    def balance(self):                 # getter
        return self._balance

    @balance.setter
    def balance(self, value):          # setter
        if value < 0:
            raise ValueError("Balance cannot be negative")
        self._balance = value

acc = BankAccount(1000)
print("Option 3:", acc.balance)        # looks like a plain attribute...
acc.balance = 1500                     # ...but the setter enforces the rules
try:
    acc.balance = -999999
except ValueError as e:
    print("Option 3 blocked:", e)

@property — The Getter 🟩@property — Getter 🟩@property — Getter（读取器）🟩

The @property decorator turns a method into a read-only attribute. Callers write obj.area, and Python quietly calls the method. A computed property like area stores nothing — its value is whatever the method returns.

@property decorator एक method को सिर्फ़ पढ़ने वाले attribute में बदल देता है। Callers obj.area लिखते हैं, और Python चुपचाप method बुलाता है। area जैसी computed property कुछ नहीं रखती — उसकी value वही है जो method लौटाता है।

@property 装饰器把一个方法变成 只读属性。调用方写 obj.area，Python 悄悄调用该方法。像 area 这样的计算属性什么都不存 — 它的值就是方法返回的结果。

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @property
    def area(self):
        # Computed on the fly - no stored attribute
        return 3.14159 * self._radius ** 2

    @property
    def circumference(self):
        return 2 * 3.14159 * self._radius

c = Circle(5)
print(c.radius)          # looks like an attribute
print(c.area)            # same syntax, but computed
print(c.circumference)

# Trying to write to a property that has no setter
try:
    c.area = 100
except AttributeError as e:
    print("Blocked:", e)

print(c.__dict__)        # only _radius is stored; area is computed each time

@x.setter — Checked Writes 🟧@x.setter — जाँच के साथ लिखना 🟧@x.setter — 带检查的写入 🟧

A property with only @property is read-only. To allow writes, add a matching @name.setter method. This is where validation lives: the setter catches every assignment and can reject a bad value before it touches the object.

सिर्फ़ @property वाली property सिर्फ़ पढ़ने के लिए होती है। लिखने देने के लिए मिलता-जुलता @name.setter method जोड़ें। जाँच यहीं रहती है: setter हर assignment पकड़ता है और ग़लत value को object तक पहुँचने से पहले ठुकरा सकता है।

只有 @property 的属性是 只读 的。要允许写入，就加一个对应的 @name.setter 方法。校验就放在这里：setter 拦截每一次赋值，可以在坏值碰到对象之前把它拒绝。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age  = age                   # goes THROUGH the setter

    @property
    def age(self):                        # GETTER
        return self._age

    @age.setter
    def age(self, value):                 # SETTER - same method name!
        if not isinstance(value, int):
            raise TypeError("age must be an int")
        if value < 0 or value > 150:
            raise ValueError("age must be 0..150")
        self._age = value

alice = Person("Alice", 30)
print(alice.age)               # getter runs

alice.age = 31                 # setter runs, passes validation
print(alice.age)

# -- Bad values are rejected AT THE SETTER, before touching the object --
try:
    alice.age = -5
except ValueError as e:
    print("Rejected:", e)

try:
    alice.age = "forty"
except TypeError as e:
    print("Rejected:", e)

print(alice.age)               # still 31 - the bad values never got in

🚧 Simulator: The Setter Gate🚧 Simulator: Setter Gate🚧 模拟器：Setter 关卡

Pick a value for alice.age = … (she starts at 30). Watch it pass — or fail — each check in the setter. Try True for a surprise. All 8 results are real.

alice.age = … के लिए कोई value चुनें (शुरू में 30 है)। देखें कि वह setter की हर जाँच में pass होती है — या fail। हैरानी के लिए True आज़माएँ। सभी 8 नतीजे असली हैं।

为 alice.age = … 选一个值（初始为 30）。看它通过 — 或没通过 — setter 中的每一项检查。试试 True，会有惊喜。全部 8 个结果都是真实的。

🎬 Simulator: The Setter Step by Step🎬 Simulator: Setter क़दम-दर-क़दम🎬 模拟器：Setter 逐步演示

Step through a real run. Notice that self.age = age inside __init__ opens the setter on the call stack, and print(alice.age) opens the getter. Switch to -5 to watch the setter reject the value. Recorded with sys.settrace.

एक असली run को step करें। ध्यान दें कि __init__ के अंदर self.age = age call stack पर setter खोलता है, और print(alice.age) getter खोलता है। -5 चुनें और setter को value ठुकराते देखें। sys.settrace से रिकॉर्ड।

逐步运行一次真实程序。注意 __init__ 里的 self.age = age 会在调用栈上打开 setter，print(alice.age) 会打开 getter。切换到 -5，看 setter 拒绝这个值。由 sys.settrace 记录。

@x.deleter — Custom Clean-Up on del obj.x 🟥@x.deleter — del obj.x पर अपनी साफ़-सफ़ाई 🟥@x.deleter — del obj.x 时的自定义清理 🟥

The third and least-used member of the trio. A deleter runs when a caller writes del obj.x. Use it when deleting should do more than just remove a value — reset to a default, close a connection, log out.

तिकड़ी का तीसरा और सबसे कम इस्तेमाल होने वाला सदस्य। Deleter तब चलता है जब caller del obj.x लिखता है। इसे तब इस्तेमाल करें जब delete करने पर value हटाने से ज़्यादा कुछ करना हो — default पर reset, connection बंद करना, log out।

三件套中第三个、也是最少用的成员。当调用方写 del obj.x 时，deleter 就会运行。当删除不只是移除一个值时使用它 — 重置为默认值、关闭连接、注销登录。

class Session:
    def __init__(self, token):
        self._token = token

    @property
    def token(self):
        return self._token

    @token.setter
    def token(self, value):
        if not isinstance(value, str) or len(value) < 8:
            raise ValueError("token must be a string of length ≥ 8")
        self._token = value

    @token.deleter
    def token(self):
        # Custom cleanup - logout, revoke, wipe
        print(f"Logging out session for token '{self._token[:4]}...'")
        self._token = None

s = Session("abc-secret-token")
print(s.token)

del s.token           # the deleter runs
print(s.token)

The Full Property Lifecycle — Get · Set · Delete 🔄पूरा Property Lifecycle — Get · Set · Delete 🔄属性的完整生命周期 — 读 · 写 · 删 🔄

One property name, three operations, three methods behind the scenes. Read (x = acc.balance) → the getter runs. Write (acc.balance = 100) → the setter runs. Delete (del acc.balance) → the deleter runs.

एक property नाम, तीन operations, पर्दे के पीछे तीन methods। पढ़ना (x = acc.balance) → getter चलता है। लिखना (acc.balance = 100) → setter चलता है। Delete (del acc.balance) → deleter चलता है।

一个属性名，三种操作，背后三个方法。读取（x = acc.balance）→ 运行 getter。写入（acc.balance = 100）→ 运行 setter。删除（del acc.balance）→ 运行 deleter。

Special Cases — Read-Only and Computed Properties 🔒ख़ास मामले — सिर्फ़ पढ़ने वाली और Computed Properties 🔒特殊情况 — 只读属性与计算属性 🔒

Not every property needs a getter, a setter and a deleter. Three common patterns:

हर property को getter, setter और deleter तीनों की ज़रूरत नहीं होती। तीन आम patterns:

并不是每个属性都需要 getter、setter 和 deleter。三种常见模式：

class Person:
    def __init__(self, first, last, birth_year):
        self.first       = first
        self.last        = last
        self._birth_year = birth_year

    # -- COMPUTED read-only property --
    @property
    def full_name(self):
        return f"{self.first} {self.last}"

    # -- READ-ONLY property (no setter) --
    @property
    def birth_year(self):
        return self._birth_year

    # -- COMPUTED from the year - no storage --
    @property
    def age(self, _year=2026):
        return _year - self._birth_year

alice = Person("Alice", "Roy", 1995)
print(alice.full_name)     # computed
print(alice.age)           # computed
print(alice.birth_year)

# Change one part -> the computed value updates automatically
alice.first = "Alicia"
print(alice.full_name)     # recomputed on the fly

# Read-only - trying to write fails
try:
    alice.birth_year = 1990
except AttributeError as e:
    print("Blocked:", e)

A note on age: Python calls a getter with self only, so _year always uses its default, 2026. The answer is right this year, but a real program would read the current year instead of hard-coding it.

age पर एक नोट: Python getter को सिर्फ़ self के साथ बुलाता है, इसलिए _year हमेशा अपना default, 2026, लेता है। इस साल जवाब सही है, पर असली program में साल hard-code करने की जगह मौजूदा साल पढ़ा जाना चाहिए।

关于 age 的说明：Python 调用 getter 时只传 self，所以 _year 总是使用默认值 2026。今年结果正确，但真实程序应该读取当前年份，而不是写死。

Practical Example 1 — Temperature With Two-Way Conversion 🌡️व्यावहारिक उदाहरण 1 — दोनों तरफ़ बदलने वाला Temperature 🌡️实例 1 — 双向换算的温度 🌡️

A classic use of properties: one stored value (celsius) and several views of it (fahrenheit, kelvin). Set fahrenheit and the stored celsius updates. Every write is checked against absolute zero.

Properties का एक क्लासिक इस्तेमाल: एक रखी हुई value (celsius) और उसके कई views (fahrenheit, kelvin)। Fahrenheit set करें और रखा हुआ celsius बदल जाता है। हर write absolute zero से जाँची जाती है।

属性的经典用法：一个存储的值（摄氏）和它的多种 视图（华氏、开尔文）。设置华氏，存储的摄氏随之更新。每次写入都会对照绝对零度检查。

class Temperature:
    def __init__(self, celsius=0):
        self.celsius = celsius        # goes through the setter - validated at creation

    # == CELSIUS: stored, with validation ==
    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError(f"{value}°C is below absolute zero")
        self._celsius = value

    @celsius.deleter
    def celsius(self):
        print("Resetting temperature to 0°C")
        self._celsius = 0

    # == FAHRENHEIT: two-way view of the underlying celsius ==
    @property
    def fahrenheit(self):
        return self._celsius * 9 / 5 + 32

    @fahrenheit.setter
    def fahrenheit(self, value):
        # Convert to celsius and reuse the celsius setter - validation reused!
        self.celsius = (value - 32) * 5 / 9

    # == KELVIN: read-only view of the underlying celsius ==
    @property
    def kelvin(self):
        return self._celsius + 273.15


t = Temperature(25)
print(f"{t.celsius}°C = {t.fahrenheit}°F = {t.kelvin}K")

# Write to fahrenheit -> celsius updates too (two-way sync)
t.fahrenheit = 100
print(f"{t.celsius:.2f}°C = {t.fahrenheit}°F = {t.kelvin:.2f}K")

# Validation is enforced through EITHER path
try:
    t.celsius = -300
except ValueError as e:
    print("Blocked:", e)

try:
    t.fahrenheit = -500            # reuses the celsius validation
except ValueError as e:
    print("Blocked:", e)

# Read-only kelvin cannot be assigned
try:
    t.kelvin = 400
except AttributeError as e:
    print("Blocked:", e)

del t.celsius                     # the deleter runs -> resets to 0
print(f"After reset: {t.celsius}°C")

🌡️ Simulator: The Temperature Router🌡️ Simulator: Temperature Router🌡️ 模拟器：温度路由器

Pick an operation and a value, then press Run. The method that fires lights up — getter, setter or deleter — and the thermometer shows the one stored number. Try writing −500 °F or assigning kelvin. Every output matched real Python on 300 random sequences.

कोई operation और value चुनें, फिर Run दबाएँ। जो method चलता है — getter, setter या deleter — वह चमकता है, और thermometer वह एक रखा हुआ नंबर दिखाता है। −500 °F लिखकर या kelvin assign करके देखें। हर output 300 random sequences पर असली Python से मिला।

选择操作和数值，然后按 Run。被触发的方法 — getter、setter 或 deleter — 会亮起，温度计显示那唯一存储的数字。试试写入 −500 °F，或给 kelvin 赋值。每个输出都在 300 个随机序列上与真实 Python 一致。

Practical Example 2 — BankAccount Balance With a Property 💰व्यावहारिक उदाहरण 2 — Property वाला BankAccount Balance 💰实例 2 — 用属性管理 BankAccount 余额 💰

class BankAccount:
    def __init__(self, holder, opening_balance):
        self.holder = holder
        self.balance = opening_balance    # goes THROUGH the setter
        self._log = []

    # -- Getter --
    @property
    def balance(self):
        return self._balance

    # -- Setter with full validation --
    @balance.setter
    def balance(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError("balance must be numeric")
        if value < 0:
            raise ValueError("balance cannot be negative")
        self._balance = float(value)

    # -- Deleter closes the account --
    @balance.deleter
    def balance(self):
        print(f"Closing {self.holder}'s account, final balance {self._balance}")
        del self._balance

    # -- Read-only COMPUTED property --
    @property
    def is_rich(self):
        return self._balance > 100_000

    # -- Read-only COMPUTED property --
    @property
    def tier(self):
        if self._balance >= 1_000_000: return "Platinum"
        if self._balance >= 100_000:   return "Gold"
        if self._balance >= 10_000:    return "Silver"
        return "Standard"


acc = BankAccount("Alice", 5000)
print(acc.balance, acc.tier, acc.is_rich)

acc.balance = 150_000                     # the setter validates, then stores
print(acc.balance, acc.tier, acc.is_rich)

# Validation catches junk
try: acc.balance = -100
except ValueError as e: print("Blocked:", e)

try: acc.balance = "a lot"
except TypeError as e: print("Blocked:", e)

# Computed properties are read-only
try: acc.tier = "Platinum"
except AttributeError as e: print("Blocked:", e)

# The deleter runs custom cleanup
del acc.balance
try: print(acc.balance)
except AttributeError as e: print("After delete:", e)

The last line shows what the deleter left behind: _balance is gone, so the getter has nothing to return.

आख़िरी line दिखाती है कि deleter के बाद क्या बचा: _balance हट गया, इसलिए getter के पास लौटाने को कुछ नहीं।

最后一行显示了 deleter 之后的状态：_balance 已被删除，所以 getter 没有可返回的值。

💰 Simulator: Account Tiers💰 Simulator: Account Tiers💰 模拟器：账户等级

Drag the balance or pick a preset. Each move is an assignment that runs the setter, and tier and is_rich are recomputed every time you read them. Try exactly 100,000. The red buttons try values the setter rejects.

Balance खिसकाएँ या कोई preset चुनें। हर बदलाव एक assignment है जो setter चलाता है, और tier व is_rich हर बार पढ़ने पर फिर से निकाले जाते हैं। ठीक 100,000 आज़माएँ। लाल buttons वे values आज़माते हैं जिन्हें setter ठुकराता है।

拖动余额或选择预设。每次变动都是一次赋值，会运行 setter；tier 和 is_rich 每次读取时都会重新计算。试试恰好 100,000。红色按钮尝试会被 setter 拒绝的值。

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

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

Five of these mistakes, run for real. Buggy code on the left, fixed code on the right, changed lines marked.

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

其中五个错误的真实运行。左边是有 bug 的代码，右边是修正后的代码，改动的行已标出。

Quick Reference 📋Quick Reference 📋速查表 📋

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

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