Encapsulation bundles data and functionality with in a single unit, controlling access to internal states. In Python, this is achieved through classes where attributes and methods are categorized by their scope and visibility. Access modifiers distinguish between public members, accessible anywhere, and private members, intended for internal use only.

Attribute Scopes and Visibility

Attributes define the state of an object. Their scope determines whether they belong to the class itself or specific instances.

Class-Level Attributes

Class attributes are shared across all instances of a class. They are defined directly within the class body, outside any methods. These are accessible via both the class name and any instance object.

class BankAccount:
    # Shared across all instances
    currency = "USD"

    def __init__(self, owner):
        self.owner = owner

# Access via class
print(BankAccount.currency)

# Access via instance
account = BankAccount("Alice")
print(account.currency)

Instance Attributes

Instance attributes are unique to each object. They are typically initialized within the constructor (__init__) using the self reference. Unlike class attributes, these cannot be accessed directly through the class name.

class BankAccount:
    currency = "USD"

    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

acc = BankAccount("Bob", 500)

# This raises an AttributeError
# print(BankAccount.balance) 

# Correct access via instance
print(acc.balance)

Private Attributes

Python does not enforce strict privacy. Instead, it uses name mangling for members prefixed with double underscores (__). This makes the attribute harder to access accidentally from outside the class.

class BankAccount:
    def __init__(self, owner, balance, pin):
        self.owner = owner
        self.balance = balance
        # Private attribute
        self.__pin = pin

    def verify_pin(self, input_pin):
        return input_pin == self.__pin

acc = BankAccount("Charlie", 1000, 9999)

# Access via public method
print(acc.verify_pin(9999))

# Access via name mangling (not recommended)
print(acc._BankAccount__pin)

Attribute Shadowing

If an instance attribute shares the same name as a class attribute, the instance attribute takes precedence when accessed through the object. The class attribute remains unchanged when accessed via the class name.

class Config:
    mode = "production"

    def __init__(self, mode):
        # Shadows the class attribute
        self.mode = mode

setup = Config("development")

# Instance attribute
print(setup.mode)  # Output: development

# Class attribute remains unchanged
print(Config.mode) # Output: production

Method Types and Decorators

Methods define the behavior of a class. Depending on whether they need access to instance data, class data, or neither, they are decorated or defined differently.

Instance Methods

These are the standard methods used for object-specific logic. They require the self parameter to access instance attributes.

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

    def deposit(self, amount):
        self.balance += amount
        return self.balance

acc = BankAccount(100)
print(acc.deposit(50))

Class Methods

Decorated with @classmethod, these methods receive the class (cls) as the first argument instead of the instance. They are useful for factory patterns or accessing class-level state.

class BankAccount:
    currency = "USD"

    @classmethod
    def get_currency(cls):
        return cls.currency

# Callable via class or instance
print(BankAccount.get_currency())
print(BankAccount().get_currency())

Static Methods

Decorated with @staticmethod, these methods behave like regular functions nested within a class. They do not receive self or cls. Use them for utility functions related to the class but independent of its state.

class BankAccount:
    @staticmethod
    def validate_amount(amount):
        return amount > 0

# Callable without instantiation
print(BankAccount.validate_amount(100))

Private Methods

Similar to private attributes, methods prefixed with __ are mangled. They should be called internally via public methods rather than directly.

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

    def __calculate_fee(self, amount):
        return amount * 0.01

    def withdraw(self, amount):
        fee = self.__calculate_fee(amount)
        self.balance -= (amount + fee)

acc = BankAccount(1000)
acc.withdraw(100)

Selection Guidelines

Choosing the correct method type depends on data access requirements:

1. Instance Methods: Required when modifying or reading specific object data (self).
2. Class Methods: Suitable when logic depends on class-level variables (cls) or when creating alternative constructors.
3. Static Methods: Best for helper functions that logically belong to the class namespace but do not interact with class or instance state.