Python Public Private Protected - Access Modifiers Explained

What You'll Learn Here

Access modifiers — controlling visibility of class members
Public — default, accessible from anywhere
Protected — intended for internal use and subclasses
Private — hidden from outside, with name mangling
Name mangling — how Python makes private members truly private
Encapsulation — protecting data and implementation details

What are Access Modifiers?

Access modifiers control the visibility of class attributes and methods. They help implement encapsulation — one of the core principles of Object-Oriented Programming.

Unlike languages like Java or C++ that have explicit keywords (public, private, protected), Python takes a convention-based approach:

Public — name (no underscore)
Protected — _name (single underscore)
Private — __name (double underscore)

Python's philosophy is: "We're all consenting adults here." The language trusts developers to respect the conventions rather than enforcing them rigidly.

💡 Key concept: Python's access modifiers are conventions — they signal intent to other developers, but don't prevent access. The exception is double-underscore (__name) which triggers name mangling.

Public Members

The Default Visibility

In Python, everything is public by default. Public members can be accessed from anywhere — inside the class, outside the class, and in subclasses.

Public members are defined without any leading underscores. They're the "normal" way to define attributes and methods.

# Public Members — Default Visibility

class Person:
    def __init__(self, name, age):
        self.name = name      # Public attribute
        self.age = age        # Public attribute
    
    # Public method
    def introduce(self):
        return f"Hi, I'm {self.name} and I'm {self.age} years old"
    
    # Public method
    def celebrate_birthday(self):
        self.age += 1
        return f"Happy Birthday! Now {self.age} years old"

# Access from outside
person = Person("Alice", 25)

print(person.name)           # Alice — accessible
print(person.age)            # 25 — accessible

print(person.introduce())    # Hi, I'm Alice and I'm 25 years old
print(person.celebrate_birthday())  # Happy Birthday! Now 26 years old

# Subclass can also access public members
class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade
    
    def show_info(self):
        # Accessing parent's public members
        return f"{self.name} is in grade {self.grade}"

student = Student("Bob", 18, 12)
print(student.show_info())   # Bob is in grade 12
print(student.name)          # Bob — accessible

print("\n✅ Public members: accessible from anywhere")
print("✅ No special syntax needed — just use the name")

Public key points:

Default visibility — no underscores needed
Accessible everywhere — inside class, outside, in subclasses
Convention — used for the public API of your class
No restrictions — Python doesn't prevent access

Quick Check: How do you define a public attribute in Python? (Answer: Just use the name without any underscores, e.g., self.name)

Protected Members

Single Underscore Convention

Protected members are indicated by a single leading underscore (_name). They signal: "This is intended for internal use. Don't access it from outside."

Protected members can still be accessed from outside, but the underscore is a convention telling developers: "You shouldn't touch this unless you know what you're doing."

# Protected Members — Single Underscore Convention

class BankAccount:
    def __init__(self, account_holder, balance):
        self.account_holder = account_holder  # Public
        self._balance = balance               # Protected — internal use
        self._transaction_history = []        # Protected — internal use
    
    # Public method — API for users
    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
            self._add_transaction(f"Deposit: +${amount}")
            return f"Deposited ${amount}. New balance: ${self._balance}"
        return "Invalid amount"
    
    # Public method — API for users
    def withdraw(self, amount):
        if 0 < amount <= self._balance:
            self._balance -= amount
            self._add_transaction(f"Withdrawal: -${amount}")
            return f"Withdrew ${amount}. New balance: ${self._balance}"
        return "Insufficient funds or invalid amount"
    
    # Public method — API for users
    def get_balance(self):
        return self._balance
    
    # Protected method — internal helper
    def _add_transaction(self, description):
        self._transaction_history.append(description)
    
    # Protected method — internal helper
    def _get_transaction_history(self):
        return self._transaction_history

class SavingsAccount(BankAccount):
    def __init__(self, account_holder, balance, interest_rate):
        super().__init__(account_holder, balance)
        self._interest_rate = interest_rate
    
    # Can access protected members from parent
    def apply_interest(self):
        interest = self._balance * self._interest_rate / 100
        self._balance += interest
        self._add_transaction(f"Interest: +${interest:.2f}")
        return f"Interest applied: ${interest:.2f}"
    
    def get_transactions(self):
        # Accessing protected method from parent
        return self._get_transaction_history()

