Why are Python's 'private' methods not actually private? Why are Python's 'private' methods not actually private? python python

Why are Python's 'private' methods not actually private?


The name scrambling is used to ensure that subclasses don't accidentally override the private methods and attributes of their superclasses. It's not designed to prevent deliberate access from outside.

For example:

>>> class Foo(object):...     def __init__(self):...         self.__baz = 42...     def foo(self):...         print self.__baz...     >>> class Bar(Foo):...     def __init__(self):...         super(Bar, self).__init__()...         self.__baz = 21...     def bar(self):...         print self.__baz...>>> x = Bar()>>> x.foo()42>>> x.bar()21>>> print x.__dict__{'_Bar__baz': 21, '_Foo__baz': 42}

Of course, it breaks down if two different classes have the same name.


Example of private function

import reimport inspectclass MyClass :    def __init__(self) :        pass    def private_function ( self ) :        try :            function_call = inspect.stack()[1][4][0].strip()            # See if the function_call has "self." in the begining            matched = re.match( '^self\.', function_call )            if not matched :                print 'This is Private Function, Go Away'                return        except :            print 'This is Private Function, Go Away'            return        # This is the real Function, only accessible inside class #        print 'Hey, Welcome in to function'    def public_function ( self ) :        # i can call private function from inside the class        self.private_function()### End ###


When I first came from Java to Python I hated this. It scared me to death.

Today it might just be the one thing I love most about Python.

I love being on a platform, where people trust each other and don't feel like they need to build impenetrable walls around their code. In strongly encapsulated languages, if an API has a bug, and you have figured out what goes wrong, you may still be unable to work around it because the needed method is private. In Python the attitude is: "sure". If you think you understand the situation, perhaps you have even read it, then all we can say is "good luck!".

Remember, encapsulation is not even weakly related to "security", or keeping the kids off the lawn. It is just another pattern that should be used to make a code base easier to understand.


matomo