Hat Python "private" Variablen in Klassen?

578

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?

Allgegenwärtig
quelle
17
Sie bedeuten Beispiel Variablen, nicht Klassenvariablen, nicht wahr?
PaulMcG
13
Sie sollten die Eigenschaften überprüfen: docs.python.org/library/functions.html#property . Verwenden Sie einfach den Getter und Ihre Variable wird geschützt.
Rubik
Eine kurze und klare Antwort ist hier . Ich hoffe das wird helfen.
Premkumar Chalmeti

Antworten:

962

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.

Kirk Strauser
quelle
14
Das macht Sinn. Ich glaube jedoch nicht, dass es in Java eine Möglichkeit gibt, auf private Variablen außerhalb der Klasse zuzugreifen (außer die Quelle der Kursklasse tatsächlich zu ändern). Gibt es?
Allgegenwärtig
168
Ich bevorzuge eher den Python-Weg, aber ich denke nicht, dass der Java-Weg so sinnlos ist, wie Sie es ausmachen. Wenn Sie schnell etwas Privates deklarieren, sagt dies jemandem, der den Code liest, etwas sehr Nützliches: Dieses Feld wird immer nur innerhalb dieser Klasse geändert.
Ned
67
@ Omnipresent, Sie können Reflexion verwenden.
Rapadura
76
Lassen Sie mich das klarstellen, damit Python keine öffentlichen oder privaten Attribute implementiert, weil "es ein Sicherheitsvorwand ist und Programmierer dazu ermutigt, verantwortlich zu sein". Die Community empfiehlt jedoch die Verwendung von "_", um private Variablen und Methoden zu bezeichnen. Vielleicht sollte Python definitiv ein öffentliches und privates Nein haben? Ihr Hauptzweck ist es, Ihnen mitzuteilen, welche API Sie für die Interaktion mit einer Klasse verwenden sollten. Sie dienen als Dokumentation, in der Sie aufgefordert werden, diese Methoden zu verwenden und diese nicht zu verwenden. Sie sind kein "Sicherheitsvorwand", sondern eine API-Dokumentation, die sogar von der IDE als Leitfaden verwendet werden kann!
PedroD
19
Dies ist eine gute Antwort und Ihre Argumentation ist sicherlich gültig, aber ich bin mit einem Aspekt nicht einverstanden. Der Zweck von Zugriffsmodifikatoren war nie die Sicherheit . Sie sind vielmehr ein Mittel, um explizit abzugrenzen (und in hohem Maße durchzusetzen), welche Teile einer Klasse als intern betrachtet werden und welche externen Benutzern dieser Klasse ausgesetzt sind. Konventionen (Kultur) sind sicherlich eine gültige Alternative zu Zugriffsmodifikatoren, und beide Methoden haben ihre Vor- und Nachteile, aber es ist irreführend, dass Zugriffsmodifikatoren auf Sprachebene in irgendeiner Weise im üblichen Sinne des Wortes "sicher" sein sollen Wort.
Devios1
159

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

watashiSHUN
quelle
3
Kurz gesagt, dies ist keine Kapselung
Watashi Shun
2
Ich frage mich, ob PHP etwas Ähnliches mit seinen doofen privaten Variablen hat - da private Variablen in der interpretierten Sprache nicht wirklich Sinn machen - ich meine, welche Optimierung kann es tun, wenn x Variable privat ist, wenn es nicht kompiliert wird?
NoBugs
1
Wie können wir das Muster privater Variablen randomisieren?
Crisron
@ Crisron gleiche Frage
IanS
5
@watashiSHUN "kurz gesagt, dies ist keine Kapselung" => ja, das ist es. Bei der Kapselung wird nur die öffentliche API verwendet, sodass der Clientcode vor Implementierungsänderungen geschützt ist. Namenskonventionen sind eine absolut gültige Methode, um festzustellen, was API und was Implementierung ist, und der Punkt ist, dass es einfach funktioniert.
Bruno Desthuilliers
30

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.

