Python @property decorator

1. What is @property

The @property decorator allows a method to be accessed like an attribute while still providing controlled logic behind the scenes.

class Person:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

p = Person("Alice")
print(p.name)  # Alice

Transforms method calls into attribute-style access.

---

2. Encapsulation Using @property

class Product:
    def __init__(self, price):
        self._price = price

    @property
    def price(self):
        return self._price

item = Product(100)
print(item.price)

Prevents direct access to internal variables while still exposing data.

---

3. Read-Only Property

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

    @property
    def area(self):
        return 3.14 * self._radius ** 2

c = Circle(5)
print(c.area)

Computed properties behave like read-only attributes.

---

4. Using @property with Setter

class Employee:
    def __init__(self, salary):
        self._salary = salary

    @property
    def salary(self):
        return self._salary

    @salary.setter
    def salary(self, value):
        if value < 0:
            raise ValueError("Salary cannot be negative")
        self._salary = value

e = Employee(5000)
e.salary = 6000
print(e.salary)

Allows controlled updates with validation.

---

5. @property with Deleter

class Account:
    def __init__(self, balance):
        self._balance = balance

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

    @balance.deleter
    def balance(self):
        del self._balance

acc = Account(1000)
del acc.balance

Supports controlled deletion of attributes.

---

6. Computed Property Example

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    @property
    def area(self):
        return self.length * self.width

rect = Rectangle(10, 5)
print(rect.area)  # 50

Encapsulates derived data logic.

---

7. Difference: @property vs Normal Method

class User:
    def __init__(self, name):
        self._name = name

    def get_name(self):
        return self._name

    @property
    def name(self):
        return self._name

u = User("Bob")
print(u.get_name())  # Method call
print(u.name)        # Property access

@property improves readability and API design.

---

8. Enforcing Data Integrity

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature below absolute zero")
        self._celsius = value

Common pattern for safe state management.

---

9. Lazy Evaluation with @property

class DataLoader:
    def __init__(self):
        self._data = None

    @property
    def data(self):
        if self._data is None:
            print("Loading data...")
            self._data = [1, 2, 3]
        return self._data

loader = DataLoader()
print(loader.data)
print(loader.data)

Data is calculated only when required.

---

10. Enterprise-Style Implementation Example

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

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

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

account = BankAccount("Alice", 1000)
account.balance = 1500
print(account.balance)

Provides clean API, robust validation, and business-rule enforcement.

---

Summary

Feature	Purpose
@property	Access method as attribute
@setter	Controlled data update
@deleter	Controlled deletion
Encapsulation	Protects internal state
Lazy Computation	Improves performance

---