Edit - Stack Overflow

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Required fields*

Rev

Required fields*

Does Python have “private” variables in classes?

I'm coming from the Java world and reading Bruce Eckels' Python 3 Patterns, Recipes and Idioms.

While reading about classes, it goes on to say that in Python there is no need to declare instance variables. You just use them in the constructor, and boom, they are there.

So for example:

class Simple:
    def __init__(self, s):
        print("inside the simple constructor")
        self.s = s

    def show(self):
        print(self.s)

    def showMsg(self, msg):
        print(msg + ':', self.show())

If that’s true, then any object of class Simple can just change the value of variable s outside of the class.

For example:

if __name__ == "__main__":
    x = Simple("constructor argument")
    x.s = "test15" # this changes the value
    x.show()
    x.showMsg("A message")

In Java, we have been taught about public/private/protected variables. Those keywords make sense because at times you want variables in a class to which no one outside the class has access to.

Why is that not required in Python?

Answer*

Python does not have any private variables like C++ or Java does. You could access any member variable at any time if wanted, too. However, you don't need private variables in Python, because in Python it is not bad to expose your classes' member variables. If you have the need to encapsulate a member variable, you can do this by using "@property" later on without breaking existing client code.

In Python, the single underscore "_" is used to indicate that a method or variable is not considered as part of the public API of a class and that this part of the API could change between different versions. You can use these methods and variables, but your code could break, if you use a newer version of this class.

The double underscore "__"  does not mean a "private variable". You use it to define variables which are "class local" and which can not be easily overridden by subclasses. It mangles the variables name.

For example:

class A(object):
        def __init__(self):
            self.__foobar = None # Will be automatically mangled to self._A__foobar

class B(A):
        def __init__(self):
            self.__foobar = 1 # Will be automatically mangled to self._B__foobar

self.__foobar's name is automatically mangled to self._A__foobar in class A. In class B it is mangled to self._B__foobar. So every subclass can define its own variable __foobar without overriding its parents variable(s). But nothing prevents you from accessing variables beginning with double underscores. However, name mangling prevents you from calling this variables /methods incidentally.

I strongly recommend you watch Raymond Hettinger's [Python's class development toolkit][1] from [PyCon][2] 2013, which gives a good example why and how you should use @property and "__"-instance variables (relevant section starts at [37min 16sec][3]).

If you have exposed public variables and you have the need to encapsulate them, then you can use @property. Therefore you can start with the simplest solution possible. You can leave member variables public unless you have a concrete reason to not do so. Here is an example:

class Distance:
        def __init__(self, meter):
            self.meter = meter

d = Distance(1.0)
    print(d.meter)
    # prints 1.0

class Distance:
        def __init__(self, meter):
            # Customer request: Distances must be stored in millimeters.
            # Public available internals must be changed.
            # This would break client code in C++.
            # This is why you never expose public variables in C++ or Java.
            # However, this is Python.
            self.millimeter = meter * 1000

# In Python we have @property to the rescue.
        @property
        def meter(self):
            return self.millimeter *0.001

@meter.setter
        def meter(self, value):
            self.millimeter = value * 1000

d = Distance(1.0)
    print(d.meter)
    # prints 1.0

[1]: https://www.youtube.com/watch?v=HTLu2DFOdTg
  [2]: https://en.wikipedia.org/wiki/Python_Conference
  [3]: https://youtu.be/HTLu2DFOdTg?t=2236

Edit Summary*

Cancel

I'm going to check out that talk. Is the @property thing part of standard Python, or is it specific to an IDE?
– bballdave025
Commented Aug 20, 2019 at 6:23
Its part of the standard since python 2.6. If you should use an older version, there is still the possibility to use property builtin function, which is available since python 2.2
– Hatatister
Commented Aug 21, 2019 at 20:25
1

Sorry to mention this 4 years later, but it's bugging me . In your last example, when you're writting the setter, I think you wrote meter instead of value.
– Daniel F.
Commented Jul 19, 2022 at 23:27
You are right. I corrected the error.
– Hatatister
Commented Jul 20, 2022 at 6:32
1

This is the best answer. Java developers often forget what property and modules are for in Python.
– Alex
Commented Oct 26, 2022 at 8:48

Add a comment |

Correct minor typos or mistakes
Clarify meaning without changing it
Add related resources or links
Always respect the author’s intent
Don’t use edits to reply to the author

create code fences with backticks ` or tildes ~
```
like so
```
add language identifier to highlight code
```python
def function(foo):
print(foo)
```
put returns between paragraphs
for linebreak add 2 spaces at end
_italic_ or **bold**
indent code by 4 spaces
backtick escapes `like _so_`
quote by placing > at start of line
to make links (use https whenever possible)

<https://example.com>

[example](https://example.com)

<a href="https://example.com">example</a>

formatting help »
answering help »

Collectives™ on Stack Overflow

Does Python have “private” variables in classes?

Answer*