Encapsulation and Abstraction in Python0%

Dataclasses: Clean Data Models with @dataclass

Encapsulation and Abstraction in Python

Intermediate8 min read•Updated: 2026-10-01

Encapsulation and Abstraction in Python

Encapsulation and Abstraction are two foundational pillars of Object-Oriented software design. Together, they protect internal object integrity, hide internal implementation complexity, and expose clean, intuitive interfaces to external consumers.

1. What is Encapsulation?

Encapsulation is the bundling of data (attributes) and the methods that operate on that data into a single unit (a class), while restricting direct access to internal components to prevent unintended tampering.

Python Naming Conventions for Access Control

Unlike languages with hard public, protected, and private keywords, Python uses naming conventions and name mangling:

Type	Convention	Meaning	Access Behavior
Public	`attribute`	Part of the public API	Fully accessible from anywhere
Protected	`_attribute`	Internal use only; intended for class & subclasses	Accessible, but signals "do not touch outside class"
Private	`__attribute`	Strictly private to this class	Triggers name mangling (`_ClassName__attribute`)

1class BankAccount:
2    def __init__(self, owner: str, initial_balance: float):
3        self.owner = owner            # Public
4        self._account_type = "Saving" # Protected convention
5        self.__balance = initial_balance # Strictly Private (mangled)
6 
7    def get_balance(self) -> float:
8        return self.__balance
9 
10acc = BankAccount("Aarav", 10000.0)
11print(acc.owner)        # Aarav (Allowed)
12print(acc._account_type) # Saving (Allowed, but discouraged by convention)
13 
14# Direct access to __balance triggers an AttributeError
15try:
16    print(acc.__balance)
17except AttributeError as err:
18    print(f"Blocked: {err}")
19 
20# How Python mangles the name under the hood:
21print(acc._BankAccount__balance)  # 10000.0 (Accessible, demonstrating "consenting adults" philosophy)

Python's Philosophy: Python operates on the principle of "We are all consenting adults here". Name mangling is designed primarily to avoid naming collisions in subclasses, not as an impenetrable security sandbox.

2. Pythonic Properties: `@property` and Setters

In traditional OOP (like Java or C++), developers write verbose getBalance() and setBalance() methods. Python replaces this with the elegant @property decorator, enabling getter/setter validation while preserving clean attribute access syntax (acc.balance = 500 instead of acc.set_balance(500)).

1class Employee:
2    def __init__(self, name: str, salary: float):
3        self.name = name
4        self.salary = salary  # Uses the setter below!
5 
6    # 1. Getter property
7    @property
8    def salary(self) -> float:
9        return self._salary
10 
11    # 2. Setter with input validation
12    @salary.setter
13    def salary(self, value: float):
14        if not isinstance(value, (int, float)):
15            raise TypeError("Salary must be a numeric value.")
16        if value < 0:
17            raise ValueError("Salary cannot be negative.")
18        self._salary = float(value)
19 
20    # 3. Deleter (optional)
21    @salary.deleter
22    def salary(self):
23        print(f"Deleting salary record for {self.name}.")
24        del self._salary
25 
26emp = Employee("Meera", 75000)
27print(emp.salary)  # 75000.0 (calls getter)
28 
29emp.salary = 82000  # Validated update via setter
30print(emp.salary)
31 
32try:
33    emp.salary = -500  # Raises ValueError: Salary cannot be negative.
34except ValueError as err:
35    print(f"Validation caught error: {err}")

3. What is Abstraction?

Abstraction focuses on hiding background details and displaying only essential features to the user. An end-user interacting with a smartphone screen doesn't need to understand RF transmission circuits or silicon microcode—they only interact with high-level buttons and icons.

In Python, abstraction is enforced using the abc (Abstract Base Classes) module:

ABC: Base class from which abstract classes inherit.
@abstractmethod: Decorator indicating methods that must be implemented by any concrete subclass.

