Python 中的私有成员

Question

如何在 Python 中将方法和数据成员设为私有？或者Python不支持私有成员？

Answer 1

9.6。私有变量

“私有”实例变量
除从内部外无法访问
一个对象，Python中不存在。
然而，有一个约定是
大多数 Python 代码后面跟着：名称
带有下划线前缀（例如
_spam) 应被视为 API 的非公开部分（无论是
是一个函数、一个方法或者一个数据
成员）。它应该被视为
实施细节并受
更改恕不另行通知。

因为有一个有效的用例
类私有成员（即避免
名字与名字的冲突
由子类定义），有
对这种机制的支持有限，
称为名称修改。任何标识符
__spam 形式（至少两个
前导下划线，最多一个
尾随下划线）在文本上是
替换为 _classname__spam，其中
classname 是当前类名
删除前导下划线。
这种破坏是在不考虑的情况下完成的
的句法位置
标识符，只要出现
在类的定义中。

因此，例如

class Test:
    def __private_symbol(self):
        pass
    def normal_symbol(self):
        pass
 
print dir(Test)

将输出：

['_Test__private_symbol', 
'__doc__', 
'__module__', 
'normal_symbol']

__private_symbol应该被考虑一个私有方法，但仍然可以通过 _Test__private_symbol 访问它。

Answer 2

其他答案提供了技术细节。一方面，我想强调 Python 与 C++/Java 等语言（根据您的问题，我认为您很熟悉）之间的哲学差异。

Python（以及 Perl）的普遍态度是，属性的​​“隐私”是对程序员的请求，而不是编译器/解释器的铁丝网。这个想法在此邮件中得到了很好的总结，并且经常被引用“我们都是同意的成年人”，因为它“假设”程序员有足够的责任不干涉内部。前导下划线用作礼貌消息，表明该属性是内部属性。

另一方面，如果您确实想要访问某些应用程序的内部结构（一个值得注意的例子是像 pydoc 这样的文档生成器），您可以随意这样做。作为一名程序员，你有责任知道自己在做什么并正确地完成它，而不是语言强迫你按它的方式做事。

Answer 3

Python 中没有任何其他访问保护机制的 private。 Python 风格指南 中记录了一个约定，用于向用户指示你的班级他们不应该访问某些属性。

• _single_leading_underscore：弱“内部使用”指示符。例如 from M import * 不会导入名称以下划线开头的对象。

• single_trailing_underscore_：按约定使用以避免与Python关键字冲突，例如Tkinter.Toplevel(master, class_='ClassName')

• __double_leading_underscore：命名类属性时，调用名称修饰（在类 FooBar 中，__boo 变为 _FooBar__boo；见下文）。

Answer 4

如果是 Python 函数的名称，
类方法或属性开头
（但不以）两个
下划线，它是私有的； 一切
否则是公开的。 Python没有概念
受保护类方法（可访问
只在自己的阶级和后代中
类）。类方法是
私有（只能在自己的
类）或公共（可从
任何地方）。

深入了解 Python

Answer 5

Python 不直接支持隐私。程序员需要知道何时可以安全地从外部修改属性，但无论如何使用 python，你可以通过一些小技巧实现诸如 private 之类的东西。
现在让我们看看一个人是否可以将任何内容设为私有。

class Person(object):

    def __priva(self):
        print "I am Private"
   
    def publ(self):
        print " I am public"
   
    def callpriva(self):
        self.__priva()

现在当我们执行时：

>>> p = Person()
>>> p.publ()
 I am public
>>> p.__priva()
Traceback (most recent call last):
  File "", line 1, in 
    p.__priva()
AttributeError: 'Person' object has no attribute '__priva'
​#Explanation   : You can see  here we are not able to fetch that private method directly.
>>> p.callpriva()
I am Private
#​Explanation  : Here we can access private method inside class​

那么某人如何访问该变量???
你可以这样做：

>>> p._Person__priva
I am Private

哇，实际上，如果 python 获取任何以双下划线开头的变量，则通过在开头添加一个下划线和类名来“翻译”：