# --- Using the class ---
account = BankAccount("Alice", 1000)

print(account.deposit(500))    # Deposited $500. New balance: $1500
print(account.withdraw(200))   # Withdrew $200. New balance: $1300

# Protected members can be accessed, but it's discouraged
print(account._balance)        # 1300 — accessible but discouraged
print(account._transaction_history)  # accessible but discouraged

# Subclass can access protected members
savings = SavingsAccount("Bob", 1000, 2.5)
print(savings.apply_interest())  # Interest applied: $25.00
print(savings.get_transactions())

print("\n✅ Protected members: single underscore — convention, not enforcement")
print("⚠️ They can be accessed from outside, but don't do it!")
print("✅ Subclasses can access them freely")

Protected key points:

Single underscore — _name indicates protected
Convention only — no enforcement by Python
For internal use — intended for class and subclasses
Accessible from subclasses — designed for inheritance
Discouraged from outside — signals "don't touch"

Quick Check: What does a single underscore prefix (_name) indicate? (Answer: Protected — intended for internal use and subclasses, but just a convention)

Private Members

Double Underscore and Name Mangling

Private members are indicated by a double leading underscore (__name). Unlike protected, private members cannot be accessed from outside the class — at least not easily.

Python uses name mangling to make private members harder to access. The name is changed to _ClassName__name, which prevents accidental access.

# Private Members — Double Underscore and Name Mangling

class BankAccount:
    def __init__(self, account_holder, balance):
        self.account_holder = account_holder  # Public
        self.__balance = balance               # Private — name mangling
        self.__transaction_history = []        # Private — name mangling
        self.__account_number = self.__generate_account_number()
    
    # Private method — name mangled
    def __generate_account_number(self):
        import random
        return f"ACC-{random.randint(10000, 99999)}"
    
    # Public method — API for users
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            self.__add_transaction(f"Deposit: +${amount}")
            return f"Deposited ${amount}. New balance: ${self.__balance}"
        return "Invalid amount"
    
    # Public method — API for users
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            self.__add_transaction(f"Withdrawal: -${amount}")
            return f"Withdrew ${amount}. New balance: ${self.__balance}"
        return "Insufficient funds or invalid amount"
    
    # Public method — API for users
    def get_balance(self):
        return self.__balance
    
    def get_account_info(self):
        return f"{self.account_holder} - {self.__account_number}"
    
    # Private method — name mangled
    def __add_transaction(self, description):
        self.__transaction_history.append(description)
    
    # Protected method — exposes private data safely
    def _get_transactions(self):
        # Return a copy to prevent modification
        return self.__transaction_history.copy()

class SavingsAccount(BankAccount):
    def __init__(self, account_holder, balance, interest_rate):
        super().__init__(account_holder, balance)
        self._interest_rate = interest_rate
    
    def apply_interest(self):
        # Cannot access __balance directly — name mangled!
        # self.__balance += interest  # This would create a NEW attribute!
        
        # Must use the public method
        balance = self.get_balance()
        interest = balance * self._interest_rate / 100
        self.deposit(interest)
        return f"Interest applied: ${interest:.2f}"

# --- Using the class ---
account = BankAccount("Alice", 1000)

print(account.deposit(500))      # Deposited $500. New balance: $1500
print(account.withdraw(200))     # Withdrew $200. New balance: $1300
print(account.get_account_info())

# Private members are NOT accessible
# print(account.__balance)        # AttributeError!
# print(account.__transaction_history)  # AttributeError!
# print(account.__generate_account_number())  # AttributeError!

# But they can be accessed via name mangling (but don't do this!)
print(account._BankAccount__balance)  # 1300 — name mangled access
print(account._BankAccount__transaction_history)

# Subclass cannot access private members
savings = SavingsAccount("Bob", 1000, 2.5)
print(savings.apply_interest())   # Interest applied: $25.00
# print(savings.__balance)        # AttributeError!
# print(savings.__transaction_history)  # AttributeError!

print("\n✅ Private members: double underscore → name mangling")
print("❌ Cannot access directly from outside")
print("⚠️ Subclasses also cannot access private members of parent")
print("🔧 Name mangling: _ClassName__name (but this is a hack)")