1from abc import ABC, abstractmethod
2 
3# Abstract Base Class definition
4class DatabaseConnector(ABC):
5    @abstractmethod
6    def connect(self):
7        """Establish connection to data store."""
8        pass
9 
10    @abstractmethod
11    def execute_query(self, query: str):
12        """Execute a query string and return results."""
13        pass
14 
15    @abstractmethod
16    def disconnect(self):
17        """Cleanly terminate connection."""
18        pass
19 
20 
21# Attempting to instantiate an abstract class directly fails:
22try:
23    db = DatabaseConnector()
24except TypeError as err:
25    print(f"Direct instantiation blocked: {err}")

4. Implementing Concrete Subclasses

Any subclass that fails to implement all abstract methods cannot be instantiated:

1class PostgreSQLConnector(DatabaseConnector):
2    def connect(self):
3        print("Connected to PostgreSQL on port 5432.")
4 
5    def execute_query(self, query: str):
6        print(f"Executing SQL: '{query}' on Postgres engine.")
7        return [{"id": 1, "status": "active"}]
8 
9    def disconnect(self):
10        print("PostgreSQL connection terminated.")
11 
12# Concrete class instantiated successfully
13pg = PostgreSQLConnector()
14pg.connect()
15data = pg.execute_query("SELECT * FROM users;")
16pg.disconnect()

⚠️ Common Intermediate Mistakes & Gotchas

1. Believing Double Underscores (`__`) Make Attributes Truly Private

Python does not enforce true private memory. Double underscores simply trigger name mangling (_ClassName__attribute). Use single underscore (_attr) for protected convention, and double underscores only when avoiding subclass name collisions.

2. Defining Setter Without Getter in `@property`

A @prop.setter requires the matching @property getter to be defined first with the exact same method name.

💻 Try It Yourself: Temperature Sensor with @property

Scenario

Build a TemperatureSensor class where the internal temperature is stored in Celsius, but provides a getter and setter in Fahrenheit using @property.

Complete Solution

1class TemperatureSensor:
2    def __init__(self, celsius: float = 0.0):
3        self._celsius = float(celsius)
4 
5    @property
6    def celsius(self) -> float:
7        return self._celsius
8 
9    @celsius.setter
10    def celsius(self, value: float):
11        if value < -273.15:
12            raise ValueError("Temperature below absolute zero is physically impossible!")
13        self._celsius = value
14 
15    @property
16    def fahrenheit(self) -> float:
17        return (self._celsius * 9/5) + 32
18 
19    @fahrenheit.setter
20    def fahrenheit(self, value: float):
21        self.celsius = (value - 32) * 5/9
22 
23sensor = TemperatureSensor(25.0)
24print(f"Temperature: {sensor.celsius}°C = {sensor.fahrenheit}°F")
25sensor.fahrenheit = 98.6
26print(f"Set to 98.6°F -> Celsius is: {sensor.celsius:.1f}°C")

Expected Output

1Temperature: 25.0°C = 77.0°F
2Set to 98.6°F -> Celsius is: 37.0°C

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

What happens when an attribute name begins with two leading underscores (e.g. __secret)?

Question 2

Which decorator is used to turn a method into a read-only getter attribute?

Question 3

What error is raised when attempting to instantiate an abstract class that has unimplemented @abstractmethods?

Question 4

What is the primary convention of a single leading underscore (e.g. _internal_var)?

Question 5

From which standard library module are ABC and @abstractmethod imported?

🚀 What's Next?

In the next lesson, we will continue your intermediate Python journey with Project: Bank Account Class System (5: Object-Oriented Programming (Intermediate)).

👉 Continue to Next Lesson: Project: Bank Account Class System →

Next Lesson

Dataclasses: Clean Data Models with @dataclass

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Polymorphism Basics	Dataclasses: Clean Data Models with @dataclass

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Dataclasses: Clean Data Models with @dataclass

Encapsulation and Abstraction in Python

Intermediate8 min read•Updated: 2026-10-01

Study Materials Cheatsheet

Encapsulation and Abstraction in Python

