Encapsulation Hands-On: Advanced

This is a two-part blog series on Encapsulation in Python:

1. Encapsulation Hands-on: Basics
2. Encapsulation Hands-on: Advanced

It's recommended to go through the Basics first if you haven't already.

$\text{In python, we can manage how data inside the classes is accessed or modified by:}$

• Defining getter and setter methods manually
• Using the @property decorator to define methods that can be accessed like normal attributes
• Adding validation logic to ensure the data remains valid and consistent
• Defining whether an attribute should be read-only or allow changes

1. Manual Getter and Setters

it is common practice in many object-oriented languages like C++, Java, etc where we define getter and setter functions to access or update the private and protected variables, ensuring encapsulation and data validation.

$\text{Pros:}$

• Explicit control over how the data is accessed and modified.
• Easy to add validation logic inside set_balance.

$\text{Cons:}$

• Using methods for what feels like attribute access (kamesh_acc.get_balance() instead of kamesh_acc.balance)

2. Decorators

@Property, @<name>.setter and @<name>.deleter

These are part of python's descriptor protocol, and they allow you to encapsulate access, mutation, and deletion of attributes in a class.

2.1 @Property

This decorator allows you to define a method that can be accessed like an attribute. In other words, it lets you treat a method as if it were a regular variable.

$\textbf{Getter}$

$\textbf{Setter}$

$\textbf{Deleter}$

$\text{2.2 Time to Disect}$

$\text{What is going under the hood when using}$ @property $\text{decorator?}$

• The magic behind @property is a core python feature called Descriptor Protocol

  A "descriptor" is simply any object that defines `one or more` of these special methods:
  
    __get__(self, instance, owner): Defines what happens when you read/access the attribute.
    __set__(self, instance, value): Defines what happens when you write/assign to the attribute.
    __delete__(self, instance): Defines what happens when you del the attribute.
  

The @property decorator is nothing more than a simple and readable way to create a descriptor object and bind it to your class.

2.3 Let's trace the flow step by step:

class User:
  def __init__(self, email):
    self._email = email

  @property
  def email(self):
    return self._email

  @email.setter
  def email(self, new_email):
    if '@' in new_email:
      self._email = new_email
    else:
      raise ValueError("Email not Valid.")

  @email.deleter
  def email(self):
    del self._email

user1 = User("kamesh@gmail.com")
print(user.email)
del user.email

The getter execution

When you run
            user1 = User("kamesh@gmail.com"),

=> the __init__ method executes self.email = "kamesh@gmail.com"
=> Python detects that email is a `descriptor`.
=> Instead of just creating an attribute, it calls the descriptor's __set__ method, which is your @email.setter code.
   The validation runs, and if passes the value is stored in self._email.

When you run
            print(user.email)

=> Python again sees the email is a descriptor and calls its __get__ method—which is @property code.
=> It fetches the value from the internal self._email and returns it.

The setter execution

when you run
            user1.email = "kamesh@gmail.com"

=> Python doesn’t treat it like a simple attribute assignment.
=> Instead, it notices that email is a property and automatically calls the @email.setter method.
=> This method receives the new value ("kamesh@gmail.com") and checks whether it contains an '@'.
=> If the validation passes, it updates the internal _email attribute; otherwise, it raises a ValueError

The deleter execution

when you do
            del user1.email

=> Python calls the @email.deleter method, which deletes internal _email variable, removing the stored email from the object.

The @property decorator in Python lets you use methods like attributes. It gives you control over how data is accessed, modified, or deleted inside a class.

3. Attribution Access

$\text{3.1 Read-only Attribute?}$

A read-only attribute is one that:

• You can read its value (via a getter)
• But you cannot change it (no setter)

Note: It allow you to write once, when creating object, but does not let you change afterwards.

In the Voter class, the name is set up as a read-only attribute. This means you can look at it using voter1.name, but you can't change it later, because there's no @name.setter defined. Python raises an AttributeError saying you can't assign to a read-only property.

$\textbf{Similary, id is also read only}$

$\text{3.2 Write-enabled Attribute}$

A write-enabled attribute is one that:

• Has a getter (via @property)
• And a setter (via @.setter)

You can both read and update its value.

The id is read-only because you probably don't want users changing their own unique ID, it's meant to stay fixed. Same with name, once it's set, it usually doesn't change. But something like address is more flexible; people move, and you might want to let them update it. That's where a setter comes in, it gives you the control to allow changes only where they make sense.

4. Why Use Properties When We Have _ and __?

Using _ (single underscore) or __ (double underscore) in Python is just a convention to signal that a variable is intended to be private. But it doesn't actually stop anyone from accessing or modifying it (you can access __ with name mangling).

Whereas @property is more powerful because it gives you real control. It lets you:

• Control access to an attribute of the class
• Make attributes read-only (just use a getter only)
• Add validation checks before setting a value (via setter)
• Keep clean syntax — use user.name instead of user.get_name()

That is,

_ and __ are like "Please don't touch this"
@property is like "You really can't touch this unless I say so"