Protected attributes in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of accessing a protected attribute

What is the output of this Python code?

Python

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

car = Car('Tesla')
print(car._model)

A AttributeError

B Tesla

C None

D SyntaxError

💡 Hint

Protected attributes start with a single underscore but can still be accessed directly.

In Python, attributes with a single underscore (e.g., _model) are protected by convention but still accessible directly. So, car._model prints the value 'Tesla'.

❓ Predict Output

intermediate

Accessing protected attribute from subclass

What will this code print?

Python

class Animal:
    def __init__(self):
        self._sound = 'Roar'

class Lion(Animal):
    def make_sound(self):
        return self._sound

lion = Lion()
print(lion.make_sound())

A Roar

B AttributeError

C None

D TypeError

💡 Hint

Protected attributes can be accessed inside subclasses.

The subclass Lion can access the protected attribute _sound from its parent Animal. So, lion.make_sound() returns 'Roar'.

❓ Predict Output

advanced

Effect of name mangling on attribute access

What is the output of this code?

Python

class Secret:
    def __init__(self):
        self.__hidden = 'hidden_value'

s = Secret()
print(hasattr(s, '__hidden'))
print(hasattr(s, '_Secret__hidden'))

A False\nTrue

B True\nFalse

C False\nFalse

D True\nTrue

💡 Hint

Double underscore attributes are name-mangled to include the class name.

Attributes with double underscores are renamed internally to include the class name. So, __hidden becomes _Secret__hidden. The first hasattr returns False, the second True.

🧠 Conceptual

advanced

Understanding protected attribute conventions

Which statement about protected attributes in Python is correct?

A Protected attributes are enforced by Python and cannot be accessed outside the class.

B Protected attributes are the same as private attributes and use double underscores.

C Protected attributes are a naming convention and can be accessed outside the class but should not be.

D Protected attributes are automatically hidden from subclasses.

💡 Hint

Think about what the single underscore means in Python naming.

In Python, a single underscore prefix is a convention to indicate an attribute is protected. It is not enforced by the language, so the attribute can be accessed outside the class but should be treated as non-public.

❓ Predict Output

expert

Output when accessing protected attribute with property

What is the output of this code?

Python

class Box:
    def __init__(self):
        self._content = 'secret'

    @property
    def content(self):
        return self._content

b = Box()
print(b.content)
print(b._content)

A None\nsecret

B secret\nAttributeError

C AttributeError\nsecret

D secret\nsecret

💡 Hint

The property returns the protected attribute, which is also accessible directly.

The property content returns the protected attribute _content. Both b.content and b._content print 'secret'.

Practice

1. What does a single underscore prefix (e.g., _value) in a Python class attribute indicate?

easy

A. It is a public attribute accessible everywhere.

B. It is a protected attribute meant for internal use within the class and subclasses.

C. It is a private attribute that cannot be accessed outside the class.

D. It is a special Python keyword for constants.

Solution

1. Step 1: Understand underscore usage in Python

   A single underscore prefix means the attribute is intended for internal use, signaling protection but not strict privacy.

2. Step 2: Differentiate from private and public

   Private attributes use double underscores, public have no underscore, and constants are uppercase without underscores.

3. Final Answer:

   It is a protected attribute meant for internal use within the class and subclasses. -> Option B

4. Quick Check:

   Single underscore = protected attribute [OK]

Hint: Single underscore means 'protected' by convention [OK]

Common Mistakes:

• Confusing single underscore with private (double underscore)
• Thinking single underscore makes attribute inaccessible
• Assuming single underscore means public attribute

2. Which of the following is the correct way to define a protected attribute named _count inside a Python class?

easy

A. self._count = 0

B. count = 0

C. self.__count = 0

D. self.count = 0

Solution

1. Step 1: Identify protected attribute syntax

   Protected attributes start with a single underscore, so self._count is correct.

2. Step 2: Check other options

   self.count is public, self.__count is private, and count = 0 is a local variable, not an attribute.

3. Final Answer:

   self._count = 0 -> Option A

4. Quick Check:

   Protected attribute = single underscore prefix [OK]

Hint: Use single underscore for protected attributes inside classes [OK]

Common Mistakes:

• Using no underscore for protected attribute
• Using double underscore for protected instead of private
• Defining attribute without self inside methods

