Por que os métodos 'privados' do Python não são realmente privados?

Python nos dá a capacidade de criar métodos 'privados' e variáveis dentro de uma classe, antecedendo sublinhados duplos para o nome, assim: __myPrivateMethod(). Como, então, alguém pode explicar isso?

>>> 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!!

Qual é o problema ?!

Vou explicar isso um pouco para quem não entendeu direito.

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

O que eu fiz lá é criar uma classe com um método público e um método privado e instancia-lo.

Em seguida, chamo seu método público.

>>> obj.myPublicMethod()
public method

Em seguida, tento chamar seu método privado.

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

Tudo parece bom aqui; não podemos chamá-lo. É, de fato, "privado". Bem, na verdade não é. A execução de dir () no objeto revela um novo método mágico que o python cria magicamente para todos os seus métodos 'particulares'.

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

O nome desse novo método é sempre um sublinhado, seguido pelo nome da classe, seguido pelo nome do método.

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

Tanta coisa para encapsulamento, não é?

De qualquer forma, sempre ouvi dizer que o Python não suporta encapsulamento, então por que tentar? O que da?

A codificação de nomes é usada para garantir que as subclasses não substituam acidentalmente os métodos e atributos particulares de suas superclasses. Ele não foi projetado para impedir o acesso deliberado de fora.

Por exemplo:

>>> 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}

Obviamente, ele será quebrado se duas classes diferentes tiverem o mesmo nome.

Exemplo de função privada

import re
import inspect

class MyClass :

    def __init__(self) :
        pass

    def private_function ( self ) :
        try :
            function_call = inspect.stack()[1][4][0].strip()

            # See if the function_call has "self." in the begining
            matched = re.match( '^self\.', function_call )
            if not matched :
                print 'This is Private Function, Go Away'
                return
        except :
            print 'This is Private Function, Go Away'
            return

        # This is the real Function, only accessible inside class #
        print 'Hey, Welcome in to function'

    def public_function ( self ) :
        # i can call private function from inside the class
        self.private_function()

### End ###

Quando eu vim de Java para Python, odiei isso. Isso me assustou até a morte.

Hoje, essa pode ser a única coisa que eu mais amo no Python.

Adoro estar em uma plataforma, na qual as pessoas confiam umas nas outras e não sentem que precisam criar muros impenetráveis ​​em torno de seu código. Em linguagens fortemente encapsuladas, se uma API tiver um bug e você tiver descoberto o que está errado, você ainda poderá não conseguir solucionar o problema, porque o método necessário é privado. Em Python, a atitude é: "com certeza". Se você acha que entende a situação, talvez até a tenha lido, tudo o que podemos dizer é "boa sorte!".

Lembre-se de que o encapsulamento não está nem um pouco relacionado à "segurança" ou a manter as crianças fora do gramado. É apenas outro padrão que deve ser usado para facilitar a compreensão de uma base de código.

Em http://www.faqs.org/docs/diveintopython/fileinfo_private.html

A rigor, os métodos privados são acessíveis fora da classe, mas não são facilmente acessíveis. Nada no Python é verdadeiramente privado; internamente, os nomes dos métodos e atributos privados são mutilados e não mutilados em tempo real para torná-los inacessíveis por seus nomes. Você pode acessar o método __parse da classe MP3FileInfo com o nome _MP3FileInfo__parse. Reconheça que isso é interessante e prometa nunca fazê-lo em código real. Os métodos privados são privados por um motivo, mas, como muitas outras coisas em Python, sua privacidade é, em última análise, uma questão de convenção, não de força.

A frase comumente usada é "somos todos adultos concordantes aqui". Anexando um único sublinhado (não exponha) ou o sublinhado duplo (ocultar), você está dizendo ao usuário da sua classe que pretende que o membro seja 'privado' de alguma forma. No entanto, você está confiando que todos os demais devem se comportar com responsabilidade e respeitar isso, a menos que eles tenham um motivo convincente para não fazê-lo (por exemplo, depuradores de código, conclusão de código).

