Why Getter and setter methods in Python? - Purpose & Use Cases

The Big Idea

What if you could protect your data like a treasure chest with special keys only you control?

The Scenario

Imagine you have a simple box where you keep your favorite toy. You want to check or change what's inside, but you have to open the box every time and be very careful not to break it.

The Problem

Opening the box directly every time is risky and slow. You might accidentally drop or damage the toy. Also, if you want to add rules like only certain people can open it, you have no easy way to do that.

The Solution

Getter and setter methods act like special doors on the box. They let you safely look inside or change what's in the box, while keeping control and protecting the toy from harm or mistakes.

Before vs After

✗ Before

class ToyBox:
    def __init__(self, toy):
        self.toy = toy

box = ToyBox('car')
print(box.toy)
box.toy = 'doll'

✓ After

class ToyBox:
    def __init__(self, toy):
        self._toy = toy
    def get_toy(self):
        return self._toy
    def set_toy(self, new_toy):
        self._toy = new_toy

box = ToyBox('car')
print(box.get_toy())
box.set_toy('doll')

What It Enables

It lets you control how data is accessed or changed, making your program safer and easier to fix or improve later.

Real Life Example

Think of a bank account where you can check your balance or add money. You don't want anyone to set your balance to a wrong number directly, so getters and setters keep it safe.

Key Takeaways

Direct access to data can cause mistakes or unsafe changes.

Getter and setter methods provide controlled access to data.

This helps protect and manage your program's important information.

Practice

1. What is the main purpose of getter and setter methods in a Python class?

easy

A. To create new classes dynamically

B. To control access to private attributes safely

C. To execute code asynchronously

D. To delete objects from memory

Solution

1. Step 1: Understand getter and setter roles

   Getter methods retrieve attribute values, and setter methods update them while controlling access.

2. Step 2: Identify their purpose in encapsulation

   They protect private data by allowing controlled reading and writing, preventing direct access.

3. Final Answer:

   To control access to private attributes safely -> Option B

4. Quick Check:

   Getter/setter = control private data [OK]

Hint: Getters and setters manage private data access [OK]

Common Mistakes:

• Thinking they create new classes
• Confusing with asynchronous code
• Assuming they delete objects

2. Which of the following is the correct syntax to define a setter method for attribute age using the @property decorator in Python?

easy

A. @property.setter\ndef set_age(self, value):\n self._age = value

B. @setter.age\ndef age(self, value):\n self._age = value

C. @age.setter\ndef age(self, value):\n self._age = value

D. @age.setter\ndef set_age(self):\n self._age = value

Solution

1. Step 1: Recall setter syntax with @property

   The setter uses @attribute.setter decorator and method name matches the attribute.

2. Step 2: Check method signature

   Setter method takes self and value parameters to set the attribute.

3. Final Answer:

   @age.setter\ndef age(self, value):\n self._age = value -> Option C

4. Quick Check:

   Setter uses @age.setter and method age(self, value) [OK]

Hint: Setter uses @attribute.setter and method named attribute [OK]

Common Mistakes:

• Using wrong decorator like @setter.age
• Method name not matching attribute
• Setter missing value parameter

3. What will be the output of the following code?

class Person:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        self._name = value.upper()

p = Person('alice')
p.name = 'bob'
print(p.name)

medium

A. bob

B. Error

C. alice

D. BOB

Solution

1. Step 1: Understand setter behavior

   Setter converts the assigned value to uppercase before storing it.

2. Step 2: Trace code execution

   Initially name is 'alice', then set to 'bob' which setter changes to 'BOB'. Printing returns 'BOB'.

3. Final Answer:

   BOB -> Option D

4. Quick Check:

   Setter uppercases value, output = BOB [OK]

Hint: Setter modifies value before storing, output reflects change [OK]

Common Mistakes:

• Expecting original lowercase 'bob'
• Thinking print shows initial 'alice'
• Assuming code raises error

4. Identify the error in this code snippet using getter and setter methods:

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

    @property
    def speed(self):
        return self._speed

    @speed.setter
    def speed(self):
        self._speed = 100

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

medium

A. Setter method missing value parameter

B. Getter method missing return statement

C. Property decorator used incorrectly

D. No error, code runs fine

Solution

1. Step 1: Check setter method signature

   Setter must accept two parameters: self and value to set the attribute.

2. Step 2: Identify missing parameter

   Current setter only has self, missing value parameter, causing error on assignment.

3. Final Answer:

   Setter method missing value parameter -> Option A

4. Quick Check:

   Setter needs (self, value) parameters [OK]

Hint: Setter must have value parameter besides self [OK]

Common Mistakes:

• Omitting value parameter in setter
• Confusing getter and setter decorators
• Assuming code runs without error

5. You want to create a class Temperature that stores temperature in Celsius internally but allows getting and setting the temperature in Fahrenheit using getter and setter methods. Which code correctly implements this behavior?

hard

A. class Temperature:
def __init__(self, celsius=0):
self._celsius = celsius

@property
def fahrenheit(self):
return (self._celsius * 9/5) + 32

@fahrenheit.setter
def fahrenheit(self, value):
self._celsius = (value - 32) * 5/9

B. class Temperature:
def __init__(self, fahrenheit=32):
self._fahrenheit = fahrenheit

@property
def celsius(self):
return (self._fahrenheit - 32) * 5/9

@celsius.setter
def celsius(self, value):
self._fahrenheit = (value * 9/5) + 32

C. class Temperature:
def __init__(self, celsius=0):
self.celsius = celsius

@property
def fahrenheit(self):
return (self.celsius * 9/5) + 32

@fahrenheit.setter
def fahrenheit(self, value):
self.celsius = (value - 32) * 5/9

D. class Temperature:
def __init__(self, fahrenheit=32):
self.fahrenheit = fahrenheit

@property
def celsius(self):
return (self.fahrenheit - 32) * 5/9

@celsius.setter
def celsius(self, value):
self.fahrenheit = (value * 9/5) + 32

Solution

1. Step 1: Understand internal storage and interface

   The class stores temperature internally in Celsius (_celsius) but exposes Fahrenheit via getter and setter.

2. Step 2: Check getter and setter calculations

   Getter converts Celsius to Fahrenheit; setter converts Fahrenheit to Celsius and stores it.

3. Step 3: Verify correct use of private attribute and decorators

   class Temperature: def __init__(self, celsius=0): self._celsius = celsius @property def fahrenheit(self): return (self._celsius * 9/5) + 32 @fahrenheit.setter def fahrenheit(self, value): self._celsius = (value - 32) * 5/9 uses _celsius internally and @property/@fahrenheit.setter correctly.

4. Final Answer:

   Option A code correctly implements the behavior -> Option A

5. Quick Check:

   Internal Celsius, getter/setter convert Fahrenheit [OK]

Hint: Store Celsius internally, convert in getter/setter for Fahrenheit [OK]

Common Mistakes:

• Storing Fahrenheit internally instead of Celsius
• Using public attributes without underscore
• Mixing getter/setter names and attributes