# python – What’s the pythonic way to use getters and setters?

## The Question :

390 people think this question is useful

I’m doing it like:

def set_property(property,value):
def get_property(property):



or

object.property = value
value = object.property



I’m new to Python, so i’m still exploring the syntax, and i’d like some advice on doing this.

743 people think this answer is useful

Try this: Python Property

The sample code is:

class C(object):
def __init__(self):
self._x = None

@property
def x(self):
"""I'm the 'x' property."""
print("getter of x called")
return self._x

@x.setter
def x(self, value):
print("setter of x called")
self._x = value

@x.deleter
def x(self):
print("deleter of x called")
del self._x

c = C()
c.x = 'foo'  # setter called
foo = c.x    # getter called
del c.x      # deleter called



342 people think this answer is useful

## What’s the pythonic way to use getters and setters?

The “Pythonic” way is not to use “getters” and “setters”, but to use plain attributes, like the question demonstrates, and del for deleting (but the names are changed to protect the innocent… builtins):

value = 'something'

obj.attribute = value
value = obj.attribute
del obj.attribute



If later, you want to modify the setting and getting, you can do so without having to alter user code, by using the property decorator:

class Obj:
"""property demo"""
#
@property            # first decorate the getter method
def attribute(self): # This getter method name is *the* name
return self._attribute
#
@attribute.setter    # the property decorates with .setter now
def attribute(self, value):   # name, e.g. "attribute", is the same
self._attribute = value   # the "value" name isn't special
#
@attribute.deleter     # decorate with .deleter
def attribute(self):   # again, the method name is the same
del self._attribute



