Hat Python "private" Variablen in Klassen?

Ich komme aus der Java-Welt und lese Bruce Eckels ' Python 3-Muster, Rezepte und Redewendungen .

Beim Lesen über Klassen heißt es weiter, dass in Python keine Instanzvariablen deklariert werden müssen. Sie verwenden sie einfach im Konstruktor und boom, sie sind da.

Also zum Beispiel:

class Simple:
    def __init__(self, s):
        print("inside the simple constructor")
        self.s = s

    def show(self):
        print(self.s)

    def showMsg(self, msg):
        print(msg + ':', self.show())

Wenn das stimmt, kann jedes Objekt der Klasse Simpleeinfach den Wert der Variablen saußerhalb der Klasse ändern .

Zum Beispiel:

if __name__ == "__main__":
    x = Simple("constructor argument")
    x.s = "test15" # this changes the value
    x.show()
    x.showMsg("A message")

In Java wurden uns öffentliche / private / geschützte Variablen beigebracht. Diese Schlüsselwörter sind sinnvoll, da Sie manchmal Variablen in einer Klasse möchten, auf die niemand außerhalb der Klasse Zugriff hat.

Warum ist das in Python nicht erforderlich?

Es ist kulturell. In Python schreiben Sie nicht in die Instanz oder Klassenvariablen anderer Klassen. In Java hindert Sie nichts daran, dasselbe zu tun, wenn Sie es wirklich wollen - schließlich können Sie immer die Quelle der Klasse selbst bearbeiten, um den gleichen Effekt zu erzielen. Python lässt diesen Sicherheitsvorwand fallen und ermutigt Programmierer, verantwortlich zu sein. In der Praxis funktioniert das sehr gut.

Wenn Sie aus irgendeinem Grund private Variablen emulieren möchten, können Sie immer das __Präfix aus PEP 8 verwenden . Python zerlegt die Namen von Variablen __fooso, dass sie für Code außerhalb der Klasse, die sie enthält, nicht leicht sichtbar sind (obwohl Sie sie umgehen können , wenn Sie entschlossen genug sind, genauso wie Sie Javas Schutz umgehen können , wenn Sie daran arbeiten ).

Nach der gleichen Konvention _bedeutet das Präfix, dass Sie sich fernhalten, auch wenn Sie technisch nicht daran gehindert sind . Sie spielen nicht mit den Variablen einer anderen Klasse herum, die wie __foooder aussehen _bar.

Private Variablen in Python sind mehr oder weniger ein Hack: Der Interpreter benennt die Variable absichtlich um.

class A:
    def __init__(self):
        self.__var = 123
    def printVar(self):
        print self.__var

Wenn Sie nun versuchen, __varaußerhalb der Klassendefinition zuzugreifen , schlägt dies fehl:

 >>>x = A()
 >>>x.__var # this will return error: "A has no attribute __var"

 >>>x.printVar() # this gives back 123

Aber Sie können leicht damit durchkommen:

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

Sie wissen wahrscheinlich, dass Methoden in OOP folgendermaßen aufgerufen werden: x.printVar() => A.printVar(x)Wenn A.printVar()auf ein Feld in xzugegriffen werden kann , kann auf dieses Feld auch außerhalb zugegriffen werden. A.printVar()Schließlich werden Funktionen für die Wiederverwendbarkeit erstellt. Den darin enthaltenen Anweisungen wird keine besondere Befugnis verliehen.

Das Spiel ist anders, wenn ein Compiler beteiligt ist ( Datenschutz ist ein Konzept auf Compilerebene ). Es kennt die Klassendefinition mit Zugriffssteuerungsmodifikatoren, sodass Fehler auftreten können, wenn die Regeln zur Kompilierungszeit nicht befolgt werden

Wie in vielen der obigen Kommentare richtig erwähnt, vergessen wir nicht das Hauptziel von Access Modifiers: Benutzern von Code zu helfen, zu verstehen, was sich ändern soll und was nicht. Wenn Sie ein privates Feld sehen, spielen Sie nicht damit herum. Es handelt sich also hauptsächlich um syntaktischen Zucker, der in Python durch _ und __ leicht erreicht werden kann.

Es gibt eine Variation von privaten Variablen in der Unterstrichkonvention.

In [5]: class Test(object):
   ...:     def __private_method(self):
   ...:         return "Boo"
   ...:     def public_method(self):
   ...:         return self.__private_method()
   ...:     

In [6]: x = Test()

In [7]: x.public_method()
Out[7]: 'Boo'

In [8]: x.__private_method()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-8-fa17ce05d8bc> in <module>()
----> 1 x.__private_method()

AttributeError: 'Test' object has no attribute '__private_method'

Es gibt einige subtile Unterschiede, aber um die ideologische Reinheit des Programmiermusters zu gewährleisten, ist es gut genug.

