Python不像c++或Java那样有任何私有变量。如果需要，还可以在任何时候访问任何成员变量。然而，在Python中不需要私有变量，因为在Python中公开类的成员变量并不坏。如果需要封装成员变量，可以稍后使用“@property”来实现，而不会破坏现有的客户端代码。

在Python中，单个下划线“_”用于表示方法或变量不被视为类的公共API的一部分，并且API的这一部分可以在不同版本之间更改。您可以使用这些方法和变量，但是如果您使用这个类的新版本，您的代码可能会中断。

双下划线“__”并不意味着“私有变量”。你可以使用它来定义“类本地”变量，这些变量不容易被子类覆盖。它破坏了变量名。

例如:

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

自我。__foobar的名称自动被破坏为self。在类B中，它被破坏为self._B__foobar。因此，每个子类都可以定义自己的变量__foobar，而不重写其父变量。但是没有什么可以阻止您访问以双下划线开头的变量。但是，name mangling阻止你偶然调用这些变量/方法。

我强烈建议你观看Raymond Hettinger的Python类开发工具包，它提供了一个很好的例子，为什么以及如何使用@property和“__”-实例变量。

如果您已经公开了公共变量，并且需要封装它们，那么可以使用@property。因此，您可以从最简单的解决方案开始。你可以让成员变量为public，除非你有具体的理由不这样做。这里有一个例子:

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

Python对私有标识符的支持有限，通过一个自动在任何以两个下划线开头的标识符前加上类名的特性。在大多数情况下，这对程序员来说是透明的，但最终结果是任何以这种方式命名的变量都可以用作私有变量。

更多信息请参见这里。

一般来说，与其他语言相比，Python的面向对象实现有点原始。但实际上我很享受这个过程。这是一个概念上非常简单的实现，非常适合该语言的动态风格。

它的文化。在Python中，不写入其他类的实例或类变量。在Java中，如果你真的想这样做，没有什么可以阻止你这样做——毕竟，你总是可以编辑类本身的源代码来达到同样的效果。Python放弃了安全的伪装，并鼓励程序员负责任。在实践中，这工作得非常好。

如果您出于某种原因想要模拟私有变量，您总是可以使用PEP 8中的__前缀。Python会修改像__foo这样的变量名，这样它们就不容易被包含它们的命名空间之外的代码看到(尽管如果你足够坚定，你可以绕过它，就像你可以绕过Java的保护一样)。

根据同样的约定，_前缀意味着_variable应该只在类(或模块)内部使用，即使技术上不阻止从其他地方访问它。你不会摆弄其他类的变量，比如__foo或_bar。

关于源代码(更改访问权限，从而绕过Java或c++等语言封装):

您并不总是拥有源代码，即使您拥有源代码，这些源代码也由一个只允许特定程序员访问源代码的系统管理(在专业上下文中)。通常，每个程序员都负责某些类，因此知道自己能做什么，不能做什么。源代码管理器还锁定正在修改的源代码，当然，还管理程序员的访问权限。

所以根据经验，我更相信软件而不是人。所以约定很好，但多重保护更好，比如访问管理(真正的私有变量)+源代码管理。

在下划线约定中有一种私有变量的变体。

In [5]: class Test(object):
   ...:     def __private_method(self):
   ...:         return "Boo"
   ...:     def public_method(self):
   ...:         return self.__private_method()
   ...:

In [6]: x = Test()

In [7]: x.public_method()
Out[7]: 'Boo'

In [8]: x.__private_method()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-8-fa17ce05d8bc> in <module>()
----> 1 x.__private_method()

AttributeError: 'Test' object has no attribute '__private_method'

有一些细微的区别，但是为了编程模式意识形态的纯洁性，它已经足够好了。

有一些@private decorator的例子更紧密地实现了这个概念，但你的情况可能会有所不同。可以说，也可以编写使用meta的类定义。

私有变量在Python中或多或少是一种hack:解释器会故意重命名变量。

class A:
    def __init__(self):
        self.__var = 123
    def printVar(self):
        print self.__var

现在，如果你试图在类定义之外访问__var，它会失败:

>>> x = A()
>>> x.__var # this will return error: "A has no attribute __var"

>>> x.printVar() # this gives back 123

但你可以很容易地摆脱这种情况:

>>> x.__dict__ # this will show everything that is contained in object x
               # which in this case is something like {'_A__var' : 123}

>>> x._A__var = 456 # you now know the masked name of private variables
>>> x.printVar() # this gives back 456

你可能知道OOP中的方法是这样调用的:x. printvar () => A.printVar(x)。如果A.printVar()可以访问x中的某个字段，那么这个字段也可以在A.printVar()之外访问…毕竟，函数是为可重用性而创建的，其中的语句并没有任何特殊的功能。