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

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

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

自从我开始开发一个想要发布的包以来，我一直在考虑私有类属性和方法(后续阅读中称为成员)。它背后的想法从来都不是不可能覆盖这些成员，而是对那些接触它们的人发出警告。我想到了一些可能有用的解决办法。第一个解决方案在我最喜欢的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的面向对象实现有点原始。但实际上我很享受这个过程。这是一个概念上非常简单的实现，非常适合该语言的动态风格。

如前所述，可以通过在变量或方法前面加上下划线来表示它是私有的。如果您觉得这还不够，还可以使用属性装饰器。这里有一个例子:

class Foo:

    def __init__(self, bar):
        self._bar = bar

    @property
    def bar(self):
        """Getter for '_bar'."""
        return self._bar

This way, someone or something that references bar is actually referencing the return value of the bar function rather than the variable itself, and therefore it can be accessed but not changed. However, if someone really wanted to, they could simply use _bar and assign a new value to it. There is no surefire way to prevent someone from accessing variables and methods that you wish to hide, as has been said repeatedly. However, using property is the clearest message you can send that a variable is not to be edited. property can also be used for more complex getter/setter/deleter access paths, as explained here: https://docs.python.org/3/library/functions.html#property

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

正如上面许多评论所正确提到的，让我们不要忘记Access Modifiers的主要目标:帮助代码的用户理解应该改变什么，不应该改变什么。当你看到一个私有的字段时，你不要乱摆弄它。所以它主要是语法糖，这在Python中很容易通过_和__实现。