encapsulation in python

Encapsulation is a fundamental concept in object-oriented programming (OOP). In a nutshell, encapsulation in Python allows us to restrict the access to certain methods and variables within the class, ensuring that the data is hidden and safe from any unintentional modifications. Dive into this guide to understand encapsulation in Python with examples.

Boost Your Python Skills: Python Programming Bootcamp: Go from zero to hero.

Understanding Private Methods in Python

Consider the following scenario: We have a Car class, which consists of two main methods: drive() and the private method __updateSoftware(). When we instantiate the Car class, the __updateSoftware() method gets executed.

However, here’s the catch. You cannot invoke the private method (__updateSoftware()) directly using the object outside the class. Here’s how it’s done:

class Car:
    def __init__(self):
        self.__updateSoftware()
    def drive(self):
        print('driving')
    def __updateSoftware(self):
        print('updating software')

redcar = Car()
redcar.drive()
#redcar.__updateSoftware()  # Error: This line is not accessible from the object.

Executing the above program would give you:

updating software
driving

The crux here is that encapsulation ensures accidental data access restrictions. Still, determined users can intentionally access it. Though the private methods appear hidden, they are simply renamed with the class name prefixed, like _Car__updateSoftware(). Therefore, you can still access the method using redcar._Car__updateSoftware().

Leveraging Private Variables in Python

Just like methods, variables can be set as private. The beauty of private variables lies in their restricted access, ensuring they are modified only within the class methods, not outside. This is crucial for protecting vital application data.

Here’s an illustration:

class Car:
    __maxspeed = 0
    __name = ""
    def __init__(self):
        self.__maxspeed = 200
        self.__name = "Supercar"
    def drive(self):
        print('driving. maxspeed ' + str(self.__maxspeed))

redcar = Car()
redcar.drive()
redcar.__maxspeed = 10  # This won't alter the variable as it's private.
redcar.drive()

Now, what if you wish to modify a private variable? Use a setter method—a dedicated method designed to set or alter the value of private variables:

class Car:
    __maxspeed = 0
    __name = ""
    def __init__(self):
        self.__maxspeed = 200
        self.__name = "Supercar"
    def drive(self):
        print('driving. maxspeed ' + str(self.__maxspeed))
    def setMaxSpeed(self, speed):
        self.__maxspeed = speed

redcar = Car()
redcar.drive()
redcar.setMaxSpeed(320)
redcar.drive()

Setter methods are handy. While some private variables might need occasional updates, others might not necessitate any changes.

Encapsulation in Python: A Summary

In Python, encapsulation can be primarily categorized as:

• Public Methods: These are accessible universally.
• Private Methods: Exclusive to their class, these begin with two underscores.
• Public Variables: These are universally accessible.
• Private Variables: Restricted to their class or through specific methods (if provided), these also commence with two underscores.

Unlike some other programming languages, Python doesn’t support protected class methods. By encapsulating data, you get superior control over how much coupling exists in your code. Essentially, it permits a class to evolve its implementation without impacting other code segments.

Get Hands-on with Exercises

← Previous Topic | Next Topic →