Protected attributes in Python - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a protected attribute named _value in the class.

Python

class MyClass:
    def __init__(self, val):
        self.[1] = val

Drag options to blanks, or click blank then click option'

A__value

Bvalue

C_value

Dvalue_

Attempts:

3 left

💡 Hint

Common Mistakes

Using no underscore or double underscore for protected attributes.

Protected attributes in Python are named with a single underscore prefix, like _value.

2fill in blank

medium

Complete the code to access the protected attribute _value inside a method of the class.

Python

class MyClass:
    def __init__(self, val):
        self._value = val
    def get_value(self):
        return self.[1]

Drag options to blanks, or click blank then click option'

Avalue

B_value

C__value

Dval

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to access the attribute without the underscore or with double underscores.

Inside the class, you access the protected attribute using its exact name with a single underscore: _value.

3fill in blank

hard

Fix the error in accessing the protected attribute from outside the class.

Python

obj = MyClass(10)
print(obj.[1])

Drag options to blanks, or click blank then click option'

A__value

Bvalue

Cval

D_value

Attempts:

3 left

💡 Hint

Common Mistakes

Using double underscores or no underscore when accessing the attribute.

Protected attributes can be accessed from outside the class using the single underscore name, like obj._value, though it is discouraged.

4fill in blank

hard

Fill both blanks to create a subclass that accesses the protected attribute of its parent class.

Python

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

class Child(Parent):
    def show_value(self):
        return [1].[2]

Drag options to blanks, or click blank then click option'

Aself

BParent

C_value

D__value

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to access the attribute via the class name or using double underscores.

The subclass accesses the protected attribute using self._value.

5fill in blank

hard

Fill all three blanks to define a class with a protected attribute, a method to set it, and a method to get it.

Python

class Data:
    def __init__(self):
        self.[1] = None
    def set_value(self, val):
        self.[2] = val
    def get_value(self):
        return self.[3]

Drag options to blanks, or click blank then click option'

A_data

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names or missing the underscore in some places.

The protected attribute is named _data. The methods set and get this attribute using the same name.

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