1. What is Encapsulation?

Python Naming Conventions for Access Control

Unlike languages with hard public, protected, and private keywords, Python uses naming conventions and name mangling:

Type	Convention	Meaning	Access Behavior
Public	`attribute`	Part of the public API	Fully accessible from anywhere
Protected	`_attribute`	Internal use only; intended for class & subclasses	Accessible, but signals "do not touch outside class"
Private	`__attribute`	Strictly private to this class	Triggers name mangling (`_ClassName__attribute`)

1class BankAccount:
2    def __init__(self, owner: str, initial_balance: float):
3        self.owner = owner            # Public
4        self._account_type = "Saving" # Protected convention
5        self.__balance = initial_balance # Strictly Private (mangled)
6 
7    def get_balance(self) -> float:
8        return self.__balance
9 
10acc = BankAccount("Aarav", 10000.0)
11print(acc.owner)        # Aarav (Allowed)
12print(acc._account_type) # Saving (Allowed, but discouraged by convention)
13 
14# Direct access to __balance triggers an AttributeError
15try:
16    print(acc.__balance)
17except AttributeError as err:
18    print(f"Blocked: {err}")
19 
20# How Python mangles the name under the hood:
21print(acc._BankAccount__balance)  # 10000.0 (Accessible, demonstrating "consenting adults" philosophy)

2. Pythonic Properties: `@property` and Setters

1class Employee:
2    def __init__(self, name: str, salary: float):
3        self.name = name
4        self.salary = salary  # Uses the setter below!
5 
6    # 1. Getter property
7    @property
8    def salary(self) -> float:
9        return self._salary
10 
11    # 2. Setter with input validation
12    @salary.setter
13    def salary(self, value: float):
14        if not isinstance(value, (int, float)):
15            raise TypeError("Salary must be a numeric value.")
16        if value < 0:
17            raise ValueError("Salary cannot be negative.")
18        self._salary = float(value)
19 
20    # 3. Deleter (optional)
21    @salary.deleter
22    def salary(self):
23        print(f"Deleting salary record for {self.name}.")
24        del self._salary
25 
26emp = Employee("Meera", 75000)
27print(emp.salary)  # 75000.0 (calls getter)
28 
29emp.salary = 82000  # Validated update via setter
30print(emp.salary)
31 
32try:
33    emp.salary = -500  # Raises ValueError: Salary cannot be negative.
34except ValueError as err:
35    print(f"Validation caught error: {err}")

3. What is Abstraction?

In Python, abstraction is enforced using the abc (Abstract Base Classes) module:

ABC: Base class from which abstract classes inherit.
@abstractmethod: Decorator indicating methods that must be implemented by any concrete subclass.

1from abc import ABC, abstractmethod
2 
3# Abstract Base Class definition
4class DatabaseConnector(ABC):
5    @abstractmethod
6    def connect(self):
7        """Establish connection to data store."""
8        pass
9 
10    @abstractmethod
11    def execute_query(self, query: str):
12        """Execute a query string and return results."""
13        pass
14 
15    @abstractmethod
16    def disconnect(self):
17        """Cleanly terminate connection."""
18        pass
19 
20 
21# Attempting to instantiate an abstract class directly fails:
22try:
23    db = DatabaseConnector()
24except TypeError as err:
25    print(f"Direct instantiation blocked: {err}")

4. Implementing Concrete Subclasses

Any subclass that fails to implement all abstract methods cannot be instantiated:

1class PostgreSQLConnector(DatabaseConnector):
2    def connect(self):
3        print("Connected to PostgreSQL on port 5432.")
4 
5    def execute_query(self, query: str):
6        print(f"Executing SQL: '{query}' on Postgres engine.")
7        return [{"id": 1, "status": "active"}]
8 
9    def disconnect(self):
10        print("PostgreSQL connection terminated.")
11 
12# Concrete class instantiated successfully
13pg = PostgreSQLConnector()
14pg.connect()
15data = pg.execute_query("SELECT * FROM users;")
16pg.disconnect()