Private key points:

Double underscore — __name indicates private
Name mangling — changed to _ClassName__name
Not accessible outside — direct access raises AttributeError
Not accessible in subclasses — name mangling prevents
Can be accessed via mangled name — but this is a hack

Quick Check: How does Python make private members inaccessible from outside? (Answer: Name mangling — __name becomes _ClassName__name)

Name Mangling Explained

How Private Members Are Protected

Name mangling is Python's way of making private members "private." When you define an attribute with two leading underscores (__name), Python automatically changes the name to _ClassName__name.

This prevents accidental access from outside the class and prevents subclasses from accidentally overriding private methods.

# Name Mangling — How Private Members Work

class Parent:
    def __init__(self):
        self.__private = "I'm private"
        self._protected = "I'm protected"
        self.public = "I'm public"
    
    def __private_method(self):
        return "Private method called"
    
    def _protected_method(self):
        return "Protected method called"
    
    def public_method(self):
        return "Public method called"
    
    def show_private(self):
        # Can access private from inside the class
        return f"Inside: {self.__private}"

class Child(Parent):
    def __init__(self):
        super().__init__()
        # This creates a DIFFERENT attribute — not overriding parent's
        self.__private = "Child's private"
    
    def try_access_parent_private(self):
        # Cannot access parent's __private directly
        # return self.__private  # Returns child's __private, not parent's
        
        # Need to use the public method
        return self.show_private()
    
    def get_mangled_name(self):
        # The mangled name for parent's private
        return "Parent's __private becomes: _Parent__private"

# --- Demonstration ---
parent = Parent()
child = Child()

# Public — accessible
print(parent.public)              # I'm public
print(parent.public_method())     # Public method called

# Protected — accessible but discouraged
print(parent._protected)          # I'm protected
print(parent._protected_method()) # Protected method called

# Private — not directly accessible
# print(parent.__private)         # AttributeError!
# print(parent.__private_method()) # AttributeError!

# But we can see the mangled name
print(dir(parent))
# ... includes _Parent__private, _Parent__private_method

# Accessing via mangled name (hack — don't do this!)
print(parent._Parent__private)    # I'm private
print(parent._Parent__private_method())  # Private method called

# Child class
print(child._protected)           # I'm protected (inherited)
print(child.show_private())       # Inside: I'm private
print(child.try_access_parent_private())  # Inside: I'm private

# Child's own __private is different
print(child._Child__private)      # Child's private

print("\n" + "=" * 60)
print("NAME MANGLING SUMMARY")
print("=" * 60)
print("""
| Original Name | Mangled Name               | Purpose                    |
|---------------|----------------------------|----------------------------|
| __private     | _ClassName__private        | Prevent accidental access  |
| __method()    | _ClassName__method()       | Prevent subclass override  |

WHY NAME MANGLING?
1. Prevents accidental attribute access from outside
2. Prevents subclasses from accidentally overriding
3. Makes private truly private (to the class)
4. Follows the "consenting adults" principle

⚠️ Important: Name mangling is NOT security!
   It's a protection against accidents, not malicious access.
   Anyone can still access using the mangled name.
""")

Name mangling key points:

Transforms — __name → _ClassName__name
Prevents accidental access — from outside and subclasses
Allows overriding safely — subclasses can have their own __name
Not security — it's a convention, not a wall
Can be bypassed — using the mangled name directly

Quick Check: What is name mangling and why is it used? (Answer: Python changes __name to _ClassName__name to prevent accidental access and subclass overriding)

Comparison Table

Public vs Protected vs Private — Side by Side

# Access Modifiers — Complete Comparison

class AccessDemo:
    def __init__(self):
        self.public = "Public"          # No underscore
        self._protected = "Protected"   # Single underscore
        self.__private = "Private"      # Double underscore
    
    def public_method(self):
        return "Public method"
    
    def _protected_method(self):
        return "Protected method"
    
    def __private_method(self):
        return "Private method"
    
    def access_all(self):
        # Inside the class — all accessible
        return [
            self.public,
            self._protected,
            self.__private,
            self.public_method(),
            self._protected_method(),
            self.__private_method()
        ]

