Matthias Kaeppler a écrit :
(snip)
> I stumbled over this paragraph in "Python is not Java", can anyone
> elaborate on it:
>
> "In Java, you have to use getters and setters because using public
> fields gives you no opportunity to go back and change your mind later to
> using getters and setters. So in Java, you might as well get the chore
> out of the way up front. In Python, this is silly, because you can start
> with a normal attribute and change your mind at any time, without
> affecting any clients of the class. So, don't write getters and setters."
>
> Why would I want to use an attribute in Python, where I would use
> getters and setters in Java?
Because you don't *need* getters/setters - you already got'em for free
(more on this latter).
> I know that encapsulation is actually just
> a hack in Python (common, "hiding" an implementation detail by prefixing
> it with the classname so you can't access it by its name anymore? Gimme
> a break...),
You're confusing encapsulation with information hiding. The mechanism
you're refering to is not meant to 'hide' anything, only to prevent
accidental shadowing of some attributes. The common idiom for
"information hiding" in Python is to prefix 'protected' attributes with
a single underscore. This warns developers using your code that this is
implementation detail, and that there on their own if they start messing
with it. And - as incredible as this can be - that's enough.
True, this won't stop stupid programmers from doing stupid thing - but
no language is 'idiot-proof' anyway (know the old '#define private
public' C++ trick ?), so why worry ?
> but is that a reason to only write white box classes? ^^
First, what is a 'white box' class ?
public class WhiteBox {
protected integer foo;
protected integer bar;
public integer getFoo() {
return foo;
}
public void setFoo(integer newfoo) {
foo = newfoo;
}
public integer getBar() {
return bar;
}
public void setBar(integer newbar) {
bar = newbar;
}
}
Does this really qualify as a 'blackbox' ? Of course not, everything is
publicly exposed. You could have the exact same result (and much less
code) with public attributes.
Now what is the reason to write getters and setters ? Answer : so you
can change the implementation without breaking the API, right ?
Python has something named 'descriptors'. This is a mechanism that is
used for attribute lookup (notice that everything being an object,
methods are attributes too). You don't usually need to worry about it
(you should read about if you really want to understand Python's object
model), but you can still use it when you need to take control over
attribute access. One of the simplest application is 'properties' (aka
computed attributes), and here's an exemple :
class Foo(object):
def __init__(self, bar, baaz):
self.bar = bar
self._baaz = baaz
def _getbaaz(self):
return self._baaz
baaz = Property(fget=_getbaaz)
This is why you don't need explicit getters/setters in Python : they're
already there ! And you can of course change how they are implemented
without breaking the interface. Now *this* is encapsulation - and it
doesn't need much information hiding...
--
http://mail.python.org/mailman/listinfo/python-list