⚠️ Common Intermediate Mistakes & Gotchas

1. Believing Double Underscores (`__`) Make Attributes Truly Private

2. Defining Setter Without Getter in `@property`

A @prop.setter requires the matching @property getter to be defined first with the exact same method name.

💻 Try It Yourself: Temperature Sensor with @property

Scenario

Build a TemperatureSensor class where the internal temperature is stored in Celsius, but provides a getter and setter in Fahrenheit using @property.

Complete Solution

1class TemperatureSensor:
2    def __init__(self, celsius: float = 0.0):
3        self._celsius = float(celsius)
4 
5    @property
6    def celsius(self) -> float:
7        return self._celsius
8 
9    @celsius.setter
10    def celsius(self, value: float):
11        if value < -273.15:
12            raise ValueError("Temperature below absolute zero is physically impossible!")
13        self._celsius = value
14 
15    @property
16    def fahrenheit(self) -> float:
17        return (self._celsius * 9/5) + 32
18 
19    @fahrenheit.setter
20    def fahrenheit(self, value: float):
21        self.celsius = (value - 32) * 5/9
22 
23sensor = TemperatureSensor(25.0)
24print(f"Temperature: {sensor.celsius}°C = {sensor.fahrenheit}°F")
25sensor.fahrenheit = 98.6
26print(f"Set to 98.6°F -> Celsius is: {sensor.celsius:.1f}°C")

Expected Output

1Temperature: 25.0°C = 77.0°F
2Set to 98.6°F -> Celsius is: 37.0°C

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

What happens when an attribute name begins with two leading underscores (e.g. __secret)?

Question 2

Which decorator is used to turn a method into a read-only getter attribute?

Question 3

What error is raised when attempting to instantiate an abstract class that has unimplemented @abstractmethods?

Question 4

What is the primary convention of a single leading underscore (e.g. _internal_var)?

Question 5

From which standard library module are ABC and @abstractmethod imported?

🚀 What's Next?

In the next lesson, we will continue your intermediate Python journey with Project: Bank Account Class System (5: Object-Oriented Programming (Intermediate)).

👉 Continue to Next Lesson: Project: Bank Account Class System →

Next Lesson

Dataclasses: Clean Data Models with @dataclass

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Polymorphism Basics	Dataclasses: Clean Data Models with @dataclass

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

Encapsulation and Abstraction in Python

1. What is Encapsulation?

Python Naming Conventions for Access Control

2. Pythonic Properties: @property and Setters

3. What is Abstraction?

4. Implementing Concrete Subclasses

⚠️ Common Intermediate Mistakes & Gotchas

1. Believing Double Underscores (__) Make Attributes Truly Private

2. Defining Setter Without Getter in @property

💻 Try It Yourself: Temperature Sensor with @property

Scenario

Complete Solution

Expected Output

Practice Quiz

🚀 What's Next?

Dataclasses: Clean Data Models with @dataclass

Related Lessons

Practice Quiz

Loading Page Content...

Encapsulation and Abstraction in Python

1. What is Encapsulation?

Python Naming Conventions for Access Control

2. Pythonic Properties: @property and Setters

3. What is Abstraction?

4. Implementing Concrete Subclasses

⚠️ Common Intermediate Mistakes & Gotchas

1. Believing Double Underscores (__) Make Attributes Truly Private

2. Defining Setter Without Getter in @property

💻 Try It Yourself: Temperature Sensor with @property

Scenario

Complete Solution

Expected Output

Practice Quiz

🚀 What's Next?

Dataclasses: Clean Data Models with @dataclass

Related Lessons

Practice Quiz

2. Pythonic Properties: `@property` and Setters

1. Believing Double Underscores (`__`) Make Attributes Truly Private

2. Defining Setter Without Getter in `@property`

2. Pythonic Properties: `@property` and Setters

1. Believing Double Underscores (`__`) Make Attributes Truly Private

2. Defining Setter Without Getter in `@property`