Es gibt Beispiele für @ private Dekorateure, die das Konzept genauer umsetzen, aber YMMV. Man könnte wohl auch eine Klassendefinition schreiben, die Meta verwendet

"In Java wurden uns öffentliche / private / geschützte Variablen beigebracht."

"Warum ist das in Python nicht erforderlich?"

Aus dem gleichen Grund ist es in Java nicht erforderlich .

Sie sind frei zu verwenden - oder auch nicht verwenden , privateund protected.

Als Python- und Java-Programmierer habe ich das gefunden privateund bin protectedsehr, sehr wichtige Designkonzepte. Aber als eine praktische Angelegenheit, in Zehntausende von Zeilen Java und Python, ich habe nie wirklich verwendet privateoder protected.

Warum nicht?

Hier ist meine Frage "Vor wem geschützt?"

Andere Programmierer in meinem Team? Sie haben die Quelle. Was bedeutet geschützt, wenn sie es ändern können?

Andere Programmierer in anderen Teams? Sie arbeiten für die gleiche Firma. Sie können - mit einem Telefonanruf - die Quelle erhalten.

Kunden? Es ist Work-for-Hire-Programmierung (im Allgemeinen). Die Clients besitzen (im Allgemeinen) den Code.

Also, vor wem - genau - schütze ich es?

Wie bereits erwähnt, können Sie angeben, dass eine Variable oder Methode privat ist, indem Sie einen Unterstrich voranstellen. Wenn Sie nicht der Meinung sind, dass dies ausreicht, können Sie jederzeit den propertyDekorateur verwenden. Hier ist ein Beispiel:

class Foo:

    def __init__(self, bar):
        self._bar = bar

    @property
    def bar(self):
        """Getter for '_bar'."""
        return self._bar

Auf diese Weise verweist jemand oder etwas, auf das verwiesen barwird, tatsächlich auf den Rückgabewert der barFunktion und nicht auf die Variable selbst. Daher kann darauf zugegriffen, aber nicht geändert werden. Wenn jemand es wirklich wollte, konnte er es einfach verwenden _barund ihm einen neuen Wert zuweisen. Es gibt keine todsichere Möglichkeit, jemanden daran zu hindern, auf Variablen und Methoden zuzugreifen, die Sie verbergen möchten, wie wiederholt gesagt wurde. Jedoch mitproperty ist jedoch die klarste Nachricht, die Sie senden können, dass eine Variable nicht bearbeitet werden soll. propertykann auch für komplexere Zugriffspfade für Getter / Setter / Deleter verwendet werden, wie hier erläutert: https://docs.python.org/3/library/functions.html#property

Python unterstützt private Bezeichner nur eingeschränkt, da der Klassenname automatisch allen Bezeichnern vorangestellt wird, die mit zwei Unterstrichen beginnen. Dies ist für den Programmierer größtenteils transparent, aber der Nettoeffekt besteht darin, dass alle auf diese Weise benannten Variablen als private Variablen verwendet werden können.

Siehe hier .

Im Allgemeinen ist Pythons Implementierung der Objektorientierung im Vergleich zu anderen Sprachen etwas primitiv. Aber ich genieße das eigentlich. Es ist eine sehr konzeptionell einfache Implementierung und passt gut zum dynamischen Stil der Sprache.

Das einzige Mal, dass ich private Variablen verwende, ist, wenn ich beim Schreiben oder Lesen aus der Variablen andere Dinge tun muss und daher die Verwendung eines Setzers und / oder Getters erzwingen muss.

Auch dies geht, wie bereits erwähnt, an die Kultur. Ich habe an Projekten gearbeitet, in denen das Lesen und Schreiben anderer Klassenvariablen für alle kostenlos war. Als eine Implementierung veraltet war, dauerte es viel länger, alle Codepfade zu identifizieren, die diese Funktion verwendeten. Wenn die Verwendung von Setzern und Gettern erzwungen wurde, konnte leicht eine Debug-Anweisung geschrieben werden, um zu identifizieren, dass die veraltete Methode aufgerufen wurde und der Codepfad, der sie aufruft.

Wenn Sie sich in einem Projekt befinden, in dem jeder eine Erweiterung schreiben kann, ist es wichtig, Benutzer über veraltete Methoden zu informieren, die in einigen Releases verschwinden sollen, um den Modulbruch bei Upgrades so gering wie möglich zu halten.

Meine Antwort lautet also: Wenn Sie und Ihre Kollegen einen einfachen Codesatz verwalten, ist der Schutz von Klassenvariablen nicht immer erforderlich. Wenn Sie ein erweiterbares System schreiben, ist es unerlässlich, wenn Änderungen am Kern vorgenommen werden, die von allen Erweiterungen mithilfe des Codes erfasst werden müssen.

Sorry Leute, dass ihr den Thread "wiederbelebt" habt, aber ich hoffe, das wird jemandem helfen:

Wenn Sie in Python3 nur die Klassenattribute "kapseln" möchten, wie in Java, können Sie genau das Gleiche tun:

class Simple:
    def __init__(self, str):
        print("inside the simple constructor")
        self.__s = str

    def show(self):
        print(self.__s)

    def showMsg(self, msg):
        print(msg + ':', self.show())

Um dies zu instanziieren, gehen Sie wie folgt vor:

ss = Simple("lol")
ss.show()

Beachten Sie Folgendes: print(ss.__s)Gibt einen Fehler aus.

In der Praxis verschleiert Python3 den globalen Attributnamen. Drehen Sie dies wie ein "privates" Attribut, wie in Java. Der Name des Attributs ist immer noch global, jedoch nicht zugänglich, wie ein privates Attribut in anderen Sprachen.

Aber hab keine Angst davor. Es spielt keine Rolle. Es macht auch den Job. ;)

private und geschützte Konzepte sind sehr wichtig. Aber Python - nur ein Werkzeug für das Prototyping und die schnelle Entwicklung mit begrenzten Ressourcen, die für die Entwicklung zur Verfügung stehen. Deshalb werden einige Schutzstufen in Python nicht so streng eingehalten. Sie können "__" in Klassenmitgliedern verwenden, es funktioniert ordnungsgemäß, sieht aber nicht gut genug aus - jeder Zugriff auf ein solches Feld enthält diese Zeichen.

Sie können auch feststellen, dass das Python-OOP-Konzept nicht perfekt ist, Smaltalk oder Ruby viel näher am reinen OOP-Konzept. Sogar C # oder Java sind näher.

Python ist ein sehr gutes Werkzeug. Aber es ist vereinfachte OOP-Sprache. Syntaktisch und konzeptionell vereinfacht. Das Hauptziel der Python-Existenz ist es, Entwicklern die Möglichkeit zu geben, sehr schnell leicht lesbaren Code mit hohem Abstraktionsgrad zu schreiben.

Python hat keine privaten Variablen wie C ++ oder Java. Auf Wunsch können Sie auch jederzeit auf jede Mitgliedsvariable zugreifen. In Python benötigen Sie jedoch keine privaten Variablen, da es in Python nicht schlecht ist, die Variablen Ihrer Klassenmitglieder verfügbar zu machen. Wenn Sie eine Mitgliedsvariable kapseln müssen, können Sie dies später mithilfe von "@property" tun, ohne den vorhandenen Clientcode zu beschädigen.

In Python wird der einzelne Unterstrich "_" verwendet, um anzuzeigen, dass eine Methode oder Variable nicht als Teil der öffentlichen API einer Klasse betrachtet wird und dass dieser Teil der API zwischen verschiedenen Versionen wechseln kann. Sie können diese Methoden / Variablen verwenden, aber Ihr Code könnte beschädigt werden, wenn Sie eine neuere Version dieser Klasse verwenden.

Der doppelte Unterstrich "__" bedeutet keine "private Variable". Sie verwenden es, um Variablen zu definieren, die "klassenlokal" sind und von Unterklassen nicht leicht überschrieben werden können. Der Name der Variablen wird entstellt.

Zum Beispiel:

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

self .__ foobars Name wird automatisch in self._A__foobar in Klasse A entstellt. In Klasse B wird er in self._B__foobar entstellt. So kann jede Unterklasse ihre eigene Variable __foobar definieren, ohne die übergeordneten Variablen zu überschreiben. Nichts hindert Sie jedoch daran, auf Variablen zuzugreifen, die mit doppelten Unterstrichen beginnen. Das Namens-Mangling verhindert jedoch, dass Sie diese Variablen / Methoden nebenbei aufrufen.

Ich empfehle dringend, Raymond Hettingers beim Reden über das "Pythons Class Development Toolkit" von Pycon 2013 (sollte auf Youtube verfügbar sein) zuzusehen. Dies ist ein gutes Beispiel dafür, warum und wie Sie @property- und "__" - Instanzvariablen verwenden sollten.

C#Mit diesem einfachen Trick können Sie einen Getter und Setter simulieren :

class Screen(object):

    def getter_setter_y(self, y, get=True):
        if get is True:
            Screen.getter_setter_y.value = y
        else:
            return Screen.getter_setter_y.value

     def getter_setter_x(self, x, get=True):
         if get is True:
             Screen.getter_setter_x.value = x
         else:
             return Screen.getter_setter_x.value

Verwenden Sie es dann ähnlich wie in C#:

scr = Screen()
scr.getter_setter_x(100)
value =  scr.getter_setter_x(0, get=False)
print (value)

Es wird lediglich eine statische lokale Variable in einer Funktion deklariert, die eine get / set-Rolle spielt, da dies die einzige Möglichkeit ist, eine Variable über get- und set-Methoden freizugeben, ohne sie für eine Klasse oder Datei global zu machen.