class Subclass(AccessDemo):
    def __init__(self):
        super().__init__()
        self.public = "Subclass public"
        self._protected = "Subclass protected"
        # self.__private = "Subclass private"  # This is different!
    
    def access_parent(self):
        # Can access public and protected from parent
        parent_public = super().public
        parent_protected = super()._protected
        
        # Cannot access parent's private directly
        # parent_private = super().__private  # AttributeError
        
        return parent_public, parent_protected

# ============================================================
# COMPARISON TABLE
# ============================================================

print("""
╔═══════════════════════╦═══════════════════════════════════════════════════════════════════════════════════╗
║ Access Modifier        ║ Visibility                                                                       ║
╠═══════════════════════╬═══════════════════════════════════════════════════════════════════════════════════╣
║                       ║  • No underscore                                                                  ║
║ PUBLIC                ║  • Accessible from anywhere                                                       ║
║ (name)                ║  • Available in subclasses                                                         ║
║                       ║  • The default for all members                                                    ║
╠═══════════════════════╬═══════════════════════════════════════════════════════════════════════════════════╣
║                       ║  • Single underscore                                                              ║
║ PROTECTED             ║  • Accessible inside class and subclasses                                         ║
║ (_name)               ║  • Can be accessed from outside (discouraged)                                     ║
║                       ║  • Signals "internal use — don't touch"                                          ║
╠═══════════════════════╬═══════════════════════════════════════════════════════════════════════════════════╣
║                       ║  • Double underscore                                                              ║
║ PRIVATE               ║  • Name mangled: _ClassName__name                                                ║
║ (__name)              ║  • Not accessible from outside (directly)                                         ║
║                       ║  • Not accessible in subclasses                                                   ║
║                       ║  • Can be accessed via mangled name (hack)                                        ║
╚═══════════════════════╩═══════════════════════════════════════════════════════════════════════════════════╝

USAGE RECOMMENDATIONS:
• PUBLIC:   Public API — safe for external use
• PROTECTED: Internal implementation — for subclasses
• PRIVATE:  Implementation detail — not for external use
""")

Comparison summary:

Public — no underscore, accessible everywhere
Protected — _name, for internal use and subclasses
Private — __name, name mangled, class-only
Outside access — public: yes, protected: yes (but discouraged), private: no (except hack)
Subclass access — public: yes, protected: yes, private: no

Quick Check: Which access modifier can subclasses access? (Answer: Public and protected — private is not accessible in subclasses)

Real-World Example

Building a Secure User System

# Real-World Example: User Management System

import hashlib
import secrets
from datetime import datetime, timedelta

class User:
    """Secure user management with access modifiers"""
    
    def __init__(self, username, email, password):
        self.username = username              # Public — user identifier
        self.email = email                    # Public — contact info
        self.__password_hash = None           # Private — password hash
        self.__failed_login_attempts = 0      # Private — security tracking
        self.__last_login = None              # Private — login tracking
        self.__session_token = None           # Private — authentication
        self.__is_locked = False              # Private — account lock
        self._role = "user"                   # Protected — for subclasses
    
        # Use protected method to set password
        self._set_password(password)
        self._log_event("Account created")
    
    # ---- PUBLIC API ----
    
    def login(self, password):
        """Public — authenticate user"""
        if self.__is_locked:
            return "Account is locked. Contact support."
        
        if self._verify_password(password):
            self.__failed_login_attempts = 0
            self.__last_login = datetime.now()
            self.__session_token = self._generate_token()
            self._log_event("Login successful")
            return f"Welcome back, {self.username}!"
        else:
            self.__failed_login_attempts += 1
            if self.__failed_login_attempts >= 3:
                self.__is_locked = True
                self._log_event("Account locked due to failed attempts")
                return "Account locked due to too many failed attempts."
            return "Invalid password."
    
    def change_password(self, old_password, new_password):
        """Public — change password with verification"""
        if not self._verify_password(old_password):
            self._log_event("Failed password change attempt")
            return "Invalid current password."
        
        if len(new_password) < 8:
            return "Password must be at least 8 characters."
        
        self._set_password(new_password)
        self.__session_token = None  # Invalidate old sessions
        self._log_event("Password changed")
        return "Password changed successfully."
    
    def logout(self):
        """Public — end session"""
        self.__session_token = None
        self._log_event("Logged out")
        return "Logged out successfully."
    
    def get_profile(self):
        """Public — get user info (safe)"""
        return {
            "username": self.username,
            "email": self.email,
            "role": self._role,
            "last_login": self.__last_login,
            "is_locked": self.__is_locked
        }
    
    def reset_account(self):
        """Public — reset security (admin only)"""
        self.__failed_login_attempts = 0
        self.__is_locked = False
        self.__session_token = None
        self._log_event("Account reset by admin")
        return "Account reset successfully."
    
    # ---- PROTECTED METHODS ----
    
    def _set_password(self, password):
        """Protected — hash and store password"""
        salt = secrets.token_hex(16)
        self.__password_hash = self._hash_password(password, salt)
    
    def _verify_password(self, password):
        """Protected — verify password against hash"""
        if self.__password_hash is None:
            return False
        # In real code, extract salt and verify
        # Simplified for demo
        return True
    
    def _hash_password(self, password, salt):
        """Protected — hash password with salt"""
        return hashlib.sha256((password + salt).encode()).hexdigest()
    
    def _generate_token(self):
        """Protected — generate session token"""
        return secrets.token_urlsafe(32)
    
    def _log_event(self, event):
        """Protected — log user activity"""
        print(f"[{datetime.now()}] {self.username}: {event}")
    
    # ---- PRIVATE METHODS (Implementation Details) ----
    
    def __validate_email(self):
        """Private — email validation (name mangled)"""
        # Implementation detail
        return "@" in self.email and "." in self.email