(Each decorator usage copies and updates the prior property object, so note that you should use the same name for each set, get, and delete function/method.

After defining the above, the original setting, getting, and deleting code is the same:

obj = Obj()
obj.attribute = value
the_value = obj.attribute
del obj.attribute



You should avoid this:

def set_property(property,value):
def get_property(property):



Firstly, the above doesn’t work, because you don’t provide an argument for the instance that the property would be set to (usually self), which would be:

class Obj:

def set_property(self, property, value): # don't do this
...
def get_property(self, property):        # don't do this either
...



Secondly, this duplicates the purpose of two special methods, __setattr__ and __getattr__.

Thirdly, we also have the setattr and getattr builtin functions.

setattr(object, 'property_name', value)
getattr(object, 'property_name', default_value)  # default is optional



The @property decorator is for creating getters and setters.

For example, we could modify the setting behavior to place restrictions the value being set:

class Protective(object):

@property
def protected_value(self):
return self._protected_value

@protected_value.setter
def protected_value(self, value):
if acceptable(value): # e.g. type or range check
self._protected_value = value



In general, we want to avoid using property and just use direct attributes.

This is what is expected by users of Python. Following the rule of least-surprise, you should try to give your users what they expect unless you have a very compelling reason to the contrary.

## Demonstration

For example, say we needed our object’s protected attribute to be an integer between 0 and 100 inclusive, and prevent its deletion, with appropriate messages to inform the user of its proper usage:

class Protective(object):
"""protected property demo"""
#
def __init__(self, start_protected_value=0):
self.protected_value = start_protected_value
#
@property
def protected_value(self):
return self._protected_value
#
@protected_value.setter
def protected_value(self, value):
if value != int(value):
raise TypeError("protected_value must be an integer")
if 0 <= value <= 100:
self._protected_value = int(value)
else:
raise ValueError("protected_value must be " +
"between 0 and 100 inclusive")
#
@protected_value.deleter
def protected_value(self):
raise AttributeError("do not delete, protected_value can be set to 0")



(Note that __init__ refers to self.protected_value but the property methods refer to self._protected_value. This is so that __init__ uses the property through the public API, ensuring it is “protected”.)

And usage:

>>> p1 = Protective(3)
>>> p1.protected_value
3
>>> p1 = Protective(5.0)
>>> p1.protected_value
5
>>> p2 = Protective(-5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in __init__
File "<stdin>", line 15, in protected_value
ValueError: protectected_value must be between 0 and 100 inclusive
>>> p1.protected_value = 7.3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 17, in protected_value
TypeError: protected_value must be an integer
>>> p1.protected_value = 101
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 15, in protected_value
ValueError: protectected_value must be between 0 and 100 inclusive
>>> del p1.protected_value
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 18, in protected_value
AttributeError: do not delete, protected_value can be set to 0



## Do the names matter?

Yes they do. .setter and .deleter make copies of the original property. This allows subclasses to properly modify behavior without altering the behavior in the parent.

class Obj:
"""property demo"""
#
@property
def get_only(self):
return self._attribute
#
@get_only.setter
def get_or_set(self, value):
self._attribute = value
#
@get_or_set.deleter
def get_set_or_delete(self):
del self._attribute



Now for this to work, you have to use the respective names:

obj = Obj()
# obj.get_only = 'value' # would error
obj.get_or_set = 'value'
obj.get_set_or_delete = 'new value'
the_value = obj.get_only
del obj.get_set_or_delete
# del obj.get_or_set # would error



I’m not sure where this would be useful, but the use-case is if you want a get, set, and/or delete-only property. Probably best to stick to semantically same property having the same name.

## Conclusion

If you later need functionality around the setting, getting, and deleting, you can add it with the property decorator.

Avoid functions named set_... and get_... – that’s what properties are for.

28 people think this answer is useful
In [1]: class test(object):
def __init__(self):
self.pants = 'pants'
@property
def p(self):
return self.pants
@p.setter
def p(self, value):
self.pants = value * 2
....:
In [2]: t = test()
In [3]: t.p
Out[3]: 'pants'
In [4]: t.p = 10
In [5]: t.p
Out[5]: 20



18 people think this answer is useful

Using @property and @attribute.setter helps you to not only use the “pythonic” way but also to check the validity of attributes both while creating the object and when altering it.

class Person(object):
def __init__(self, p_name=None):
self.name = p_name

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

@name.setter
def name(self, new_name):
if type(new_name) == str: #type checking for name property
self._name = new_name
else:
raise Exception("Invalid value for name")



By this, you actually ‘hide’ _name attribute from client developers and also perform checks on name property type. Note that by following this approach even during the initiation the setter gets called. So:

p = Person(12)



Exception: Invalid value for name



But:

>>>p = person('Mike')
>>>print(p.name)
Mike
>>>p.name = 'George'
>>>print(p.name)
George
>>>p.name = 2.3 # Causes an exception



13 people think this answer is useful

Check out the @property decorator.

6 people think this answer is useful

This is an old question but the topic is very important and always current. In case anyone wants to go beyond simple getters/setters i have wrote an article about superpowered properties in python with support for slots, observability and reduced boilerplate code.

from objects import properties, self_properties

class Car:
with properties(locals(), 'meta') as meta:

def brand(self) -> str:
"""Brand"""

def max_speed(self) -> float:
"""Maximum car speed"""

@meta.prop(listener='_on_acceleration')
def speed(self) -> float:
"""Speed of the car"""
return 0  # Default stopped

@meta.prop(listener='_on_off_listener')
def on(self) -> bool:
"""Engine state"""
return False

def __init__(self, brand: str, max_speed: float = 200):
self_properties(self, locals())

def _on_off_listener(self, prop, old, on):
if on:
print(f"{self.brand} Turned on, Runnnnnn")
else:
self._speed = 0
print(f"{self.brand} Turned off.")

def _on_acceleration(self, prop, old, speed):
if self.on:
if speed > self.max_speed:
print(f"{self.brand} {speed}km/h Bang! Engine exploded!")
self.on = False
else:
print(f"{self.brand} New speed: {speed}km/h")
else:
print(f"{self.brand} Car is off, no speed change")



This class can be used like this:

mycar = Car('Ford')

# Car is turned off
for speed in range(0, 300, 50):
mycar.speed = speed

# Car is turned on
mycar.on = True
for speed in range(0, 350, 50):
mycar.speed = speed



This code will produce the following output:

Ford Car is off, no speed change
Ford Car is off, no speed change
Ford Car is off, no speed change
Ford Car is off, no speed change
Ford Car is off, no speed change
Ford Car is off, no speed change
Ford Turned on, Runnnnnn
Ford New speed: 0km/h
Ford New speed: 50km/h
Ford New speed: 100km/h
Ford New speed: 150km/h
Ford New speed: 200km/h
Ford 250km/h Bang! Engine exploded!
Ford Turned off.
Ford Car is off, no speed change



5 people think this answer is useful

You can use accessors/mutators (i.e. @attr.setter and @property) or not, but the most important thing is to be consistent!

If you’re using @property to simply access an attribute, e.g.

class myClass:
def __init__(a):
self._a = a

@property
def a(self):
return self._a



use it to access every* attribute! It would be a bad practice to access some attributes using @property and leave some other properties public (i.e. name without an underscore) without an accessor, e.g. do not do

class myClass:
def __init__(a, b):
self.a = a
self.b = b

@property
def a(self):
return self.a



Note that self.b does not have an explicit accessor here even though it’s public.

Similarly with setters (or mutators), feel free to use @attribute.setter but be consistent! When you do e.g.

class myClass:
def __init__(a, b):
self.a = a
self.b = b

@a.setter
def a(self, value):
return self.a = value



It’s hard for me to guess your intention. On one hand you’re saying that both a and b are public (no leading underscore in their names) so I should theoretically be allowed to access/mutate (get/set) both. But then you specify an explicit mutator only for a, which tells me that maybe I should not be able to set b. Since you’ve provided an explicit mutator I am not sure if the lack of explicit accessor (@property) means I should not be able to access either of those variables or you were simply being frugal in using @property.

*The exception is when you explicitly want to make some variables accessible or mutable but not both or you want to perform some additional logic when accessing or mutating an attribute. This is when I am personally using @property and @attribute.setter (otherwise no explicit acessors/mutators for public attributes).

Lastly, PEP8 and Google Style Guide suggestions:

PEP8, Designing for Inheritance says:

For simple public data attributes, it is best to expose just the attribute name, without complicated accessor/mutator methods. Keep in mind that Python provides an easy path to future enhancement, should you find that a simple data attribute needs to grow functional behavior. In that case, use properties to hide functional implementation behind simple data attribute access syntax.

On the other hand, according to Google Style Guide Python Language Rules/Properties the recommendation is to:

Use properties in new code to access or set data where you would normally have used simple, lightweight accessor or setter methods. Properties should be created with the @property decorator.

The pros of this approach:

Readability is increased by eliminating explicit get and set method calls for simple attribute access. Allows calculations to be lazy. Considered the Pythonic way to maintain the interface of a class. In terms of performance, allowing properties bypasses needing trivial accessor methods when a direct variable access is reasonable. This also allows accessor methods to be added in the future without breaking the interface.

and cons:

Must inherit from object in Python 2. Can hide side-effects much like operator overloading. Can be confusing for subclasses.

0 people think this answer is useful

You can use the magic methods __getattribute__ and __setattr__.

class MyClass:
def __init__(self, attrvalue):
self.myattr = attrvalue
def __getattribute__(self, attr):
if attr == "myattr":
#Getter for myattr
def __setattr__(self, attr):
if attr == "myattr":
#Setter for myattr



Be aware that __getattr__ and __getattribute__ are not the same. __getattr__ is only invoked when the attribute is not found.