Public attributes in Python - Step-by-Step Execution

Concept Flow - Public attributes

Create object

↓

Access public attribute

↓

Read or modify attribute value

↓

Use updated value in program

↓

End

This flow shows how a public attribute of an object is created, accessed, and modified directly.

Execution Sample

Python

class Car:
    def __init__(self, color):
        self.color = color

car = Car('red')
print(car.color)
car.color = 'blue'
print(car.color)

This code creates a Car object with a public attribute 'color', prints it, changes it, then prints again.

Execution Table

Step	Action	Attribute 'color' Value	Output
1	Create Car object with color='red'	red
2	Print car.color	red	red
3	Change car.color to 'blue'	blue
4	Print car.color	blue	blue
5	End of program	blue

💡 Program ends after printing updated attribute value.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
car.color	undefined	red	blue	blue

Key Moments - 2 Insights

Why can we access and change car.color directly?

Because 'color' is a public attribute, it can be accessed and modified directly as shown in steps 2 and 3 of the execution_table.

What happens if we try to access car.color before creating the object?

The attribute does not exist before object creation, so accessing it would cause an error. Step 1 shows creation where 'color' is set.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of car.color after step 3?

A 'red'

B undefined

C 'blue'

D 'green'

💡 Hint

Check the 'Attribute color Value' column at step 3 in the execution_table.

At which step does the program print the original color 'red'?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Output' column in the execution_table for the first print.

If we remove the line 'car.color = "blue"', what will be printed at step 4?

A 'red'

B 'blue'

C Error

D Nothing

💡 Hint

Without changing the attribute, it keeps its original value as shown in variable_tracker.

Concept Snapshot

Public attributes in Python classes are variables accessible directly from object instances.
They can be read or changed freely using dot notation (object.attribute).
No special methods are needed to access or modify them.
Example: obj.attr = value or print(obj.attr).
They provide simple, direct data storage in objects.

Full Transcript

This lesson shows how public attributes in Python work. We create a class Car with a public attribute 'color'. When we make a Car object, we set 'color' to 'red'. We can print this value directly using car.color. Then we change car.color to 'blue' and print it again. The execution table traces each step, showing how the attribute value changes and what is printed. Public attributes are easy to use because they allow direct access and modification without extra code. Beginners often wonder why they can change attributes directly; this is because public attributes have no access restrictions. The visual quiz tests understanding of attribute values at different steps and what happens if we skip changing the attribute. Remember, public attributes are the simplest way to store and update data inside objects.

Practice

1. What is a public attribute in a Python class?

easy

A. An attribute that can be accessed and changed from outside the class

B. An attribute that is hidden and cannot be accessed outside the class

C. A method that runs automatically when an object is created

D. A special function to delete an object

Solution

1. Step 1: Understand attribute visibility

   Public attributes are designed to be accessed and modified from outside the class.

2. Step 2: Compare options

   An attribute that can be accessed and changed from outside the class correctly describes public attributes. Options A, B, and D describe other concepts.

3. Final Answer:

   An attribute that can be accessed and changed from outside the class -> Option A

4. Quick Check:

   Public attribute = accessible outside [OK]

Hint: Public means anyone can access or change it [OK]

Common Mistakes:

• Confusing public with private attributes
• Thinking methods are attributes
• Mixing up constructors with attributes

2. Which of the following is the correct way to create a public attribute name inside a Python class constructor?

easy

A. self->name = value

B. self.name = value

C. name = self.value

D. def name(self):

Solution

1. Step 1: Recall syntax for public attributes

   Inside __init__, public attributes are created by assigning to self.attribute_name.

2. Step 2: Check each option

   self.name = value uses correct syntax: self.name = value. Others are invalid Python syntax or wrong usage.

3. Final Answer:

   self.name = value -> Option B

4. Quick Check:

   Use self.attribute = value [OK]

Hint: Use self.attribute = value inside __init__ [OK]

Common Mistakes:

• Using def instead of assignment
• Wrong arrow syntax like self->name
• Assigning attribute to name instead of self.name

3. What will be the output of this code?

class Dog:
    def __init__(self, name):
        self.name = name

my_dog = Dog('Buddy')
print(my_dog.name)

medium

A. Dog

B. Error

C. my_dog

D. Buddy

Solution

1. Step 1: Understand attribute assignment

   The constructor sets self.name to the value passed, which is 'Buddy'.

2. Step 2: Print the attribute value

   Printing my_dog.name outputs 'Buddy'.

3. Final Answer:

   Buddy -> Option D

4. Quick Check:

   Print attribute value = Buddy [OK]

Hint: Print object.attribute to see stored value [OK]

Common Mistakes:

• Expecting class name instead of attribute value
• Confusing object name with attribute
• Thinking it causes an error

4. Find the error in this code that tries to create a public attribute age:

class Person:
    def __init__(self, age):
        age = age

p = Person(30)
print(p.age)

medium

A. The attribute should be assigned to self.age, not age

B. The print statement should be print(age)

C. The constructor is missing a return statement

D. The class name should be lowercase

Solution

1. Step 1: Check attribute assignment

   Assigning age = age only creates a local variable, not an attribute of the object.

2. Step 2: Correct attribute assignment

   It should be self.age = age to create a public attribute accessible outside.

3. Final Answer:

   The attribute should be assigned to self.age, not age -> Option A

4. Quick Check:

   Use self.attribute = value to create public attribute [OK]

Hint: Always assign attributes to self.attribute inside __init__ [OK]

Common Mistakes:

• Assigning to local variable instead of self.attribute
• Trying to print variable not attached to object
• Thinking constructor needs return

5. You want to create a class Car that stores the public attributes make and year. Which code correctly creates these attributes and allows access to them?

hard

A. class Car:
def __init__(self, make, year):
self.make = make
year = self.year

my_car = Car('Toyota', 2020)
print(my_car.make, my_car.year)

B. class Car:
def __init__(self, make, year):
make = self.make
year = self.year

my_car = Car('Toyota', 2020)
print(my_car.make, my_car.year)

C. class Car:
def __init__(self, make, year):
self.make = make
self.year = year

my_car = Car('Toyota', 2020)
print(my_car.make, my_car.year)

D. class Car:
def __init__(self, make, year):
self.make = make
self.year = year

my_car = Car('Toyota', 2020)
print(make, year)

Solution

1. Step 1: Check attribute assignments

   class Car: def __init__(self, make, year): self.make = make self.year = year my_car = Car('Toyota', 2020) print(my_car.make, my_car.year) correctly assigns self.make and self.year to the passed values.

2. Step 2: Check attribute access

   class Car: def __init__(self, make, year): self.make = make self.year = year my_car = Car('Toyota', 2020) print(my_car.make, my_car.year) prints my_car.make and my_car.year, which are valid public attributes.

3. Final Answer:

   class Car: def __init__(self, make, year): self.make = make self.year = year my_car = Car('Toyota', 2020) print(my_car.make, my_car.year) -> Option C

4. Quick Check:

   Assign and access via self.attribute and object.attribute [OK]

Hint: Assign attributes to self and access via object.attribute [OK]

Common Mistakes:

• Assigning attributes backwards (make = self.make)
• Accessing attributes without object prefix
• Mixing local variables with attributes