class AdminUser(User):
    """Admin user with additional privileges"""
    
    def __init__(self, username, email, password, admin_level):
        super().__init__(username, email, password)
        self._role = "admin"  # Protected — can modify
        self.__admin_level = admin_level  # Private
    
    def promote_user(self, user):
        """Admin action — promote a user"""
        if isinstance(user, User):
            user._role = "admin"  # Access protected member
            self._log_event(f"Promoted {user.username}")
            return f"{user.username} promoted to admin."
        return "Invalid user."
    
    def demote_user(self, user):
        """Admin action — demote a user"""
        if isinstance(user, User):
            user._role = "user"
            self._log_event(f"Demoted {user.username}")
            return f"{user.username} demoted to user."
        return "Invalid user."

# ---- DEMO ----

print("=" * 60)
print("USER MANAGEMENT SYSTEM")
print("=" * 60)

# Create users
print("\n1. CREATING USERS")
user1 = User("alice", "alice@example.com", "SecurePass123")
user2 = User("bob", "bob@example.com", "MyPassword456")
admin = AdminUser("admin", "admin@example.com", "AdminPass789", 5)

# Login attempts
print("\n2. LOGIN ATTEMPTS")
print(user1.login("wrong"))        # Invalid password.
print(user1.login("wrong"))        # Invalid password.
print(user1.login("wrong"))        # Account locked...
print(user1.login("SecurePass123")) # Account is locked. Contact support.

# Admin resets account
print("\n3. ADMIN ACTIONS")
print(admin.promote_user(user2))   # bob promoted to admin.
print(admin.reset_account(user1))  # Account reset successfully.

# User logs in again
print("\n4. LOGIN SUCCESS")
print(user1.login("SecurePass123")) # Welcome back, alice!

# Change password
print("\n5. CHANGE PASSWORD")
print(user1.change_password("SecurePass123", "NewStrongPass456"))

# Get profile
print("\n6. USER PROFILE")
print(user1.get_profile())

print("\n✅ Public: username, email, profile methods")
print("✅ Protected: _role, _set_password(), _log_event()")
print("✅ Private: __password_hash, __failed_login_attempts, __session_token")
print("✅ Encapsulation: sensitive data is protected")

Real-world example key points:

Public — username, email, login(), logout(), get_profile()
Protected — _role, _set_password(), _verify_password(), _log_event()
Private — __password_hash, __failed_login_attempts, __session_token, __is_locked
Encapsulation — sensitive data hidden behind public API
Security — password hashing, account locking, failed attempt tracking

Quick Check: Why are password hash and session token private? (Answer: To protect sensitive security data from accidental modification or access)

Best Practices

Using Access Modifiers Effectively

# Best Practices for Access Modifiers

# ============================================================
# 1. PUBLIC — The Safe API
# ============================================================