Ardavan
quelle
4
Ich denke, das ist ein ebenso wichtiger Punkt wie jeder andere. Wenn Sie Code debuggen (ich weiß, ich bin ein Schwächling, um Fehler einzuführen), vereinfacht das Wissen, welche Klassen eine Mitgliedsvariable ändern können, den Debugging-Prozess. Zumindest, wenn die Variable durch einen bestimmten Bereich geschützt ist. Ein ähnliches Konzept sind const-Funktionen in C ++. Ich weiß, dass Mitgliedsvariablen dort nicht geändert wurden, und daher betrachte ich diese Methode nicht einmal als mögliche Ursache für eine schlechte Variableneinstellung. Obwohl die spätere Entwicklung von Klassenerweiterungen / Hinzufügen von Funktionen möglich ist, erleichtert das Einschränken der Sichtbarkeit von Code das Debuggen.
MrMas
18

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

Shayne
quelle
14
Mir ist klar, dass dies für die Party ziemlich spät ist, aber dieser Link wird bei Google angezeigt, wenn das Problem gegoogelt wird. Das erzählt nicht die ganze Geschichte. __xDa eine Variable innerhalb der Klasse Avom Compiler tatsächlich umgeschrieben wird _A__x, ist sie immer noch nicht vollständig privat und kann weiterhin aufgerufen werden.
Zorf
1
Wenn ich eine Variable mit dem Namen sehe _A__x, werde ich sie natürlich nicht berühren. Es könnte ansteckend sein. Ich werde verdammt noch mal davonlaufen.
Mateen Ulhaq
Ich bin mir sicher, dass es kein echtes Privatleben ist. Die Hauptgründe für hart erzwungenes Private in C ++ und Java (usw.), die Compileroptimierung, gibt es in Python jedoch nicht wirklich. Daher ist Private laut Konvention gut genug. Die Python-Konvention besagt im Allgemeinen, dass Sie sich ohne Aufsicht verhalten. (Und es ist eine Newbie-Falle, aber Sie wissen, denken Sie nur über Klassendesign und Konsum nach)
Shayne
14

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

S.Lott
quelle
118
-1: Ich stimme Porculus zu. Es geht nicht darum, den Zugriff zu verbieten oder etwas zu verbergen, sondern um implizite API-Dokumentation. Entwickler sowie Compiler / Interpreter / Code-Checker können leicht erkennen, welche Mitglieder empfohlen werden und welche nicht (oder zumindest mit Vorsicht) berührt werden sollten. In den meisten Fällen wäre es ein schreckliches Durcheinander, wenn alle Mitglieder einer Klasse oder eines Moduls öffentlich wären. Betrachten Sie die Unterscheidung zwischen privaten / geschützten / öffentlichen Mitgliedern als Dienstleistung und sagen Sie: "Hey, diese Mitglieder sind wichtig, während diese intern verwendet werden und wahrscheinlich für Sie nicht nützlich sind."
Oben Sonne
7
@ S.Lott: Ich stimme zu, dass API-Dokumente eine höhere Priorität haben und oft die einzige Möglichkeit sind, die beabsichtigten Verwendungen einer API zu kommunizieren. Aber manchmal sprechen Mitgliedsnamen und Sichtbarkeit (privat / öffentlich) ausreichend für sich. Ich sehe auch Ihren Standpunkt, dass die Idee der impliziten Dokumentation in Editoren ohne API-Überprüfung nicht gut funktioniert, aber in IDEs mit Code-Vervollständigung wirklich hilfreich ist. Angenommen, Sie haben die API-Dokumente bereits vor einiger Zeit gelesen, können Sie sich daran erinnern, wie eine Klasse verwendet wird. Die Dinge würden nicht so klug funktionieren, wenn es keinen Unterschied zwischen privaten und öffentlichen Mitgliedern gäbe.
Oben Sonne
21
Spät zur Diskussion, aber alles, was Porculus und Oben hier anfordern, wird durch die Konvention "Präfix mit Unterstrich" (und ohne den Schaden, den die Durchsetzung dieser Konvention durch den Compiler verursachen kann)
adncoghlan
38
@ S.Lott Ich bin kein Python-Typ, daher werde ich aus dieser Perspektive keinen Kommentar abgeben. Als Java-Entwickler ist dies jedoch ein wirklich schrecklicher Rat. -1
dbyrne
11
Beeindruckend. Sie verpassen den Punkt völlig, Sie geben einen sehr schlechten Ratschlag, Sie beleidigen jeden, der in diesem Punkt nicht mit Ihnen übereinstimmt, aber Sie erhalten immer noch Abzeichen und mehr als 1000 Reputationspunkte für diese "Antwort".
Eric Duminil
12

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

