自从我开始开发一个想要发布的包以来，我一直在考虑私有类属性和方法(后续阅读中称为成员)。它背后的想法从来都不是不可能覆盖这些成员，而是对那些接触它们的人发出警告。我想到了一些可能有用的解决办法。第一个解决方案在我最喜欢的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的新手但我有c#和JavaScript的背景。就特性而言，Python感觉像是两者的混合体。JavaScript在这方面也有问题，解决方法是创建一个闭包。这可以通过返回不同的对象来防止访问您不想公开的数据。

def print_msg(msg):
    # This is the outer enclosing function

    def printer():
        # This is the nested function
        print(msg)

    return printer  # returns the nested function


# Now let's try calling this function.
# Output: Hello
another = print_msg("Hello")
another()

https://www.programiz.com/python-programming/closure

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures#emulating_private_methods_with_closures

隐私和受保护的概念非常重要。但Python只是一个用于原型设计和快速开发的工具，可用的开发资源有限，这就是为什么Python中没有严格遵守一些保护级别的原因。你可以在类成员中使用“__”。它工作正常，但看起来不够好。对该字段的每次访问都包含这些字符。

此外，您可以注意到Python OOP概念并不完美。Smalltalk或Ruby更接近于纯OOP概念。甚至c#或Java也更接近。

Python是一个非常好的工具。但它是一种简化的面向对象语言。从语法和概念上简化。Python存在的主要目标是使开发人员能够以非常快的方式编写具有高抽象级别的易于阅读的代码。

我唯一一次使用私有变量是当我需要在写入或读取变量时做其他事情，因此我需要强制使用setter和/或getter。

正如前面所述，这又涉及到文化。我一直在工作的项目中，读取和写入其他类变量是自由的。当一个实现被弃用时，识别使用该函数的所有代码路径需要更长的时间。当强制使用setter和getter时，可以很容易地编写调试语句来识别已调用的废弃方法和调用它的代码路径。

当你在一个任何人都可以编写扩展的项目中，通知用户那些将在几个版本中消失的废弃方法，因此在升级时将模块破坏降到最低是至关重要的。

所以我的答案是;如果您和您的同事维护一个简单的代码集，那么保护类变量并不总是必要的。如果您正在编写一个可扩展的系统，那么当对核心的更改需要被使用该代码的所有扩展捕获时，它就变得必不可少。

私有变量在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不像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