[Road to Intermediate] Artikel-Link-Zusammenfassung
Dies ist eine Zusammenfassung der "** Eigenschaften **", die in Python Tutorial nicht behandelt werden.
Ich schreibe derzeit Forschungscode in Python, aber ich habe ihn richtig geschrieben, also ist er durcheinander. Daher werde ich eine mittlere Python-Ebene anstreben und Code anstreben, den jeder lesen und verstehen kann.
Was ist überhaupt eine Immobilie? Eigenschaften repräsentieren "Objektattribut- / Eigenschaftsdaten".
... Ich weiß es nicht.
Betrachten Sie beispielsweise die Klasse Player, die in einem zweidimensionalen Schießspiel verwendet wird.
Spielerinstanzen zum Bewegen und Zeichnen in Schießspielen
xyIch habe die Informationen von.
Auf diese Weise werden die Attribut- / Eigenschaftsdaten jeder Instanz als ** Eigenschaft ** bezeichnet.
Lassen Sie uns vorerst eine normale Player-Klasse implementieren.
Bereiten wir eine Verschiebungsfunktion vor, die sich mit jeder Koordinate bewegt.
Der Spieler hat diesmal einen beweglichen Bereich von $ 0 {\ leqq} x, y {\ leqq} 500 $ für $ x und y $.
class Player:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f'(x = {self.x}, y = {self.y})'
def move(self, dx, dy):
self.x += dx
self.y += dy
"""
(x = 100, y = 100)
"""
player = Player(100, 100)
print(player)
"""
(x = 0, y = -100)
"""
player.move(-100, -200)
print(player)
Der obige Quellcode funktioniert normal und ist einfach. In Bezug auf die Objektorientierung gibt es jedoch einige Probleme mit dem obigen Quellcode.
Die obige Klasse kann mit ** direkt ** Eigenschaftsvariablen manipuliert werden.
Dies ist nicht in sehr gutem Zustand. Dies liegt daran, dass die Möglichkeit besteht, unbequeme Variablen festzulegen oder zu ändern.
Die grundlegende Objektorientierung besteht auch darin, dass sich der Status je nach Methode ändert.
Ich möchte, dass diese Player-Klasse in $ 0 {\ leqq} x, y {\ leqq} 500 $ für $ x und y $ ausgeführt wird. Die oben beschriebene Verschiebungsfunktion führte jedoch dazu, dass die Reichweite überschritten wurde.
Ist es möglich, den Prozess so einzustellen, dass er gleichzeitig mit dem Einstellen der Variablen im Bereich bleibt?
Daher verwenden wir die Notationseigenschaft von Python.
Schreiben wir den Quellcode wie folgt um.
class Player:
MIN_X = 0
MAX_X = 500
MIN_Y = 0
MAX_Y = 500
def __init__(self, x, y):
self._x = x
self._y = y
def __repr__(self):
return f'(x = {self.x}, y = {self.y})'
@property
def x(self):
return self._x
@x.setter
def x(self, dx):
self._x += dx
self._x = max(0, min(self.MAX_X, self._x))
@property
def y(self):
return self._y
@y.setter
def y(self, dy):
self._y += dy
self._y = max(0, min(self.MAX_Y, self._y))
def move(self, dx, dy):
self.x += dx
self.y += dy
player = Player(100, 100)
player.move(-200, -200)
"""
(x = 0, y = 0)
"""
print(player)
Schauen wir uns den Inhalt einzeln an.
init
Darin werden Variablen mit _x initialisiert. Es scheint, dass Variablen, die Sie nur intern verarbeiten möchten, häufig mit Unterstrichen wie _x ausgedrückt werden.
＠property
@property
def x(self):
return self._x
@property
def Name der externen öffentlichen Variablen(self):
interne Variable zurückgeben
Schauen wir uns als nächstes x (self) an.
Es funktioniert wie eine Methode, kann aber außerhalb der Klasse wie eine "nur eine Variable" aussehen.
Dies ist für ** Rückgabe des Wertes nach außen **.
Dies liegt daran, dass wir die Notation @ property ** decorator ** über dieser Funktionsdefinition verwenden.
In Bezug auf Dekorateure werde ich das nächste Mal einen weiteren Artikel schreiben.
Durch Hinzufügen des Schlüsselworts @property zu einer Methode können Sie den Wert vorerst mit diesem Methodennamen von außerhalb der Klasse abrufen.
@x.setter
def x(self, dx):
self._x += dx
self._x = max(0, min(self.MAX_X, self._x))
@Name der externen öffentlichen Variablen.setter
def Name der externen öffentlichen Variablen(self, dx):
self.Interne Variablen+= dx
self.Interne Variablen= max(0, min(self.MAX_X, self._x))
Die zuvor erwähnte @ -Eigenschaft war ein Schlüsselwort zum Abrufen und Verwenden eines Werts von außerhalb der Klasse.
Dies bedeutet, dass es auch Schlüsselwörter gibt, die einen Wert von außen angeben und den Wert von innen festlegen.
Verwenden Sie das Schlüsselwort "@external public variable name.setter". Auf diese Weise können Sie den Wert intern in der üblichen Notation festlegen.
Was ist die Freude an der Immobilie?
Tatsächlich haben Python-Eigenschaften eine andere Form als andere Sprachen. Ursprünglich berührte ich C #, C ++ und Java, daher war ich ziemlich überrascht und unbehaglich.
Python-Eigenschaften sind
Das sage ich gerne.
In anderen Sprachen
player.setValueA(50);
Es musste in Form einer Funktion / Methode beschrieben werden, sozusagen war es ** redundant **.
Verwenden Sie in Python die Sprachspezifikation, die nur für dynamische Sprachen gilt, die als Dekoratoren bezeichnet werden. Stellen Sie Methoden wie Variablen nach außen bereit Intern können Sie zusätzliche Verarbeitung schreiben.
Wenn Sie jedoch zu viel komplizierten Inhalt in den Setter schreiben, wird dies zu einem Fehler, und Sie müssen sich dessen bewusst sein, sodass es möglicherweise erforderlich ist, den Inhalt hell zu machen.
Ich habe die Eigenschaften zusammengefasst! Da ich ein Anfänger bin, denke ich, dass es viele Fehler gibt. Wir wären Ihnen dankbar, wenn Sie uns Ihre Ratschläge und Meinungen geben könnten!
Recommended Posts