Modifying object state in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this code modifying object attributes?

Look at the code below. What will be printed after running it?

Python

class Box:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def resize(self, new_length, new_width):
        self.length = new_length
        self.width = new_width

box = Box(5, 3)
box.resize(10, 6)
print(box.length, box.width)

A 10 3

B 5 3

C 10 6

D 5 6

💡 Hint

Think about what the resize method does to the object's attributes.

The resize method changes the length and width attributes of the box object to 10 and 6 respectively. So, printing them shows 10 6.

❓ Predict Output

intermediate

What will be the value of the counter after method calls?

Consider this class that modifies its internal counter. What is the final value printed?

Python

class Counter:
    def __init__(self):
        self.count = 0

    def increment(self):
        self.count += 1

    def reset(self):
        self.count = 0

c = Counter()
c.increment()
c.increment()
c.reset()
c.increment()
print(c.count)

A 0

B 1

C 3

D 2

💡 Hint

Follow the changes to count step by step.

The counter increments twice to 2, then resets to 0, then increments once more to 1. So the final value is 1.

❓ Predict Output

advanced

What is the output when modifying a mutable attribute inside a method?

What will this code print?

Python

class Basket:
    def __init__(self):
        self.items = []

    def add_item(self, item):
        self.items.append(item)

b = Basket()
b.add_item('apple')
b.add_item('banana')
print(b.items)

A ['apple', 'banana']

B ['apple']

C []

D ['banana']

💡 Hint

Think about how the list items changes when you append new elements.

The add_item method adds each item to the items list. After adding 'apple' and 'banana', the list contains both.

❓ Predict Output

advanced

What error occurs when modifying a non-existent attribute?

What happens when this code runs?

Python

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

car = Car('Sedan')
car.speed = 60
print(car.speed)
print(car.color)

A 60 followed by AttributeError

B 60 followed by 0

C AttributeError at car.speed assignment

D 60 followed by null

💡 Hint

Check which attributes exist and which do not.

Assigning car.speed = 60 creates the attribute speed. Printing it shows 60. But car.color was never set, so accessing it raises AttributeError.

🧠 Conceptual

expert

Which option correctly modifies the object's state to track history?

You want to keep track of all values assigned to an attribute value in an object. Which code correctly updates the history each time value changes?

A

class Tracker:
    def __init__(self):
        self.value = None
        self.history = []
    
    def update(self, new_value):
        self.value = new_value
        self.history = [new_value]

B

class Tracker:
    def __init__(self):
        self.value = None
        self.history = []
    
    def set_value(self, new_value):
        self.value = new_value
        self.history.append(new_value)

C

class Tracker:
    def __init__(self):
        self.value = None
        self.history = []
    
    def value(self, new_value):
        self.value = new_value
        self.history.append(new_value)

D

class Tracker:
    def __init__(self):
        self._value = None
        self.history = []
    
    @property
    def value(self):
        return self._value
    
    @value.setter
    def value(self, new_value):
        self._value = new_value
        self.history.append(new_value)

💡 Hint

Think about how to run code automatically when an attribute changes.

Option D uses a property setter to update _value and append to history every time value changes. This tracks all changes correctly.

Other options either don't use property setters or overwrite history incorrectly.

Practice

1. What does it mean to modify the state of an object in Python?

easy

A. Changing the values of its attributes

B. Creating a new object

C. Deleting the object

D. Printing the object

Solution

1. Step 1: Understand object state

   The state of an object is stored in its attributes (variables inside the object).

2. Step 2: What modifying state means

   Modifying state means changing these attribute values to new ones.

3. Final Answer:

   Changing the values of its attributes -> Option A

4. Quick Check:

   Modify state = change attribute values [OK]

Hint: State means attribute values; changing them modifies state [OK]

Common Mistakes:

• Confusing creating a new object with modifying state
• Thinking printing changes state
• Mixing deleting object with modifying state

2. Which of the following is the correct way to change an object's attribute color to 'blue'?

easy

A. object.color('blue')

B. object->color = 'blue'

C. object.color = 'blue'

D. object[color] = 'blue'

Solution

1. Step 1: Attribute assignment syntax

   In Python, to change an attribute, use dot notation: object.attribute = value.

2. Step 2: Check each option

   object.color = 'blue' uses correct dot notation. Options A, B, and C use invalid syntax for attribute assignment.

3. Final Answer:

   object.color = 'blue' -> Option C

4. Quick Check:

   Use dot and = to assign attribute [OK]

Hint: Use dot and equals to set attribute: object.attr = value [OK]

Common Mistakes:

• Using brackets [] instead of dot for attributes
• Using arrow -> which is not Python syntax
• Trying to call attribute like a function

3. What will be the output of this code?

class Box:
    def __init__(self):
        self.size = 5

    def enlarge(self):
        self.size += 3

b = Box()
b.enlarge()
print(b.size)

medium

A. 5

B. 8

C. 3

D. Error

Solution

1. Step 1: Initial attribute value

   The Box object b starts with size = 5 from __init__.

2. Step 2: Method enlarge changes size

   Calling b.enlarge() adds 3 to size, so size becomes 5 + 3 = 8.

3. Final Answer:

   8 -> Option B

4. Quick Check:

   5 + 3 = 8 [OK]

Hint: Add changes inside method to attribute value [OK]

Common Mistakes:

• Forgetting method changes attribute
• Thinking size resets after method call
• Expecting error due to method call

4. Find the error in this code that tries to update an object's attribute:

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

    def accelerate(self):
        speed += 10

c = Car()
c.accelerate()
print(c.speed)

medium

A. Using speed without self inside accelerate method

B. Missing self in accelerate method parameter

C. Incorrect print statement syntax

D. No error, code runs fine

Solution

1. Step 1: Check method parameter

   accelerate has self parameter, so it can access attributes.

2. Step 2: Identify attribute update

   Inside accelerate, speed += 10 tries to update speed but misses self. It should be self.speed += 10.

3. Final Answer:

   Using speed without self inside accelerate method -> Option A

4. Quick Check:

   Use self.speed to modify attribute [OK]

Hint: Always use self.attribute to change object state inside methods [OK]

Common Mistakes:

• Forgetting self. before attribute inside methods
• Thinking print syntax is wrong
• Assuming missing self parameter causes error here

5. You want to keep track of how many times a method use() is called on an object. Which is the best way to modify the object state to do this?

hard

A. Delete the object after each use() call

B. Print a message every time use() is called

C. Create a new object each time use() is called

D. Add an attribute count initialized to 0 and increase it inside use()

Solution

1. Step 1: Understand tracking calls

   To count calls, store a number in the object that updates each time.

2. Step 2: Modify state properly

   Initialize an attribute count = 0, then increase it by 1 inside use() method.

3. Final Answer:

   Add an attribute count initialized to 0 and increase it inside use() -> Option D

4. Quick Check:

   Use attribute to track count [OK]

Hint: Use attribute counter updated inside method to track calls [OK]

Common Mistakes:

• Just printing without storing count
• Creating new objects instead of updating state
• Deleting object removes all state