About getters and setters in Python

UncleZeiv — Tue, 25 Aug 2009 18:43:34 +0000

Recently I’ve been developing a fairly large Python application, involving a somewhat articulate and deep class hierarchy. With time, I ended up writing a certain amount of getters and setters which felt suspiciously unpythonic. Looking for better solutions I stumbled upon a number of sources making fun of people writing getters and setters in Python (e.g. Python Is Not Java), because:

there’s no real data member protection in Python anyway (“we are all consenting adults here”)
if you later want to embed some logic in the retrieval of an attribute, you can keep the same interface by just adding a property

These arguments were so compelling that made me feel pretty stupid. Consequently, I immediately started converting all my getters and setters into variables or, when needed, into properties.

Unfortunately, it soon became apparent that I had not considered all the facets of the problem. Problems surfaced soon, primarily because, as I had to find out the hard way, avoiding getters/setters does not play that well with inheritance.

First of all, overriding the access of an attribute becomes a bit quirky — despite being perfectly acceptable when using getters. In particular, the child class must know if a certain attribute is indeed an attribute or a property — and this already breaks the promise of keeping the switch from variable to property a local change.

1
2
3
4
5
6
7
8
9
10
11
12

class Foo(object):
@property
def foo(self):
return 5

class Bar(Foo):
@property
def foo(self):
return Foo.foo.fget(self) + 1

print Foo().foo # 5
print Bar().foo # 6

The syntax gets really cumbersome. For instance, if you want to override only the getter or the setter, verbosity ensues:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Foo(object):
@property
def foo(self):
return 5

@foo.setter
def foo(self, val):
print val

# one way to do that
class Bar1(Foo):
@property
def foo(self):
return Foo.foo.fget(self) + 1

@foo.setter
def foo(self, val):
return Foo.foo.fset(self, val)

# another way
class Bar2(Foo):
def foo_get(self):
return Foo.foo.fget(self) + 1

def foo_set(self, val):
return Foo.foo.fset(self, val)

foo = property(foo_get, foo_set)

Foo().foo = 4
Bar1().foo = 3
Bar2().foo = 2

Granted, true Pythoners would say that this is not Python’s fault but mine, as I have evidently made some wrong, or at least unpythonic, design decisions at a higher level. That’s an acceptable criticism, but I still think that the organization of my program was fair when employing getters and setters. Most importantly, though, the consequences of substituting them in class hierarchies where overriding is common have not been sufficiently explained by the previously mentioned Internet sources.

In other words, sometimes “practicality beats purity“!

Egocentric pumpkin

UncleZeiv — Fri, 31 Oct 2008 00:34:32 +0000

I’m back from the Blender Conference, which was very stimulating as always. For some reason, it’s very easy to hang out with the other participants, and to relate with people you’ve never heard of as if they were close friends! My opinion is that Blender hits a soft spot between technical and artistic interests (and possibly even ethical, because of the open source part): this makes the overall atmosphere one of… tasteful nerdiness I would say

By the way let me stress once again how kind and helpful are all the top Blender heads, despite their success in the field. @ndy and Bassam are always in for a chat, and Brecht is always painstakingly giving guidance to hordes of famelic developers fighting their way through Blender’s codebase (I was one of them by the way!).

Anyway. It suddenly occurred to me that since my initial involvement in the Summer of Code, I have almost completely stopped using Blender, apart from setting up test scenes.

This is why today I took the time to carry out a small Halloween-themed project. Actually, I don’t care at all about Halloween, but anthropomorphic pumpkins are undeniably a fun subject.

Egocentric pumpkin

The project eventually turned out to be mostly a programming effort after all. The blend file contains two scenes:

the pumpkin scene, where a Python script link takes care to move the camera and the eyes of the pumpkin randomly at each frame, also setting random values for a couple of shape keys and changing the color of the background
the “Polaroids” scene, where a number of randomly rotated objects display the frames rendered in the other scene (all assignments were carried out through Python scripting again)

The artistic quality of the result is pretty questionable, but, hey, if someone wants to improve shading, modeling, or whatever, here is the halloween.blend blend file to play with.

Egocentric pumpkin (monocolor)

UncleZeiv's Corner » python

About getters and setters in Python

Egocentric pumpkin