object.attribute vs. object.getAttribute()

[Michael Geary]

I've always disliked accessor methods in C++ and Java. I can understand the
reason for using them, but they are just so ugly.

Danger: Advice from a Python newbie follows... :-)

My suggestion would be to use Python properties, as defined with the
property() function that was added in 2.2. Best of both worlds: You get the
clean syntax of directly reading and writing properties just as if they were
attributes, but behind the scenes you've defined get/set/del functions for
each property.

Personally, I wouldn't define properties for everything--I would use
ordinary attributes wherever they do the job. The beauty is that you can
always replace an attribute with a property without having to change the
calling code--which eliminates most of the reason for using accessor methods
as you would in C++.

-Mike

Roy Smith wrote:
> For the past 6-8 months, I've spent most of my time writing C++ and a
> little bit of Java.  Both of these languages support and encourage the
> use of private data and explicit accessor functions, i.e. instead of
> writing x = foo.bar, you write x = foo.getBar().  Now that I'm back to
> writing Python, I find myself in a quandry.
>
> Historically, I've always avoided accessor functions and just reached
> directly into objects to get the value of their attributes.  Since
> Python doesn't have private data, there really isn't much advantage to
> writing accessors, but somehow I'm now finding that it just feels wrong
> not to.  I'm not sure if this feeling is just a C++/Java-ism that will
> cure itself with time, or if perhaps it really does make sense and I
> should change the way I code.
>
> On the plus side, accessors/mutators give me:
>
> 1) Implicit documentation of which attributes I intended to be part of
> an object's externally visible state (accessors).
> 2) Hooks to do data checking or invarient assertions (mutators).
> 3) Decoupling classes by hiding the details of data structures.
> 4) Vague feeling that I'm doing a good thing by being more in line with
> mainstream OO practices :-)
>
> On the minus side:
>
> 1) More typing (which implies more reading, which I think reduces the
> readability of the finished product).
> 2) Need to write (and test) all those silly little functions.
> 3) Performance hit due to function call overhead.
> 4) Only the appearance of private data (modulo some slots hackery).
> 5) Code is harder to change (adding functionality means going back and
> adding more slots).
> 6) Vague feeling that I'm dirtying myself by letting C++ and Java change
> my Python coding habits :-)
>
> Comments?