Warum sind Pythons "private" Methoden nicht wirklich privat?

Python gibt uns die Möglichkeit, 'private' Methoden und Variablen innerhalb einer Klasse zu erstellen, indem dem Namen doppelte Unterstriche vorangestellt werden : __myPrivateMethod(). Wie kann man das dann erklären?

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

Was ist das Problem?!

Ich werde dies ein wenig für diejenigen erklären, die das nicht ganz verstanden haben.

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

Dort habe ich eine Klasse mit einer öffentlichen und einer privaten Methode erstellt und instanziiert.

Als nächstes rufe ich seine öffentliche Methode auf.

>>> obj.myPublicMethod()
public method

Als nächstes versuche ich, seine private Methode aufzurufen.

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

Hier sieht alles gut aus; wir können es nicht nennen. Es ist in der Tat "privat". Nun, eigentlich ist es nicht. Wenn Sie dir () für das Objekt ausführen, wird eine neue magische Methode angezeigt, die Python auf magische Weise für alle Ihre "privaten" Methoden erstellt.

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

Der Name dieser neuen Methode ist immer ein Unterstrich, gefolgt vom Klassennamen, gefolgt vom Methodennamen.

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

Soviel zur Kapselung, was?

Auf jeden Fall hatte ich immer gehört, dass Python die Kapselung nicht unterstützt. Warum also überhaupt versuchen? Was gibt?

Die Namensverschlüsselung wird verwendet, um sicherzustellen, dass Unterklassen die privaten Methoden und Attribute ihrer Oberklassen nicht versehentlich überschreiben. Es soll nicht den absichtlichen Zugriff von außen verhindern.

Zum Beispiel:

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

Natürlich bricht es zusammen, wenn zwei verschiedene Klassen den gleichen Namen haben.

Beispiel einer privaten Funktion

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

Als ich zum ersten Mal von Java nach Python kam, hasste ich das. Es hat mich zu Tode erschreckt.

Heute ist es vielleicht das Einzige, was ich an Python am meisten liebe .

Ich liebe es, auf einer Plattform zu sein, auf der sich die Leute gegenseitig vertrauen und nicht das Gefühl haben, undurchdringliche Wände um ihren Code bauen zu müssen. Wenn in stark gekapselten Sprachen eine API einen Fehler aufweist und Sie herausgefunden haben, was schief geht, können Sie ihn möglicherweise immer noch nicht umgehen, da die erforderliche Methode privat ist. In Python lautet die Einstellung: "sicher". Wenn Sie denken, Sie verstehen die Situation, vielleicht haben Sie sie sogar gelesen, dann können wir nur "viel Glück!" Sagen.

Denken Sie daran, dass die Kapselung nicht einmal schwach mit "Sicherheit" zusammenhängt oder die Kinder vom Rasen fernhält. Es ist nur ein weiteres Muster, das verwendet werden sollte, um das Verständnis einer Codebasis zu erleichtern.

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

Streng genommen sind private Methoden außerhalb ihrer Klasse zugänglich, nur nicht leicht zugänglich. Nichts in Python ist wirklich privat. Intern werden die Namen privater Methoden und Attribute im laufenden Betrieb entstellt und entwirrt, damit sie unter ihren Vornamen nicht zugänglich sind. Sie können auf die __parse-Methode der MP3FileInfo-Klasse unter dem Namen _MP3FileInfo__parse zugreifen. Erkennen Sie an, dass dies interessant ist, und versprechen Sie dann, es niemals in echtem Code zu tun. Private Methoden sind aus einem bestimmten Grund privat, aber wie viele andere Dinge in Python ist ihre Privatsphäre letztendlich eine Frage der Konvention, nicht der Gewalt.

Der häufig verwendete Ausdruck lautet "Wir stimmen hier allen Erwachsenen zu". Indem Sie einen einzelnen Unterstrich (nicht verfügbar machen) oder einen doppelten Unterstrich (ausblenden) voranstellen, teilen Sie dem Benutzer Ihrer Klasse mit, dass das Mitglied in irgendeiner Weise "privat" sein soll. Sie vertrauen jedoch darauf, dass sich alle anderen verantwortungsbewusst verhalten und dies respektieren, es sei denn, sie haben einen zwingenden Grund, dies nicht zu tun (z. B. Debugger, Code-Vervollständigung).