Isaac Saffold
quelle
Django weiß das auch zu schätzen.
Babygame0ver
10

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.

Dan Olson
quelle
Ja. Das Schöne ist, dass die Metaprogrammierfähigkeiten von Python bedeuten, dass Sie die ausgefallenen Dinge tatsächlich implementieren können, wenn Sie möchten (und es gibt Bibliotheken, die @ private / @ protected / etc-Dekoratoren und andere Dinge implementieren. Zum Teufel habe ich sogar eine Bibliothek gesehen, die Prototypklassen im JS-Stil implementiert hat ohne gottverdammt vernünftigen Grund), aber in der Praxis ist es einfach nicht so notwendig. Ich hasse das Mem "Python / js / was auch immer ein Lisp ist", weil es fast nie wahr ist, aber Python teilt Metaprogrammierungs-Chops in Kombination mit einfacher Syntax 'mit dieser Sprache
Shayne
8

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.

BlueEagle
quelle
8

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. ;)

Ferrarezi
quelle
2
Dies existiert seit Python 1.5.2 IIRC und verhindert immer noch nicht den Zugriff auf das Attribut über seinen verstümmelten Namen.
Bruno Desthuilliers
7

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.

user711294
quelle
Rearson Private und Protected sind wichtig, da der Compiler in statisch kompilierten Sprachen direkte Aufrufe an die private Methode erstellen kann, sich jedoch auf eine Nachschlagetabelle für öffentliche Methoden stützen muss. Dies ist einfach kein Problem mit dynamischen Sprachen. Schließlich gibt es in Sprachen wie C ++ Auswirkungen auf die Vererbung und die Methodenauflösung. Python und Ruby haben sehr ähnliche Implementierungen von OO, daher ist der Vergleich bedeutungslos. Smalltalk hat eigentlich keine Ahnung von öffentlichen / privaten Nachrichten. Sie können privat als Kategorie hinzufügen, dies ist jedoch nur eine Empfehlung.
Shayne
Um meine Behauptung zu fördern. Aus der Sicht der Codierungshygiene sind sie zwar wichtig für die Kapselung, aber dafür nicht erforderlich. Daher sind die @ privaten (usw.) Dekorateure eher beratend als alles andere, aber da privat / öffentlich nichts zur Optimierung in a beiträgt Nicht statische Sprache, es ist nicht auf einer tiefen Ebene implementiert, wie es in einer kompilierten Sprache wie Java oder C
Shayne
4

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.

Hatatister
quelle
Ich werde das Gespräch überprüfen. Ist das @propertyDing Teil von Standard-Python oder ist es spezifisch für eine IDE?
bballdave025
Es ist Teil des Standards seit Python 2.6. Wenn Sie eine ältere Version verwenden sollten, besteht weiterhin die Möglichkeit, die propertyintegrierte Funktion zu verwenden, die seit Python 2.2
Hatatister
0

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.

Ilian Zapryanov
quelle