3. What will be the output of this code?

class MyClass:
    def __init__(self):
        self._value = 10

obj = MyClass()
print(obj._value)

medium

A. AttributeError

B. None

C. 10

D. SyntaxError

Solution

1. Step 1: Understand protected attribute access

   Protected attributes can be accessed outside the class, though it is discouraged.

2. Step 2: Check code behavior

   The attribute _value is set to 10 and printed directly, so output is 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   Protected attribute accessible outside class = 10 [OK]

Hint: Protected attributes can be read outside class [OK]

Common Mistakes:

• Expecting AttributeError when accessing protected attribute
• Confusing protected with private attributes
• Thinking protected attributes are hidden

4. Find the error in this code that tries to access a protected attribute:

class Parent:
    def __init__(self):
        self._data = 5

class Child(Parent):
    def print_data(self):
        print(self.data)

c = Child()
c.print_data()

medium

A. TypeError because of wrong method call

B. SyntaxError due to missing colon

C. No error, prints 5

D. AttributeError because self.data does not exist

Solution

1. Step 1: Check attribute names in Parent and Child

   Parent defines self._data, but Child tries to print self.data, which does not exist.

2. Step 2: Understand error type

   Accessing a non-existent attribute causes AttributeError at runtime.

3. Final Answer:

   AttributeError because self.data does not exist -> Option D

4. Quick Check:

   Wrong attribute name = AttributeError [OK]

Hint: Check exact attribute names when accessing [OK]

Common Mistakes:

• Ignoring underscore in attribute name
• Assuming protected attribute is private and inaccessible
• Confusing syntax errors with attribute errors

5. You want to create a class BankAccount with a protected attribute _balance that can be safely accessed and updated only by subclasses. Which code snippet correctly implements this?

hard

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

class SavingsAccount(BankAccount):
def deposit(self, amount):
self._balance += amount

acc = SavingsAccount(100)
acc.deposit(50)
print(acc._balance)

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

class SavingsAccount(BankAccount):
def deposit(self, amount):
self.__balance += amount

acc = SavingsAccount(100)
acc.deposit(50)
print(acc.__balance)

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

class SavingsAccount(BankAccount):
def deposit(self, amount):
self.balance += amount

acc = SavingsAccount(100)
acc.deposit(50)
print(acc.balance)

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

class SavingsAccount(BankAccount):
def deposit(self, amount):
_balance += amount

acc = SavingsAccount(100)
acc.deposit(50)
print(_balance)

Solution

1. Step 1: Identify protected attribute usage

   class BankAccount: def __init__(self, balance): self._balance = balance class SavingsAccount(BankAccount): def deposit(self, amount): self._balance += amount acc = SavingsAccount(100) acc.deposit(50) print(acc._balance) uses self._balance which is protected and accessible in subclass.

2. Step 2: Check attribute access and update

   Subclass method deposit updates self._balance correctly. Printing acc._balance shows updated value.

3. Step 3: Analyze other options

   class BankAccount: def __init__(self, balance): self.__balance = balance class SavingsAccount(BankAccount): def deposit(self, amount): self.__balance += amount acc = SavingsAccount(100) acc.deposit(50) print(acc.__balance) uses double underscore (private), so subclass cannot access __balance directly. class BankAccount: def __init__(self, balance): self.balance = balance class SavingsAccount(BankAccount): def deposit(self, amount): self.balance += amount acc = SavingsAccount(100) acc.deposit(50) print(acc.balance) uses public attribute. class BankAccount: def __init__(self, balance): _balance = balance class SavingsAccount(BankAccount): def deposit(self, amount): _balance += amount acc = SavingsAccount(100) acc.deposit(50) print(_balance) uses local variable _balance not attached to self, causing errors.

4. Final Answer:

   Uses self._balance (single underscore) in parent and subclass. -> Option A

5. Quick Check:

   Protected attribute with single underscore and subclass access = class BankAccount: def __init__(self, balance): self._balance = balance class SavingsAccount(BankAccount): def deposit(self, amount): self._balance += amount acc = SavingsAccount(100) acc.deposit(50) print(acc._balance) [OK]

Hint: Use single underscore and self. for protected attributes [OK]

Common Mistakes:

• Using double underscore for protected attribute
• Not using self. to define attributes
• Using local variables instead of instance attributes