Python – Accessing private class variable

classpropertiespythonpython-2.7scope

While learning Python, I came accross this strange behavior :

Consider this simple class :

class Human(object):
  def __init__(self, name):
    self.__name = name

  def description(self):
    print("Hello, my name is %s" % self.__name)

I want to avoid being able to alter the name after the object has been created.

If I use this :

MyHuman = Human("Andy")
MyHuman.__name = "Arthur"
MyHuman.age = 23

MyHuman.description()
print MyHuman.age

It doesn't change the name after the object instanciation, which is good because I want the instance variable to be private. On the other hand, I thought it would complain about accessing this variable. It doesn't even complain about accessing a mysterious "age" variable and prints it properly later.

I come from C# and it seems odd to me. Where is my mistake ?

Best Answer

You should know the following:

When you write to an attribute of an object, that does not exist, the python system will normally not complain, but just create a new attribute.
Private attributes are not protected by the Python system. That is by design decision.
Private attributes will be masked. The reason is, that there should be no clashes in the inheritance chain. The masking is done by some implicit renaming. Private attributes will have the real name

  "_<className>__<attributeName>"

With that name, it can be accessed from outside. When accessed from inside the class, the name will be automatically changed correctly.

Related Solutions

Python – Are static class variables possible in Python

Variables declared inside the class definition, but not inside a method are class or static variables:

>>> class MyClass:
...     i = 3
...
>>> MyClass.i
3

As @millerdev points out, this creates a class-level i variable, but this is distinct from any instance-level i variable, so you could have

>>> m = MyClass()
>>> m.i = 4
>>> MyClass.i, m.i
>>> (3, 4)

This is different from C++ and Java, but not so different from C#, where a static member can't be accessed using a reference to an instance.

See what the Python tutorial has to say on the subject of classes and class objects.

@Steve Johnson has already answered regarding static methods, also documented under "Built-in Functions" in the Python Library Reference.

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

@beidy recommends classmethods over staticmethod, as the method then receives the class type as the first argument, but I'm still a little fuzzy on the advantages of this approach over staticmethod. If you are too, then it probably doesn't matter.

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.

Best Answer

Related Solutions

Python – Are static class variables possible in Python

Python – Why are Python’s ‘private’ methods not actually private

Related Topic