为什么Python的“私有”方法实际上不是私有的？ [英] Why are Python's 'private' methods not actually private?

问题描述

Python通过在名称前加双下划线，使我们能够在类中创建私有方法和变量，如下所示： __ myPrivateMethod（）。那么，如何解释这一点

Python gives us the ability to create 'private' methods and variables within a class by prepending double underscores to the name, like this: __myPrivateMethod(). How, then, can one explain this

>>> class MyClass:
...     def myPublicMethod(self):
...             print 'public method'
...     def __myPrivateMethod(self):
...             print 'this is private!!'
... 
>>> obj = MyClass()
>>> obj.myPublicMethod()
public method
>>> obj.__myPrivateMethod()
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: MyClass instance has no attribute '__myPrivateMethod'
>>> dir(obj)
['_MyClass__myPrivateMethod', '__doc__', '__module__', 'myPublicMethod']
>>> obj._MyClass__myPrivateMethod()
this is private!!

这是怎么回事？！

I

>>> class MyClass:
...     def myPublicMethod(self):
...             print 'public method'
...     def __myPrivateMethod(self):
...             print 'this is private!!'
... 
>>> obj = MyClass()

我做了什么

接下来，我将其称为公共方法。

Next, I call its public method.

>>> obj.myPublicMethod()
public method

接下来，我尝试调用其私有方法。

Next, I try and call its private method.

>>> obj.__myPrivateMethod()
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: MyClass instance has no attribute '__myPrivateMethod'

这里的一切看起来都很不错；我们无法调用它。实际上，它是私人。嗯，实际上不是。在对象上运行 dir（）会显示一个新的神奇方法，python会为您的所有私有方法神奇地创建该方法。

Everything looks good here; we're unable to call it. It is, in fact, 'private'. Well, actually it isn't. Running dir() on the object reveals a new magical method that python creates magically for all of your 'private' methods.

>>> dir(obj)
['_MyClass__myPrivateMethod', '__doc__', '__module__', 'myPublicMethod']

此新方法的名称始终是下划线，其后是类名，然后是方法名。

This new method's name is always an underscore, followed by the class name, followed by the method name.

>>> obj._MyClass__myPrivateMethod()
this is private!!

这么多封装，是吗？

无论如何，我总是听到Python不支持封装，那么为什么还要尝试呢？

In any case, I'd always heard Python doesn't support encapsulation, so why even try? What gives?

推荐答案

名称加扰用于确保子类不会意外覆盖其超类的私有方法和属性。 。并不是为了防止来自外部的故意访问。

The name scrambling is used to ensure that subclasses don't accidentally override the private methods and attributes of their superclasses. It's not designed to prevent deliberate access from outside.

例如：

>>> class Foo(object):
...     def __init__(self):
...         self.__baz = 42
...     def foo(self):
...         print self.__baz
...     
>>> class Bar(Foo):
...     def __init__(self):
...         super(Bar, self).__init__()
...         self.__baz = 21
...     def bar(self):
...         print self.__baz
...
>>> x = Bar()
>>> x.foo()
42
>>> x.bar()
21
>>> print x.__dict__
{'_Bar__baz': 21, '_Foo__baz': 42}

当然，如果两个不同的类具有相同的名称，则会崩溃。

Of course, it breaks down if two different classes have the same name.

这篇关于为什么Python的“私有”方法实际上不是私有的？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！