class SafeAPI:
    def __init__(self):
        self.name = "Public"  # Public — safe to access
        self._internal = "Internal"  # Protected — not part of API
        self.__secret = "Secret"  # Private — implementation detail
    
    def public_method(self):
        """This is the public API — documented and stable"""
        return "Use this method"
    
    def _internal_method(self):
        """Internal method — may change"""
        return "Don't depend on this"
    
    def __secret_method(self):
        """Implementation detail — don't touch"""
        return "This might change or disappear"

# ✅ DO: Keep public API clean and well-documented
# ✅ DO: Use public methods for all external interactions
# ❌ DON'T: Make internal details public


# ============================================================
# 2. PROTECTED — For Inheritance
# ============================================================

class BaseClass:
    def __init__(self):
        self._value = 0  # Protected — for subclasses
    
    def _helper_method(self):
        """Protected — subclasses can use this"""
        return self._value
    
    def public_method(self):
        return self._helper_method()  # Using protected method

class SubClass(BaseClass):
    def use_protected(self):
        # ✅ DO: Use protected members in subclasses
        return self._helper_method()
    
    def override_helper(self):
        # ✅ DO: Override protected methods
        self._value = 10
        return "Overridden"

# ✅ DO: Use protected for methods subclasses should override
# ✅ DO: Use protected for helpers that subclasses need
# ❌ DON'T: Expose protected members in the public API


# ============================================================
# 3. PRIVATE — For Implementation Details
# ============================================================

class DataProcessor:
    def __init__(self, data):
        self._data = data
        self.__cache = {}  # Private — caching implementation
        self.__processing_count = 0  # Private — state tracking
    
    def process(self):
        """Public API — stable and documented"""
        self.__processing_count += 1
        return self.__process_data()
    
    def __process_data(self):
        """Private — implementation detail"""
        if not self.__cache:
            self.__cache = self._build_cache()
        return self.__cache
    
    def _build_cache(self):
        """Protected — can be overridden by subclasses"""
        return {"processed": True}

# ✅ DO: Use private for implementation details
# ✅ DO: Use private for state that shouldn't change
# ✅ DO: Use private for methods that might be removed
# ❌ DON'T: Make everything private


# ============================================================
# 4. GETTERS AND SETTERS (Property Decorator)
# ============================================================

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
        self._fahrenheit = celsius * 9/5 + 32
    
    @property
    def celsius(self):
        """Getter — public access"""
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        """Setter — with validation"""
        if value < -273.15:
            raise ValueError("Temperature below absolute zero!")
        self._celsius = value
        self._fahrenheit = value * 9/5 + 32
    
    @property
    def fahrenheit(self):
        """Getter — computed property"""
        return self._fahrenheit
    
    @fahrenheit.setter
    def fahrenheit(self, value):
        self.celsius = (value - 32) * 5/9

# ✅ DO: Use properties for controlled access
# ✅ DO: Add validation in setters
# ✅ DO: Keep the internal representation private (_celsius)


# ============================================================
# 5. SUMMARY TABLE
# ============================================================

print("""
╔══════════════════════════════════════════════════════════════════════════════════╗
║ ACCESS MODIFIER BEST PRACTICES                                                  ║
╠══════════════════════════════════════════════════════════════════════════════════╣
║                                                                                 ║
║  PUBLIC (name)                                                                  ║
║  • Use for the public API of your class                                         ║
║  • Document these well                                                          ║
║  • Keep them stable — avoid breaking changes                                    ║
║  • This is what users of your class interact with                               ║
║                                                                                 ║
║  PROTECTED (_name)                                                              ║
║  • Use for internal helpers that subclasses might need                          ║
║  • Use for methods that subclasses should override                              ║
║  • Use for attributes that subclasses need access to                            ║
║  • Document that these are for internal use                                     ║
║                                                                                 ║
║  PRIVATE (__name)                                                               ║
║  • Use for implementation details that should be hidden                         ║
║  • Use for sensitive data (passwords, tokens, etc.)                             ║
║  • Use for internal state that should not be accessed                           ║
║  • Use for methods that might be removed or changed                             ║
║                                                                                 ║
║  REMEMBER:                                                                      ║
║  • Protected and private are CONVENTIONS, not security                          ║
║  • Python trusts developers to respect the conventions                          ║
║  • Private uses name mangling to prevent accidental access                      ║
║                                                                                 ║
╠══════════════════════════════════════════════════════════════════════════════════╣
║  "We're all consenting adults here." — Python Philosophy                       ║
╚══════════════════════════════════════════════════════════════════════════════════╝
""")