注意：如果你不想要这样名称更改，但您仍然想发送信号让其他对象远离，您可以使用单个初始下划线名称，带有初始下划线的名称不会通过带星号的导入导入（来自模块导入*）
示例：

#test.py
def hello():
    print "hello"
def _hello():
    print "Hello private"

#----------------------

#test2.py
from test import *
print hello()
print _hello()

输出-->

hello
Traceback (most recent call last):
  File "", line 1, in 
NameError: name '_hello' is not defined

现在，如果我们手动调用 _hello 。

#test2.py
from test import _hello , hello
print hello()
print _hello()

输出-->

hello
hello private

最后：Python 并没有真正具有同等的隐私支持，尽管是单一的
首字母双下划线在某种程度上确实为您提供了两个级别的隐私

Answer 6

这可能有效：

import sys, functools

def private(member):
    @functools.wraps(member)
    def wrapper(*function_args):
      myself = member.__name__
      caller = sys._getframe(1).f_code.co_name
      if (not caller in dir(function_args[0]) and not caller is myself):
         raise Exception("%s called by %s is private"%(myself,caller))
      return member(*function_args)
    return wrapper

class test:
   def public_method(self):
      print('public method called')

   @private
   def private_method(self):
      print('private method called')

t = test()
t.public_method()
t.private_method()

Answer 7

这是一个有点长的答案，但我认为它触及了真正问题的根源——可见范围。当我艰难地完成这个任务时，请坚持住！

简单地导入模块并不一定能让应用程序开发人员访问其所有类或方法；如果我实际上无法查看模块源代码，我如何知道可用的内容？有人（或某件事）必须告诉我我能做什么，并解释如何使用我被允许使用的功能，否则整件事对我来说毫无用处。

那些通过导入模块基于基本类和方法开发更高级别抽象的人会收到一份规范文档——而不是实际的源代码。

模块规范描述了客户端开发人员可见的所有功能。在处理大型项目和软件项目团队时，模块的实际实现应该始终对使用它的人隐藏——它是一个带有外部世界接口的黑匣子。对于 OOD 纯粹主义者来说，我认为技术术语是“解耦”和“连贯性”。模块用户只需要知道接口方法，而不必担心实现细节。

在没有首先更改其底层规范文档的情况下，切勿更改模块，这可能需要在某些组织中进行审查/批准才能更改代码。

作为业余程序员（现已退休），我启动了一个新模块，其中规范文档实际上写成模块顶部的巨大注释块，这将是用户在规范库中实际看到的部分。由于只有我一个人，所以我还没有建立一个库，但这很容易做到。

然后我开始编码，编写各种类和方法，但没有函数体——只有像“print()”这样的空打印语句——足以让模块编译而没有语法错误。当这一步完成后，我编译完成的空模块——这是我的规范。如果我在项目团队工作，我会提出这个规范/界面以供审查和使用。在继续充实身体之前进行评论。

我一次充实每个方法的主体并进行相应的编译，确保立即修复语法错误。这也是开始在底部编写临时“主”执行部分以在编码时测试每个方法的好时机。编码/测试完成后，所有测试代码都会被注释掉，直到您再次需要它（如果需要更新）。

在现实世界的开发团队中，规范注释块也会出现在文档控制库中，但那是另一回事了。要点是：作为模块客户端，您只能看到此规范，而不是源代码。

PS：早在时间开始之前，我就在国防航空航天社区工作，我们做了一些非常酷的事情，但是诸如专有算法和敏感系统控制逻辑之类的东西都在超级安全软件库中严格存储和加密。我们可以访问模块/包接口，但不能访问黑盒实现主体。有一个文档管理工具可以处理所有系统级设计、软件规格、源代码和测试记录——所有这些都同步在一起。政府对软件质量保证标准有严格的要求。有人记得一种叫做“Ada”的语言吗？我才多大岁数啊！

Answer 8

PEP 8

“方法名称和实例变量”部分 https://peps.python.org/pep-0008/#method-names-and-instance-variables

仅对非公共方法和实例变量使用一个前导下划线。

