[Road to Intermediate] Résumé du lien de l'article
Ceci est un résumé des «** Propriétés **» qui ne sont pas couvertes dans le Tutoriel Python.
J'écris actuellement du code de recherche en Python, mais je l'ai écrit correctement, donc c'est foiré. Par conséquent, je viserai un niveau intermédiaire de Python et viserai un code que tout le monde peut lire et comprendre.
Qu'est-ce qu'une propriété en premier lieu? Les propriétés représentent les «données d'attribut / propriété d'objet».
... Je ne sais pas.
Par exemple, considérons la classe Player utilisée dans un jeu de tir en deux dimensions.
Instance de joueur pour se déplacer et dessiner dans les jeux de tir
--Coordonnées horizontales x
yJ'ai les informations de.
De cette manière, les données d'attribut / propriété de chaque instance sont appelées ** propriété **.
Pour le moment, implémentons une classe Player normale.
Préparons une fonction de déplacement qui se déplace avec chaque coordonnée.
Le joueur a cette fois une plage mobile de $ 0 {\ leqq} x, y {\ leqq} 500 $ pour $ x et 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)
Le code source ci-dessus fonctionne normalement et est simple. Cependant, en termes d'orientation objet, il y a quelques problèmes avec le code source ci-dessus.
La classe ci-dessus peut être falsifiée avec les variables de propriété ** directement **.
Ce n'est pas en très bon état. En effet, il existe une possibilité de définir ou de modifier des variables peu pratiques.
En outre, l'orientation de base de l'objet est que l'état change en fonction de la méthode.
Je veux que cette classe Player s'exécute dans $ 0 {\ leqq} x, y {\ leqq} 500 $ pour $ x et y $. Cependant, la fonction de déplacement ci-dessus l'a rendu hors de portée.
Est-il possible de définir d'une manière ou d'une autre le processus pour qu'il reste dans la plage en même temps que la définition de la variable?
Par conséquent, nous utiliserons la propriété de notation de Python.
Réécrivons le code source comme suit.
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)
Regardons le contenu un par un.
init
Dans celui-ci, les variables sont initialisées avec _x. Il semble que les variables que vous souhaitez gérer uniquement en interne sont souvent exprimées à l'aide de traits de soulignement tels que _x.
＠property
@property
def x(self):
return self._x
@property
def Nom de la variable publique externe(self):
retourne une variable interne
Ensuite, jetons un coup d'œil à x (self).
Cela fonctionne comme une méthode, mais cela peut ressembler à une simple variable à l'extérieur de la classe.
C'est pour ** renvoyer la valeur vers l'extérieur **.
C'est parce que nous utilisons la notation @ property ** decorator ** au-dessus de cette définition de fonction.
Concernant les décorateurs, j'écrirai un autre article la prochaine fois.
Pour le moment, en ajoutant le mot-clé @property à une méthode, vous pouvez obtenir la valeur de l'extérieur de la classe avec ce nom de méthode.
@x.setter
def x(self, dx):
self._x += dx
self._x = max(0, min(self.MAX_X, self._x))
@Nom de la variable publique externe.setter
def Nom de la variable publique externe(self, dx):
self.Variables internes+= dx
self.Variables internes= max(0, min(self.MAX_X, self._x))
Le @property mentionné précédemment était un mot-clé pour obtenir et utiliser une valeur extérieure à la classe.
Cela signifie qu'il existe également des mots-clés qui donnent une valeur de l'extérieur et définissent la valeur à l'intérieur.
Utilisez le mot-clé @external public variable name.setter.
Cela vous permet de définir la valeur en interne dans la notation habituelle.
Quelle est la joie de la propriété?
En fait, les propriétés Python ont une forme différente de celle des autres langages. À l'origine, je touchais C #, C ++ et Java, donc j'étais assez surpris et mal à l'aise.
Les propriétés Python sont
--Pour l'extérieur, il peut être utilisé comme ** variables telles qu'elles apparaissent ** --Pour l'intérieur, vous pouvez masquer les variables importantes et écrire des traitements supplémentaires
Je suis heureux de le dire.
Dans d'autres langues
player.setValueA(50);
Il fallait le décrire sous la forme d'une fonction / méthode, pour ainsi dire, c'était ** redondant **.
En Python, en utilisant la spécification de langage propre aux langages dynamiques appelés décorateurs, Exposer des méthodes comme des variables à l'extérieur En interne, vous pouvez écrire des traitements supplémentaires.
Cependant, si vous écrivez trop de contenu compliqué dans le setter, cela deviendra un bogue et vous devrez en être conscient, il peut donc être nécessaire de rendre le contenu léger.
J'ai résumé les propriétés! Puisque je suis débutant, je pense qu'il y a beaucoup d'erreurs. Nous vous serions reconnaissants de bien vouloir nous donner vos conseils et opinions!
Recommended Posts