Wenn Sie wirklich etwas Privates haben müssen, können Sie es in einer Erweiterung implementieren (z. B. in C für CPython). In den meisten Fällen lernen Sie jedoch einfach die pythonische Vorgehensweise.

Es ist nicht so, dass Sie die Privatsphäre von Mitgliedern in keiner Sprache umgehen können (Zeigerarithmetik in C ++, Reflections in .NET / Java).

Der Punkt ist, dass Sie eine Fehlermeldung erhalten, wenn Sie versuchen, die private Methode versehentlich aufzurufen. Aber wenn Sie sich in den Fuß schießen wollen, machen Sie es einfach.

Bearbeiten: Sie versuchen nicht, Ihre Sachen durch OO-Kapselung zu sichern, oder?

Die class.__stuffNamenskonvention teilt dem Programmierer mit, dass er nicht __stuffvon außen darauf zugreifen soll . Der Name Mangling macht es unwahrscheinlich, dass jemand es versehentlich tun wird.

Sie können das zwar noch umgehen, es ist sogar noch einfacher als in anderen Sprachen (die Sie übrigens auch zulassen), aber kein Python-Programmierer würde dies tun, wenn er sich um die Kapselung kümmert.

Ein ähnliches Verhalten tritt auf, wenn Modulattributnamen mit einem einzelnen Unterstrich beginnen (z. B. _foo).

Als solche bezeichnete Modulattribute werden bei Verwendung der from*Methode nicht in ein importierendes Modul kopiert , z.

from bar import *

Dies ist jedoch eine Konvention und keine Sprachbeschränkung. Dies sind keine privaten Attribute. Sie können von jedem Importeur referenziert und manipuliert werden. Einige argumentieren, dass Python aus diesem Grund keine echte Kapselung implementieren kann.

Dies ist nur eine dieser Optionen für das Sprachdesign. In gewisser Hinsicht sind sie gerechtfertigt. Sie machen es so, dass Sie ziemlich weit aus dem Weg gehen müssen, um zu versuchen, die Methode aufzurufen, und wenn Sie es wirklich so dringend brauchen, müssen Sie einen ziemlich guten Grund haben!

Debugging-Hooks und Tests kommen als mögliche Anwendungen in den Sinn, die natürlich verantwortungsbewusst eingesetzt werden.

Mit Python 3.4 ist dies das Verhalten:

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

Beachten Sie, dass die Mangling-Regeln hauptsächlich dazu dienen, Unfälle zu vermeiden. Es ist weiterhin möglich, auf eine Variable zuzugreifen oder diese zu ändern, die als privat betrachtet wird. Dies kann sogar unter besonderen Umständen nützlich sein, beispielsweise im Debugger.

Selbst wenn die Frage alt ist, hoffe ich, dass mein Ausschnitt hilfreich sein könnte.

Das wichtigste Anliegen bei privaten Methoden und Attributen ist, den Entwicklern anzuweisen, sie nicht außerhalb der Klasse aufzurufen. Dies ist die Kapselung. Man kann die Sicherheit durch Kapselung falsch verstehen. Wenn man absichtlich die von Ihnen erwähnte Syntax (unten) verwendet, möchten Sie keine Kapselung.

obj._MyClass__myPrivateMethod()

Ich bin von C # migriert und anfangs war es auch komisch für mich, aber nach einer Weile kam ich auf die Idee, dass nur die Art und Weise, wie Python-Code-Designer über OOP denken, anders ist.

Warum sind Pythons "private" Methoden nicht wirklich privat?

So wie ich es verstehe, können sie nicht privat sein. Wie könnte die Privatsphäre durchgesetzt werden?

Die offensichtliche Antwort lautet "Auf private Mitglieder kann nur über zugegriffen werden self", aber das würde nicht funktionieren - selfist in Python nichts Besonderes, es ist nichts weiter als ein häufig verwendeter Name für den ersten Parameter einer Funktion.