为了避免与子类发生名称冲突，请使用两个前导下划线来调用 Python 的名称修饰规则。

Python 将这些名称与类名混合在一起：如果类 Foo 有一个名为 __a 的属性，则 Foo.__a 无法访问它。 （坚持不懈的用户仍然可以通过调用 Foo._Foo__a 来获得访问权限。）通常，双前导下划线应该仅用于避免与设计为子类化的类中的属性发生名称冲突。

注意：关于 __names 的使用存在一些争议（见下文）。

“为继承而设计”部分
“ https://peps.python.org/pep-0008/#designing -用于继承

始终决定类的方法和实例变量（统称为“属性”）应该是公共的还是非公共的。如有疑问，请选择非公开；稍后将其公开比将公共属性设为非公开更容易。

公共属性是您期望与您的类无关的客户端使用的属性，并且您承诺避免向后不兼容的更改。非公共属性是指那些不打算被第三方使用的属性；您不保证非公共属性不会更改甚至被删除。

我们在这里不使用术语“私有”，因为在 Python 中没有属性是真正私有的（通常不需要做不必要的工作）。

另一类属性是“子类 API”的一部分（在其他语言中通常称为“受保护”）。有些类被设计为继承、扩展或修改类行为的各个方面。在设计这样的类时，请注意明确决定哪些属性是公共的，哪些是子类 API 的一部分，以及哪些确实只能由基类使用。

考虑到这一点，以下是 Pythonic 指南：

• 公共属性不应有前导下划线。

• 如果您的公共属性名称与保留关键字冲突，请在您的属性名称后添加一个尾随下划线。这比缩写或损坏的拼写更好。 （但是，尽管有这条规则，“cls”是任何已知为类的变量或参数的首选拼写，尤其是类方法的第一个参数。）

  注释 1：请参阅上面的类方法的参数名称建议。

• 对于简单的公共数据属性，最好只公开属性名称，而不需要复杂的访问器/修改器方法。请记住，如果您发现简单的数据属性需要扩展功能行为，Python 提供了一条未来增强的简单途径。在这种情况下，请使用属性将功能实现隐藏在简单的数据属性访问语法后面。

  注 1：尽量保持功能行为没有副作用，尽管缓存等副作用通常是没问题的。

  注2：避免使用属性进行计算量大的操作；属性表示法使调用者相信访问（相对）便宜。

• 如果您的类打算进行子类化，并且您有不希望子类使用的属性，请考虑使用双前导下划线命名它们，并且不使用尾随下划线。这会调用 Python 的名称修饰算法，其中类的名称被修饰为属性名称。如果子类无意中包含同名的属性，这有助于避免属性名称冲突。

  注意1：请注意，重整名称中仅使用简单的类名称，因此如果子类选择相同的类名称和属性名称，仍然可能会发生名称冲突。

  注释 2：名称修改可能会降低某些用途（例如调试和 getattr()）的便利性。然而，名称修饰算法有详细记录并且易于手动执行。

  注 3：并不是每个人都喜欢名称修改。尝试在避免意外名称冲突的需要与高级调用者的潜在使用之间取得平衡。

Answer 9

import inspect


class Number:
    def __init__(self, value):
        self.my_private = value

    def set_private(self, value):
        self.my_private = value

    def __setattr__(self, my_private, value):
        f = inspect.stack()[1][3]
        if f not in ['__init__', 'set_private']:
            raise Exception("can't access private member-my_private")
        # the default behavior
        self.__dict__[my_private] = value


def main():
    n = Number(2)
    print(n.my_private)
    n.set_private(3)
    print(n.my_private)


if __name__ == '__main__': 
    main()

Answer 10

我使用 Python 2.7 和 3.5。我写了这段代码：

class MyOBject(object):
    def __init__(self):
        self.__private_field = 10


my_object = MyOBject()
print(my_object.__private_field)

运行它并得到：

AttributeError：“MyOBject”对象没有属性“__private_field”

请参阅：
https://www.tutorialsteacher.com/python/ python 中的私有和受保护访问修饰符