Introduction to Encapsulation in Python | CodeSignal Learn

Introduction to Encapsulation in Python | CodeSignal Learn

Introduction to Encapsulation

Welcome back! After diving deep into classes in our last session, we're now shifting our focus to another essential concept in Object-Oriented Programming (OOP): encapsulation . Encapsulation is a way to bundle the data (variables) and methods (functions) that operate on the data, and to restrict direct access to some of an object's components, which can prevent the accidental modification of data. By keeping the data attributes private and providing public methods to access and modify the attributes, you ensure that the internal state of the object can only be changed in controlled ways. In Python, attributes can be public (accessible from outside the class) or private (not directly accessible from outside the class). Public attributes are meant to be accessed directly, while private attributes are to be accessed and modified through methods within the class.

Create Private Attributes

Let's start by defining a simple Person class with private attributes. To apply encapsulation, we need to make the attributes private by prefixing them with double underscores (__): Python class Person: def __init__(self, name, age): self.__name = name self.__age = age Now,__name and__age are private attributes. It is important to note, however, that Python doesn't have truly private attributes. Prefixing an attribute with double underscores (__) is a convention to indicate it should not be accessed directly outside the class. This name mangling feature helps prevent accidental access and modification but can still be bypassed if necessary.

Getter Methods

Next, let's add methods to access these private attributes. These methods are known as getter methods: methods which provide controlled and consistent access to private attributes, facilitate debugging by centralizing access logic. They allow for calculations or transformations before returning values and offer abstraction that enables changes to the underlying data structure without impacting external code. Here is an example of these methods: Python class Person: def __init__(self, name, age): self.__name = name self.__age = age def get_name(self): return self.__name def get_age(self): return self.__age

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Setter Methods

Similarly to getter methods, since the attributes are private and cannot be accessed from outside the class, we need a way to modify these private attributes. These methods are called setter methods: class Person: def __init__(self, name, age): self.__name = name self.__age = age def get_name(self): return self.__name def get_age(self): return self.__age def set_name(self, name): self.__name = name def set_age(self, age): self.__age = age Setter methods are necessary to provide a controlled way to change the values of private attributes and enforce any constraints or validations.

Test the Encapsulation

Now, let's use our Person class to see encapsulation in action: person = Person("Alice", 30) # Accessing private attributes through getter methods print("Name:", person.get_name(), ", Age:", person.get_age()) # Output: Name: Alice , Age: 30 # Modifying private attributes through setter methods person.set_name("Bob") person.set_age(25) # Accessing modified attributes print("Name:", person.get_name(), ", Age:", person.get_age()) # Output: Name: Bob , Age: 25 In this example, we have encapsulated the name and age attributes by making them private and providing getter and setter methods for controlled access and modification. This is useful because it ensures that the internal state of the object can only be accessed and modified through the provided methods, allowing us to enforce validation and maintain consistency.

Python

class Person:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def get_name(self):
        return self.__name
    
    def get_age(self):
        return self.__age
    
    def set_name(self, name):
        self.__name = name

    def set_age(self, age):
        self.__age = age

Python

person = Person("Alice", 30)

# Accessing private attributes through getter methods
print("Name:", person.get_name(), ", Age:", person.get_age()) # Output: Name: Alice , Age: 30

# Modifying private attributes through setter methods
person.set_name("Bob")
person.set_age(25)

# Accessing modified attributes
print("Name:", person.get_name(), ", Age:", person.get_age()) # Output: Name: Bob , Age: 25