Lesson 1

Encapsulation in Python: Securing Data with OOP Principles


Welcome! Today's subject is Encapsulation, a cornerstone of Object-Oriented Programming (OOP). Encapsulation bundles data and the operations that we perform on them into one unit, namely, an object. It guards data against unwanted alterations, ensuring the creation of robust and maintainable software.

Prepare yourself for an exciting journey as we delve into how encapsulation works in Python and explore the vital role it plays in data privacy.

Unraveling Encapsulation

Starting with the basics, Encapsulation is similar to packing data and the methods that modify this data into a single compartment known as a class. It safeguards the data in an object from external interference.

To illustrate, consider a Python class representing a bank account. Without encapsulation, the account balance could be directly altered. With encapsulation, however, the balance can only change through specified methods, like depositing or withdrawing.

Encapsulation: Guardian of Data Privacy

Encapsulation restricts direct access to an object's data and prevents unwanted data alteration. This principle is comparable to window blinds, allowing you to look out while preventing others from peeping in.

In Python, encapsulation pertains to private and public attributes, which are integral to data privacy. Private attributes, prefixed with two underscores __, warrant caution while being manipulated.

To illustrate, let's consider a Python class named Person, which includes a private attribute __name.

1class Person: 2 def __init__(self, name): 3 self.__name = name # Private attribute 4 5 def get_name(self): 6 return self.__name # Accessor method 7 8person = Person('Alice') 9print(person.get_name()) # Accessing private attribute via accessor method. Output: Alice 10print(person.__name) # Error: 'Person' object has no attribute '__name'

In this example, __name is private, and get_name() enables us to access __name. However, we specify that the name can't be changed, as we don't provide a proper method for that.

In Python, all class members are public by default. To designate an attribute as private, we prefix it with two underscores __.

Getter and Setter Methods in Encapsulation

Within encapsulation, Python uses getter and setter methods to access or modify private attributes. In a class, the getter method retrieves the attribute value, and the setter method alters it. Let's illustrate this.

1class Dog: 2 def __init__(self, name): 3 self.__name = name # Private attribute 4 5 def set_name(self, name): # Setter method 6 self.__name = name 7 8 def get_name(self): # Getter method 9 return self.__name 10 11my_dog = Dog('Max') 12my_dog.set_name('Buddy') 13print(my_dog.get_name()) # Output: Buddy

Here, set_name() and get_name() serve as the setter and getter methods, respectively, for the private attribute __name.

Practical Application and Summary

Let's apply the principle of encapsulation to our BankAccount class, which includes private attributes like account number and balance, along with public methods for withdrawals, deposits, and balance checks.

1class BankAccount: 2 3 def __init__(self, account_no, balance): 4 self.__account_no = account_no 5 self.__balance = balance 6 7 def withdraw(self, amount): 8  self.__balance -= amount 9 10 def deposit(self, amount):  11  self.__balance += amount 12 13 def check_balance(self):  14  return self.__balance 15 16account = BankAccount(1, 500) 17account.withdraw(100) 18account.deposit(50) 19print(account.check_balance()) # Prints: 450

In the above code, the BankAccount class encapsulates account details, and the public methods manipulate the balance in a controlled way.

Hands-on Exercise and Practice

Admirable! Now it's your turn to apply what you've learned by practicing encapsulation in Python. Remember, practice enhances your comprehension. Enjoy coding!

Enjoy this lesson? Now it's time to practice with Cosmo!

Practice is how you turn knowledge into actual skills.