How To Define A Private Method In Python

Python is widely known for its easy-to-understand syntax, making it perfect for both beginners and professionals. One concept that is often used in Object-Oriented Programming (OOP) is the private method.

Although Python doesn’t have built-in support for private methods like other programming languages such as Java or C++, it does provide a way to indicate that a method should be treated as a private one. This tutorial will guide you on how to define a private method in Python using a naming convention that is generally accepted by the community.

Step 1: Understand the Concept of Private Methods

A private method is a function inside a class that is intended to be used only within that class. It is designed to encapsulate functionality that should not be accessible from outside the class, improving the overall integrity and security of the code.

In Python, there is no strict way to enforce private methods. However, there is a widely accepted naming convention that indicates a method should be considered private: a method prefixed with a double underscore (__).

Step 2: Define a Class and a Private Method

To create a private method, declare it inside a class with a double underscore as a prefix. Let’s create a class named Car with a private method called __start_engine():

1
2
3
class Car:
    def __start_engine(self):
        print("Starting the engine")

Here, the __start_engine() method is considered to be a private method because of the double underscore prefix.

Step 3: Calling the Private Method Inside the Class

To use a private method within the class, simply call it using self followed by the method name, as you would for any other method. For example, let’s define a public method called drive() in the Car class that calls the private method __start_engine():

1
2
3
4
5
6
7
class Car:
    def __start_engine(self):
        print("Starting the engine")
 
    def drive(self):
        self.__start_engine()
        print("Driving the car")

Step 4: Accessing the Private Method from an Outside Client

In general, you should not access private methods from outside the class. However, it is technically possible by using the following syntax: _classname__methodname. For example:

1
2
car = Car()
car._Car__start_engine()

It is important to note that this is not a recommended practice, as it can break the encapsulation principle of OOP.

Full Code:

1
2
3
4
5
6
7
8
9
10
class Car:
    def __start_engine(self):
        print("Starting the engine")
 
    def drive(self):
        self.__start_engine()
        print("Driving the car")
 
car = Car()
car.drive()

Output:

Starting the engine
Driving the car

Conclusion

In this tutorial, we learned how to define a private method in Python using the double underscore naming convention. Although Python does not have strict support for private methods, this approach allows you to hint that a method should be treated as a private one. Practice encapsulation by leveraging private methods to improve the integrity and security of your code.