在Python 3中，如果你只是想“封装”类属性，就像在Java中一样，你可以这样做:

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

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

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

要实例化此操作:

ss = Simple("lol")
ss.show()

注意:print(ss.__s)将抛出一个错误。

实际上，Python 3会混淆全局属性名。就像在Java中一样，它将此转换为“私有”属性。属性名仍然是全局的，但是以一种不可访问的方式，就像其他语言中的私有属性一样。

但是不要害怕。没关系。它也起作用了。；）

私有变量在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()之外访问…毕竟，函数是为可重用性而创建的，其中的语句并没有任何特殊的功能。

在Python 3中，如果你只是想“封装”类属性，就像在Java中一样，你可以这样做:

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

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

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

要实例化此操作:

ss = Simple("lol")
ss.show()

注意:print(ss.__s)将抛出一个错误。

实际上，Python 3会混淆全局属性名。就像在Java中一样，它将此转换为“私有”属性。属性名仍然是全局的，但是以一种不可访问的方式，就像其他语言中的私有属性一样。

但是不要害怕。没关系。它也起作用了。；）

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

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书籍之一《Fluent Python》中使用。

技术1的优点:

它不太可能被意外覆盖。 它很容易理解和实现。 它比实例属性的前双下划线更容易处理。

*在书中使用了哈希符号，但你也可以使用整数转换为字符串。在Python中，禁止使用class .1

class Technique1:

    def __init__(self, name, value):
        setattr(self, f'private#{name}', value)
        setattr(self, f'1{name}', value)

技术1的缺点:

但是，使用这种技术不容易保护方法。这是可能的。 属性查找只能通过getattr实现 仍然没有对用户发出警告

我遇到的另一个解决方案是编写__setattr__。优点:

它很容易实现和理解 它与方法一起工作 查找不受影响 用户得到一个警告或错误

class Demonstration:

    def __init__(self):
        self.a = 1

    def method(self):
        return None

    def __setattr__(self, name, value):
        if not getattr(self, name, None):
            super().__setattr__(name, value)
        else:
            raise ValueError(f'Already reserved name: {name}')

d = Demonstration()
#d.a = 2
d.method = None

缺点:

您仍然可以重写类 为了让变量不仅仅是常量，您需要映射允许的输入。 子类仍然可以覆盖方法

为了防止子类覆盖方法，你可以使用__init_subclass__:

class Demonstration:
    __protected = ['method']

    def method(self):
        return None

    def __init_subclass__(cls):
        protected_methods = Demonstration.__protected
        subclass_methods = dir(cls)
        for i in protected_methods:
            p = getattr(Demonstration,i)
            j = getattr(cls, i)
            if not p is j:
                raise ValueError(f'Protected method "{i}" was touched')

可以看到，有很多方法可以保护类成员，但不能保证用户不会覆盖它们。这应该能给你们一些启发。最后，您还可以使用元类，但这可能会带来新的危险。这里使用的技术也非常简单，你应该看看文档，你可以找到这个技术的有用特性，并根据你的需要定制它们。

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

更多信息请参见这里。

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