Best practices summary:

Public — the stable API, document well, avoid breaking changes
Protected — for subclasses, internal helpers, override points
Private — implementation details, sensitive data, can change
Properties — use @property for controlled access
Remember — these are conventions, not security walls

Quick Check: What should you use protected members for? (Answer: Internal helpers that subclasses might need or override)

Try It Yourself

Experiment with access modifiers in the editor below.

Loading Pyodide... 0%

Python Code Editor

# Python Public Private Protected - Practice

print("=" * 50)
print("ACCESS MODIFIERS - PRACTICE")
print("=" * 50)

# 1. CREATE A CLASS WITH ALL MODIFIERS
print("\n1. CLASS WITH PUBLIC, PROTECTED, PRIVATE")
class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner              # Public
        self._type = "savings"          # Protected
        self.__balance = balance        # Private
        self.__transactions = []        # Private
    
    # Public methods — the API
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            self.__add_transaction(f"Deposit: +${amount}")
            return f"✅ Deposited ${amount}. Balance: ${self.__balance}"
        return "❌ Invalid amount"
    
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            self.__add_transaction(f"Withdrawal: -${amount}")
            return f"✅ Withdrew ${amount}. Balance: ${self.__balance}"
        return "❌ Insufficient funds"
    
    def get_balance(self):
        return self.__balance
    
    def get_transactions(self):
        # Return a copy to protect the original
        return self.__transactions.copy()
    
    # Protected — for subclasses
    def _add_transaction(self, description):
        self.__transactions.append(description)
    
    # Private — implementation detail
    def __calculate_interest(self):
        # This is a private implementation detail
        return self.__balance * 0.01

class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, interest_rate):
        super().__init__(owner, balance)
        self._interest_rate = interest_rate
    
    def apply_interest(self):
        # Can access protected _add_transaction
        # Cannot access private __balance directly
        balance = self.get_balance()
        interest = balance * self._interest_rate / 100
        self.deposit(interest)
        self._add_transaction(f"Interest: +${interest:.2f}")
        return f"💰 Interest applied: ${interest:.2f}"

# 2. USING THE CLASSES
print("\n2. USING THE BANK ACCOUNT")
account = BankAccount("Alice", 1000)
print(account.deposit(500))
print(account.withdraw(200))
print(f"Balance: ${account.get_balance()}")
print(f"Transactions: {account.get_transactions()}")

# Try accessing protected and private
print("\n3. ACCESSING PROTECTED AND PRIVATE")
print(f"Protected _type: {account._type} (accessible but discouraged)")
try:
    print(f"Private __balance: {account.__balance}")
except AttributeError as e:
    print(f"❌ Cannot access __balance: {e}")

# Name mangling hack
print(f"Name mangling: {account._BankAccount__balance} (hack)")

# 4. SUBCLASS
print("\n4. SUBCLASS (SAVINGS ACCOUNT)")
savings = SavingsAccount("Bob", 2000, 2.5)
print(savings.apply_interest())
print(f"Balance: ${savings.get_balance()}")

print("\n" + "=" * 50)
print("SUMMARY:")
print("✅ Public: owner, deposit(), withdraw(), get_balance()")
print("✅ Protected: _type, _add_transaction()")
print("✅ Private: __balance, __transactions, __calculate_interest()")
print("✅ Name mangling: _BankAccount__balance")
print("=" * 50)

==================================================
ACCESS MODIFIERS - PRACTICE
==================================================

1. CLASS WITH PUBLIC, PROTECTED, PRIVATE

2. USING THE BANK ACCOUNT
✅ Deposited $500. Balance: $1500
✅ Withdrew $200. Balance: $1300
Balance: $1300
Transactions: ['Deposit: +$500', 'Withdrawal: -$200']

3. ACCESSING PROTECTED AND PRIVATE
Protected _type: savings (accessible but discouraged)
❌ Cannot access __balance: 'BankAccount' object has no attribute '__balance'
Name mangling: 1300 (hack)