Se você realmente deve ter algo privado, pode implementá-lo em uma extensão (por exemplo, em C para CPython). Na maioria dos casos, no entanto, você simplesmente aprende a maneira pitônica de fazer as coisas.

Não é como se você absolutamente não pudesse contornar a privacidade dos membros em qualquer idioma (aritmética de ponteiros em C ++, Reflexões em .NET / Java).

O ponto é que você receberá um erro se tentar chamar o método privado por acidente. Mas se você quer dar um tiro no pé, vá em frente e faça-o.

Edit: Você não tenta proteger suas coisas por encapsulamento OO, não é?

A class.__stuffconvenção de nomenclatura permite que o programador saiba que ele não deve acessar __stuffde fora. O nome desconcertante torna improvável que alguém o faça por acidente.

É verdade que você ainda pode solucionar isso, é ainda mais fácil do que em outras linguagens (que a BTW também permite), mas nenhum programador Python faria isso se ele se importasse com o encapsulamento.

Um comportamento semelhante existe quando os nomes dos atributos do módulo começam com um único sublinhado (por exemplo, _foo).

Os atributos do módulo nomeados como tal não serão copiados para um módulo de importação ao usar o from*método, por exemplo:

from bar import *

No entanto, esta é uma convenção e não uma restrição de idioma. Esses não são atributos particulares; eles podem ser referenciados e manipulados por qualquer importador. Alguns argumentam que, por causa disso, o Python não pode implementar o verdadeiro encapsulamento.

É apenas uma dessas opções de design de idioma. Em algum nível, eles são justificados. Eles fazem com que você precise ir muito longe do seu caminho para tentar chamar o método, e se você realmente precisa muito disso, deve ter um bom motivo!

Ganchos de depuração e testes vêm à mente como possíveis aplicativos, usados ​​com responsabilidade, é claro.

Com o Python 3.4, este é o comportamento:

>>> class Foo:
        def __init__(self):
                pass
        def __privateMethod(self):
                return 3
        def invoke(self):
                return self.__privateMethod()


>>> help(Foo)
Help on class Foo in module __main__:

class Foo(builtins.object)
 |  Methods defined here:
 |
 |  __init__(self)
 |
 |  invoke(self)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)

 >>> f = Foo()
 >>> f.invoke()
 3
 >>> f.__privateMethod()
 Traceback (most recent call last):
   File "<pyshell#47>", line 1, in <module>
     f.__privateMethod()
 AttributeError: 'Foo' object has no attribute '__privateMethod'

https://docs.python.org/3/tutorial/classes.html#tut-private

Observe que as regras de confundimento são projetadas principalmente para evitar acidentes; ainda é possível acessar ou modificar uma variável considerada privada. Isso pode até ser útil em circunstâncias especiais, como no depurador.

Mesmo se a pergunta for antiga, espero que meu snippet possa ser útil.

A preocupação mais importante sobre métodos e atributos privados é dizer aos desenvolvedores para não chamá-lo fora da classe e isso é encapsulamento. pode-se entender mal a segurança do encapsulamento. quando alguém usa deliberadamente uma sintaxe como essa (abaixo) mencionada, não deseja encapsulamento.

obj._MyClass__myPrivateMethod()

Eu migrei do C # e no começo era estranho para mim também, mas depois de um tempo cheguei à ideia de que apenas a maneira como os designers de código Python pensam sobre OOP é diferente.

Por que os métodos 'privados' do Python não são realmente privados?

Pelo que entendi, eles não podem ser privados. Como a privacidade pode ser aplicada?

A resposta óbvia é que "membros privados só podem ser acessados ​​por meio self", mas isso não funcionaria - selfnão é especial no Python, nada mais é que um nome comumente usado para o primeiro parâmetro de uma função.