Why do we make methods private?

We make methods private primarily to encapsulate the internal logic of a class and control its public interface. This ensures a cleaner, more maintainable, and robust codebase.

Encapsulation Explained

Encapsulation, in the context of object-oriented programming, is about bundling the data (attributes) and methods that operate on that data within a class, and hiding the internal workings from the outside world. Private methods play a crucial role in achieving this. According to provided reference, private methods are a great way to encapsulate the internal logic of your class.

Benefits of Private Methods

Here's a breakdown of the advantages of using private methods:

• Hiding Implementation Details: Private methods allow you to hide complex or internal operations that are specific to how the class works. Users of the class don't need to know how a task is accomplished, only that it is accomplished. This is a fundamental tenet of abstraction.
• Preventing Unintended Usage: By making a method private, you prevent external code from directly calling it. This ensures that certain critical operations are only performed in a controlled manner through the class's public interface.
• Reducing Coupling: Private methods reduce the coupling between your class and other parts of your code. If the internal implementation (and therefore the private methods) changes, it won't affect the code that uses the class, as long as the public interface remains the same.
• Improved Maintainability: When the internal workings of a class are encapsulated using private methods, it becomes easier to modify or refactor the code without worrying about breaking other parts of the application.

Practical Examples

Let's imagine a BankAccount class:

class BankAccount:
    def __init__(self, account_number, balance):
        self.account_number = account_number
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        self._log_transaction("deposit", amount)  # Private method

    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
            self._log_transaction("withdraw", amount)  # Private method
        else:
            print("Insufficient funds.")

    def get_balance(self):
        return self.balance

    def _log_transaction(self, transaction_type, amount):
        # Internal logic for logging transactions
        print(f"Transaction: {transaction_type} - Amount: {amount}")


account = BankAccount("12345", 1000)
account.deposit(500)
account.withdraw(200)
print(f"Current balance: {account.get_balance()}")

#account._log_transaction("test", 100) #Avoid to use outside the class

In this example, _log_transaction is a private method. It's used internally by the deposit and withdraw methods to record transaction details. External code shouldn't call _log_transaction directly, because it's an internal implementation detail of the BankAccount class. The single underscore is a convention, Python doesn't truly enforce privateness.

Summary