4. SUBCLASS (SAVINGS ACCOUNT)
💰 Interest applied: $50.00
Balance: $2050.0

==================================================
SUMMARY:
✅ Public: owner, deposit(), withdraw(), get_balance()
✅ Protected: _type, _add_transaction()
✅ Private: __balance, __transactions, __calculate_interest()
✅ Name mangling: _BankAccount__balance
==================================================

🏆

You've Got It!

You now understand public, private, and protected access modifiers in Python. You know how to use underscores for visibility control and how name mangling works.

Quick Quiz

Test what you've learned:

1. What is the default access modifier in Python?

A) Public B) Protected C) Private D) It depends on the context

2. How do you indicate a protected member in Python?

A) No underscore — name B) Single underscore — _name C) Double underscore — __name D) Triple underscore — ___name

3. What is name mangling?

A) A way to rename methods B) Changing __name to _ClassName__name C) Deleting private attributes D) Making attributes public

4. Can a subclass access a private member of its parent class?

A) Yes, always B) Only if it's a method C) No, not directly D) Only in Python 3.8+

5. What is the purpose of access modifiers in Python?

A) To enforce strict security B) To signal intent and implement encapsulation C) To make code run faster D) To prevent all access to attributes

Frequently Asked Questions

Does Python have public, private, and protected like Java?

Python has similar concepts but uses conventions rather than keywords. Public is the default, protected uses a single underscore (_name), and private uses a double underscore (__name). However, these are not enforced — they're signals to other developers.

Can I access a private member from outside the class?

Yes, but not directly. Private members are name-mangled to _ClassName__name. You can access them using the mangled name, but you shouldn't. This is considered a hack and violates the encapsulation principle.

What's the difference between protected and private?

Protected (_name) is a convention for "internal use, but subclasses can access it." Private (__name) uses name mangling and is harder to access from outside the class. Private members are not accessible in subclasses.

When should I use protected vs private?

Use protected when you expect subclasses to need access or override the method. Use private for implementation details that shouldn't be accessed by anyone outside the class (including subclasses). Private is for "implementation details that can change."

Why doesn't Python enforce access modifiers?

Python follows the philosophy of "We're all consenting adults." The language trusts developers to use the conventions properly. Enforcing access control would make Python less flexible and go against its design principles.

What is the purpose of name mangling?

Name mangling prevents accidental access and accidental overriding. It's not for security — it's to prevent bugs where subclasses accidentally override private methods or access private attributes they shouldn't.

Where to Go From Here

Now that you understand access modifiers in Python, check out these related topics:

Previous: Abstract Class vs Interface Next: Overloading vs Overriding →

Python

Python: Public, Private and Protected

What are Access Modifiers?

Public Members

The Default Visibility

Protected Members

Single Underscore Convention

Private Members

Double Underscore and Name Mangling

Name Mangling Explained

How Private Members Are Protected

Comparison Table

Public vs Protected vs Private — Side by Side

Real-World Example

Building a Secure User System

Best Practices

Using Access Modifiers Effectively

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

Does Python have public, private, and protected like Java?

Can I access a private member from outside the class?

What's the difference between protected and private?

When should I use protected vs private?

Why doesn't Python enforce access modifiers?

What is the purpose of name mangling?

Where to Go From Here

Encapsulation in Python

Inheritance in Python

Property Decorator

Python

Python: Public, Private and Protected

What are Access Modifiers?

Public Members

The Default Visibility

Protected Members

Single Underscore Convention

Private Members

Double Underscore and Name Mangling

Name Mangling Explained

How Private Members Are Protected

Comparison Table

Public vs Protected vs Private — Side by Side

Real-World Example

Building a Secure User System

Best Practices

Using Access Modifiers Effectively

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

Does Python have public, private, and protected like Java? ▼

Can I access a private member from outside the class? ▼

What's the difference between protected and private? ▼

When should I use protected vs private? ▼

Why doesn't Python enforce access modifiers? ▼

What is the purpose of name mangling? ▼

Where to Go From Here

Encapsulation in Python

Inheritance in Python

Property Decorator

Does Python have public, private, and protected like Java?

Can I access a private member from outside the class?

What's the difference between protected and private?

When should I use protected vs private?

Why doesn't Python enforce access modifiers?

What is the purpose of name mangling?