Protected attributes in Python - Step-by-Step Execution

Concept Flow - Protected attributes

Define class with _protected attribute

↓

Create object instance

↓

Access _protected attribute inside class

↓

Access _protected attribute outside class

↓

Modify _protected attribute

↓

Program continues

This flow shows how a protected attribute (with a single underscore) is defined and accessed inside and outside a class, highlighting that access outside is allowed but discouraged.

Execution Sample

Python

class Car:
    def __init__(self):
        self._speed = 0

car = Car()
print(car._speed)

Defines a class with a protected attribute _speed, creates an object, and prints the protected attribute.

Execution Table

Step	Action	Variable/Attribute	Value	Output
1	Define class Car with __init__	_speed	Defined as protected attribute
2	Create instance car	car	Car object created
3	Call __init__ for car	car._speed	0
4	Print car._speed	car._speed	0	0
5	End of program

💡 Program ends after printing the protected attribute value 0

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
car	undefined	Car object created	Car object with _speed=0	Car object with _speed=0
car._speed	undefined	undefined	0	0

Key Moments - 2 Insights

Why can we access the _speed attribute outside the class even though it is 'protected'?

In Python, a single underscore prefix is a convention to indicate 'protected', but it does not prevent access. As shown in step 4 of the execution_table, accessing car._speed outside the class works but is discouraged.

What happens if we try to modify the _speed attribute outside the class?

You can modify it freely because Python does not enforce protection. The underscore is just a hint to programmers. This is implied by the convention and the execution flow.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of car._speed when printed?

A Undefined

B 0

C Error

D None

💡 Hint

Check the 'Value' and 'Output' columns at step 4 in the execution_table.

At which step is the protected attribute _speed first assigned a value?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Variable/Attribute' and 'Value' columns in the execution_table to see when car._speed is set.

If we rename _speed to speed (no underscore), how would the access outside the class change?

A It would cause an error when accessed outside

B It would become private and inaccessible

C It would still be accessible without any warning

D It would require special syntax to access

💡 Hint

Recall that underscore is a convention; removing it does not restrict access (see key_moments).

Concept Snapshot

Protected attributes in Python start with a single underscore (_).
This is a convention to signal 'internal use' but does not prevent access.
You can access and modify them outside the class, but it's discouraged.
Use them to indicate 'please don't touch this' to other programmers.

Full Transcript

This visual execution shows how protected attributes work in Python. A class Car defines a protected attribute _speed with a single underscore. When an object car is created, _speed is set to 0 inside the constructor. Accessing car._speed outside the class prints 0 without error. This is because Python's single underscore is a naming convention only, not an access restriction. The execution table traces each step: defining the class, creating the object, initializing _speed, and printing it. The variable tracker shows how car and car._speed change over time. Key moments clarify that protected attributes can be accessed and modified outside the class, but it is discouraged by convention. The quiz tests understanding of when _speed is set, its value when printed, and the effect of removing the underscore. The snapshot summarizes the concept simply for quick reference.