je viens de lire le chapitre sur les propriétés en python.
Et j'aurai une question.
Dans ce code:
class Personne:
"""Classe définissant une personne caractérisée par :
— son nom ;
— son prénom ;
— son âge ;
— son lieu de résidence.
"""
def __init__(self, nom, prenom):
"""Constructeur de notre classe."""
self.nom = nom
self.prenom = prenom
self.age = 33
self._lieu_residence = "Paris" # notez le souligné _ devant le nom
def _get_lieu_residence(self):
"""Méthode qui sera appelée quand on souhaite accéder en lecture
à l'attribut 'lieu_residence'.
"""
print("On accède à l'attribut lieu_residence !")
return self._lieu_residence
def _set_lieu_residence(self, nouvelle_residence):
"""Méthode appelée quand on souhaite modifier le lieu de résidence."""
print("Attention, il semble que {0} déménage à {1}.".format( \
self.prenom, nouvelle_residence))
self._lieu_residence = nouvelle_residence
# On va dire à Python que notre attribut lieu_residence pointe vers une
# propriété
lieu_residence = property(_get_lieu_residence, _set_lieu_residence)
Est-ce que la seule différence quand on fait jean.lieu_residence
est jean.lieu_residence = "Rome"
Comment il interprète ça?
Il voit qu'il y a "= "xxx" et se dit que c'est forcément get?
ou c'est en fonction du nombre de propriété? (donc si on avait mis un paramètre dans set, on se serai retrouvé avec une erreur?).
Je suis très curieux de comprendre comment ça marche car je n'arrive pas à le comprendre de moi-même. Comment arrive-t-il à savoir lequel choisir?
Si on le lit, c'est à dire qu'on ne lui attribue pas de valeur, il fait get, si on lui donne une valeur, ça fait set. Ca choisit tout seul, comme un grand.
La fonction property (que je n'utilise jamais) comprend une fonction d'accès (fget), une fonction de placement (fset) et une fonction d'affacement (fdel).
Bon c'est à peu près tout ce que je sais, ne l'utilisant jamais.
Je me suis amusé à un petit test pour voir, peut-être par le code c'est plus simple.
class A(object):
def __init__(self, var):
self.var=var
def fget(self):
return self.var
def fset(self, _var):
self.var=_var
def fdel(self):
del self.var
variable=property(fget, fset, fdel)
a=A("bonjour")
print a.variable
a.variable="coucou"
print a.variable
del a.variable
Oui, mais la question c'était comment l'ordinateur sait quelle méthode appeler.
Et comme l'a dit ordiclic, il choisit en fonction de ce qu'il a à faire dessus (il est capable de voir s'il modifie, efface ou lit la variable).
comme ils l'ont expliqué, lorsque tu essayes de modifier l'attribut _lieuDeResidence (dans ce cas là) la méthode qui est appelée sera _setLieuDeResidence et lorsque tu souhaites lire l'attribut pour connaître/afficher sa valeur, la méthode _getLieuDerésidence sera appelée.
Pourquoi utiliser les propriétés ?
Personnellement je préfère les utiliser car elles sont plus simple d'utilisation. En effet il est plus simple de faire
realmagma.lieuDeResidence = "Paris"
QUE
realmagma.getLieuDeResidence(nom)
Ne crois-tu pas ?
Sachant qu'il ne faut pas oublier le principe d'encapsulation et de POO.
Essaye ce code:
class Personne():
"""Classe d'une personne"""
#A chaque nouvelle instance on incrémente ce compteur
compteurInstance = 0
def __init__(self, nom = "Pseudo_"):
"""Constructeur de la
classe <Personne>
"""
Personne.compteurInstance += 1
self._nom = nom + str(Personne.compteurInstance)
def _getNom(self):
"""Retourne le nom de la personne"""
return self._nom
def _setNom(self, nouveauNom):
"""Change le nom après vérification:
Ne ren faire si:
- Si le nom est trop court
- Si le nom est trop long
"""
if len(nouveauNom) < 4 or len(nouveauNom) > 9:
#Si la condition n'est pas respecté, ne rien faire
self._nom = self._nom
else:
self._nom = nouveauNom
#
###############Propriété##############
nom = property(_getNom, _setNom)
if __name__ =="__main__":
monsieur = Personne()
#Quel est son nom par défaut ?
print(monsieur.nom)
#Je préfère changer de nom:
monsieur.nom = "luc"
#Mince le nom est trop court, ça n'a pas marché
print(monsieur.nom)
#Là ça marche
monsieur.nom = "Tintin"
print(monsieur.nom)
En fait, pour utiliser les propriétés, il existe une autre syntaxe depuis python 2.6, utilisant les décorateurs, plus pratique (et beaucoup plus lisible surtout) :
class Personne(object):
def __init__(self, nom):
self.__nom = nom
@property
def nom(self):
""" Nom de la personne """
return self.__nom
@nom.setter
def nom(self, val):
if val != '':
self.__nom = val
else:
print "Pas le droit d'être anonyme"
p = Personne('Michel')
print p.nom
p.nom = 'Maurice'
print p.nom
p.nom = ''
En effet, très sympathique ce @property.
Est-ce normal que mon @nom.setter n'est pas coloré sous Python 3.x ?
Mon code avec les @property:
class Personne(object):
"""Classe d'une personne"""
#A chaque nouvelle instance on incrémente ce compteur
compteurInstance = 0
def __init__(self, nom = "Pseudo_"):
"""Constructeur de la
classe <Personne>
"""
Personne.compteurInstance += 1
self._nom = nom + str(Personne.compteurInstance)
@property
def nom(self):
"""Retourne le nom de la personne"""
return self._nom
@nom.setter
def nom(self, nouveauNom):
"""Change le nom après vérification:
Ne ren faire si:
- Si le nom est trop court
- Si le nom est trop long
"""
if len(nouveauNom) < 4 or len(nouveauNom) > 9:
#Si la condition n'est pas respecté, ne rien faire
self._nom = self._nom
else:
self._nom = nouveauNom
if __name__ =="__main__":
monsieur = Personne()
#Quel est son nom par défaut ?
print(monsieur.nom)
#Je préfère changer de nom:
monsieur.nom = "luc"
#Mince le nom est trop court, ça n'a pas marché
print(monsieur.nom)
#Là ça marche
monsieur.nom = "Tintin"
print(monsieur.nom)
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Python c'est bon, mangez-en.