Python Private Method

Introduction

In Python, a private method is a method that is not intended to be used outside of the class in which it is defined. These methods are denoted by a double underscore prefix (__) before their name, and they can only be accessed within the class where they are defined. In this article, we are going to discuss the concept of private methods in Python, their advantages and disadvantages, and how to use them with examples.

What is a Private Method in Python?

A private method is a method that is not intended to be used outside the class in which it is defined. These methods are used to implement internal functionality within the class. These are not meant to be used by external code. In Python, private methods are denoted by a double underscore prefix before their name.

Example

How to Define a Private Method in Python?

When the programmer wants to define a private method in Python, then the programmer needs to add a double underscore prefix before the method name. Here is an example:

Program 1:

class MyClass:
    
    def __init__(self):
        self.__private_method()
 
    def __private_method(self):
        print("This is a private method.")
 
# Instantiate, the class
my_obj = MyClass()

Output:

Explanation:

In the above example, we have defined a class called MyClass. It has a private method called __private_method. This method is called from the class constructor (__init__) using self.__private_method(). Since the method has a double underscore prefix, it is private and cannot be accessed outside the class.

Program 2:

class BankAccount:
    
    def __init__(self, account_number, balance):
        self.__account_number = account_number
        self.__balance = balance
 
    def deposit(self, amount):
        self.__balance += amount
 
    def withdraw(self, amount):
        if self.__balance >= amount:
            self.__balance -= amount
        else:
            print("Insufficient funds")
 
    def __display_balance(self):
        print("Account Balance:", self.__balance)
 
    def statement(self):
        print("Account Number:", self.__account_number)
        self.__display_balance()
# create a BankAccount object
my_account = BankAccount("123456789", 1000)
 
# make some transactions
my_account.deposit(500)
my_account.withdraw(200)
 
# print a statement
my_account.statement()

Output:

Explanation:

The code provided defines a BankAccount class with methods for depositing and withdrawing funds, displaying the account balance, and printing an account statement. An instance of this class is then created, and some transactions are made to it, followed by printing a statement.

Advantages of Private Methods in Python

Encapsulation: Private methods help in achieving encapsulation. It is a fundamental principle of object-oriented programming. By making certain methods private, the programmer can control how the class's internal functionality is accessed from external code. This makes the class more secure and helps in preventing unwanted changes to the class's behavior.
Code Reusability: Private methods can be used to implement internal functionality that can be reused within the class. This can help in reducing code duplication and improve code maintainability.
Easy Debugging: Private methods are only accessible within the class, making it easier to debug code by isolating the class's behavior.

Disadvantages of Private Methods in Python

Limited Access: Private methods are only accessible within the class in which they are defined. This means that if the programmer needs to access the functionality of a private method from outside the class, then they need to create a public method that calls the private method. This can add additional complexity to the code.
False Sense of Security: Python's private methods are not truly private. It is still possible to access them outside the class using the _classname__methodname() syntax. However, this is considered bad practice and should be avoided.
Increased Complexity: The use of private methods can increase the complexity of the code, making it harder to understand and maintain. This can be especially true if the private methods are poorly documented.

Conclusion

Private methods in Python are a useful feature that can help achieve encapsulation and improve code maintainability. While they have some disadvantages, the benefits of using private methods in Python outweigh the drawbacks.

Next TopicPython Subprocess Run

← prev next →