Private attributes in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of accessing a private attribute directly?

Consider this Python class with a private attribute. What happens when we try to print it directly?

Python

class MyClass:
    def __init__(self):
        self.__secret = 'hidden'

obj = MyClass()
print(obj.__secret)

A hidden

B None

C AttributeError

D SyntaxError

💡 Hint

Private attributes are not accessible directly outside the class.

In Python, attributes with double underscores are name-mangled and cannot be accessed directly outside the class, causing an AttributeError.

❓ Predict Output

intermediate

How to access a private attribute using name mangling?

Given a class with a private attribute, what is the output when accessing it using name mangling?

Python

class MyClass:
    def __init__(self):
        self.__secret = 'hidden'

obj = MyClass()
print(obj._MyClass__secret)

A hidden

B AttributeError

C None

D SyntaxError

💡 Hint

Private attributes are stored with a name that includes the class name.

Python changes the name of private attributes by prefixing them with _ClassName, so accessing obj._MyClass__secret works.

❓ Predict Output

advanced

What is the output when modifying a private attribute inside a subclass?

Look at this code where a subclass tries to modify a private attribute of its parent. What is printed?

Python

class Parent:
    def __init__(self):
        self.__value = 10

class Child(Parent):
    def __init__(self):
        super().__init__()
        self.__value = 20

obj = Child()
print(obj._Parent__value)

A None

B 20

C AttributeError

D 10

💡 Hint

Private attributes are name-mangled per class, so subclass private attributes are different.

The Child class creates its own private attribute _Child__value, so _Parent__value remains 10.

❓ Predict Output

advanced

What error occurs when trying to access a private attribute with a single underscore?

What happens when you try to access an attribute with a single underscore prefix from outside the class?

Python

class MyClass:
    def __init__(self):
        self._hidden = 'secret'

obj = MyClass()
print(obj._hidden)

A secret

B AttributeError

C SyntaxError

D None

💡 Hint

Single underscore means 'protected' by convention, but no real restriction.

Attributes with a single underscore are accessible outside the class; it's just a convention to treat them as non-public.

🧠 Conceptual

expert

Why does Python use name mangling for private attributes?

Choose the best explanation for why Python uses name mangling (double underscore prefix) for private attributes.

A To make attributes completely inaccessible from outside the class, enforcing strict privacy.

B To prevent accidental access and name clashes in subclasses by changing the attribute name internally.

C To optimize memory usage by shortening attribute names at runtime.

D To allow attributes to be accessed only by functions defined in the same module.

💡 Hint

Think about how subclasses might accidentally overwrite attributes.

Python's name mangling changes attribute names to include the class name, avoiding accidental overwrites in subclasses but does not enforce strict privacy.

Practice

1. What is the main purpose of using private attributes (starting with __) in a Python class?

easy

A. To speed up the program execution

B. To hide the attribute from outside the class and protect it

C. To make the attribute accessible everywhere

D. To make the attribute a global variable

Solution

1. Step 1: Understand private attribute naming

   Private attributes start with double underscores to hide them from outside access.

2. Step 2: Purpose of hiding attributes

   This protects the data inside the object from accidental or unauthorized changes.

3. Final Answer:

   To hide the attribute from outside the class and protect it -> Option B

4. Quick Check:

   Private attributes = data protection [OK]

Hint: Private attributes start with __ to hide data inside class [OK]

Common Mistakes:

• Thinking private means accessible everywhere
• Confusing private with global variables
• Believing private speeds up code

2. Which of the following is the correct way to define a private attribute named age in a Python class?

easy

A. self.___age

B. self.age

C. self._age

D. self.__age

Solution

1. Step 1: Identify private attribute syntax

   Private attributes start with exactly two underscores, like __age.

2. Step 2: Check options

   self.__age uses self.__age, which is correct. self.age is public, self._age is protected (single underscore), self.___age has three underscores which is invalid.

3. Final Answer:

   self.__age -> Option D

4. Quick Check:

   Private attribute = double underscore [OK]

Hint: Private attribute = double underscore before name [OK]

Common Mistakes:

• Using single underscore instead of double
• Adding too many underscores
• Forgetting underscores

3. What will be the output of this code?

class Person:
    def __init__(self, name):
        self.__name = name
    def get_name(self):
        return self.__name

p = Person('Anna')
print(p.get_name())
print(p.__name)

medium

A. Anna\nAnna

B. AttributeError\nAnna

C. Anna\nAttributeError

D. AttributeError\nAttributeError

Solution

1. Step 1: Understand private attribute access

   The attribute __name is private and cannot be accessed directly outside the class.

2. Step 2: Check print statements

   Calling p.get_name() returns 'Anna' correctly. But p.__name causes AttributeError because it's private.

3. Final Answer:

   Anna\nAttributeError -> Option C

4. Quick Check:

   Private attribute direct access = AttributeError [OK]

Hint: Private attributes cause error if accessed directly outside class [OK]

Common Mistakes:

• Expecting direct access to private attribute
• Ignoring AttributeError on private access
• Confusing method call with attribute access

4. Find the error in this code and fix it:

class Car:
    def __init__(self, model):
        self.__model = model

c = Car('Tesla')
print(c.__model)

medium

A. Add a method inside class to return __model

B. No error, code runs fine

C. Remove underscores from __model

D. Change __model to _model to fix access

Solution

1. Step 1: Identify the error

   Accessing c.__model outside the class causes AttributeError because __model is private.

2. Step 2: Fix by adding a getter method

   Adding a method inside the class to return self.__model allows safe access.

3. Final Answer:

   Add a method inside class to return __model -> Option A

4. Quick Check:

   Private attribute access needs class method [OK]

Hint: Use class method to access private attributes outside class [OK]

Common Mistakes:

• Trying to access private attribute directly
• Removing underscores breaks privacy
• Ignoring need for getter method

5. You want to store a private attribute __balance in a BankAccount class and allow safe updating only through a method that adds money. Which code snippet correctly implements this?

hard

A. class BankAccount:
def __init__(self):
self.__balance = 0
def add_money(self, amount):
self.__balance += amount
def get_balance(self):
return self.__balance

B. class BankAccount:
def __init__(self):
self._balance = 0
def add_money(self, amount):
self._balance += amount
def get_balance(self):
return self._balance

C. class BankAccount:
def __init__(self):
self.balance = 0
def add_money(self, amount):
self.balance += amount
def get_balance(self):
return self.balance

D. class BankAccount:
def __init__(self):
self.__balance = 0
def add_money(self, amount):
self.balance += amount
def get_balance(self):
return self.__balance

Solution

1. Step 1: Check private attribute usage

   class BankAccount: def __init__(self): self.__balance = 0 def add_money(self, amount): self.__balance += amount def get_balance(self): return self.__balance uses self.__balance consistently and privately.

2. Step 2: Verify method updates and access

   The add_money method safely updates __balance, and get_balance returns it correctly.

3. Final Answer:

   The code using self.__balance consistently in all methods -> Option A

4. Quick Check:

   Private attribute updated only inside class methods [OK]

Hint: Update private attributes only via class methods [OK]

Common Mistakes:

• Updating private attribute outside class
• Mixing private and public attribute names
• Not providing method to access private data