what about things like __*** ?

[Gumuz]

ah great, I found asking this myself last night, too.

isn't this the same for:   __methodName(self, parm) which makes it a private
method?



"Eric Brunel" <eric.brunel at pragmadev.com> wrote in message
news:al1p8n$12d$1 at wanadoo.fr...
> black wrote:
> > Hi, all~
> >
> > when reading the tutorial I met some trouble.(Maybe trifle to you all
> > but really trouble to me)
> >
> > That is I couldnt figure out what __*** is. Here is the description of
> > that article but even confused me:
> >
> > There is limited support for class-private identifiers. Any identifier
> > of the form __spam (at least two leading underscores, at most one
> > trailing underscore) is now textually replaced with _classname__spam,
> > where classname is the current class name with leading underscore(s)
> > stripped.
> >
> > What's it trying to say please ???
>
> As a good practice in object-oriented programming, the structure of a
> class, i.e. its actual attributes, are often hidden from the outside
world.
> It's called "encapsulation". It helps to separate the interface of the
> class from the actual implementation of the methods, that shouldn't be
> known outside the class itself.
>
> Languages like C++ or Java have a native support for encapsulation, by
> allowing to declare attributes "private" or "protected". A value of a
> private or protected attribute can't be read or set by another class than
> the owner class (or one of its sub-classes for protected attributes).
>
> IIRC, before Python 2.0, there were no support at all for encapsulation in
> Python. So you could always do:
>
> class C:
>   def __init__(self):
>     self.a = 12
> o = C()
> o.a = 13
> print o.a
>
> The attribute "a" of instances of class C can be read or modified outside
> the class, and there's no (simple...) means to prevent that.
>
> From Python 2.0, there's a (limited) support for encapsulation: if the
name
> of an attribute begins with a double-underscore, it's just as if it had
> been declared private:
>
> class C:
>   def __init__(self):
>     self.__a = 12
>   def get_a(self):
>     return self.__a
> o = C()
> o.__a = 13       # Does not work
> print o.__a      # Again, does not work
> print o.get_a()  # Works
>
> class CC(C):
>   def __init__(self):
>     C.__init__(self)
>     print self.__a    # Does *not* work
>
> The attribute __a is private: it can be seen only in the class C. It's
> impossible to read or set it from outside the class, even in one of its
> sub-classes. This sounds like a big restriction, but is actually very
often
> used in OO programming.
>
> The actual mechanism involves a "name-mangling", and that's what the
> comment tried to explain. But it's not that important: the final result is
> just that any attribute beginning with a double-underscore is private.
>
> HTH
> --
> - Eric Brunel <eric.brunel at pragmadev.com> -
> PragmaDev : Real Time Software Development Tools -
http://www.pragmadev.com