Python attribut est en lecture seule à l'intérieur de la classe

J'ai une classe:

class Portfolio:
    def __init__(self, value):
        self.value = value

class GenericStrategy:
    def __init__(self, portfolio: Portfolio):
        self.portfolio = portfolio

    def modify_ptf_value(new_value):
        self.portfolio.value = new_value
        # This should return an error

Je'va écrire certaines des stratégies qui va hériter de GenericStrategy. J'aimerais leurs méthodes pour être en mesure de lire l'attribut portefeuille, mais de ne pas le modifier, ni ses attributs.

J'ai lu quelque chose à propos de la @properties décorateur, mais il ne fonctionne que si je ne veux pas l'attribut (et ses attributs) pour être accessible de l'extérieur, je peux toujours modifier l'attribut (et ses attributs) à partir de méthodes 'à l'intérieur de l'objet.
Est-il un moyen de faire de l'attribut (et ses attributs) 'lecture seule' l'exception de la __init__ méthode? Ma conception erronée et doit recommencer depuis le début? Je sais que c'est à l'utilisateur de ne pas modifier "protégés" attributs, mais je tiens à faire preuve de balle. Toute idée est bien acceptée, même si elle nécessite un changement considérable dans la conception de classe.

Grâce

InformationsquelleAutor gionni | 2017-04-05
  1. 1

    Contrairement à d'autres (couramment utilisé) langages de programmation Python est livré avec une nouvelle approche concernant l'accès de la classe/les membres de l'instance. Par exemple, rien n'est vraiment privé, les champs/méthodes:

    • commencer avec un _, sont régulièrement champs
    • commencer avec __ (et à la fin avec tout au plus un _), sont juste le nom mutilé, mais ils peuvent toujours être consulté (même modifiés/supprimés) à partir de l'extérieur de la classe

    Ainsi, à la fin, c'est une question de convention, et il compte qu'il sera suivi par ceux qui ont écrit le code. Ligne de fond est qu'il y a rien qui permettrait d'empêcher un utilisateur d'accéder à une classe/instance-même.

    Note: Dans d'autres langues il est aussi possible pour accéder aux membres privés: il existe des méthodes officiellement pris en charge (comme Réflexion ([Oracle]: Trail: L'API Reflection) pour Java), ou pas officiellement pris en charge (qui nécessitent quelques "trucs et astuces" - par exemple: reinterpret_casting un class à un struct avec la même structure pour C++). De nos jours, de plus en plus de langues ont tendance à offrir un moyen de modifier une instance de la structure.

    De toute façon, il y a le soi-disant Descripteur de Protocole ([Python]: Descripteur De Guide) qui est l'un des Python's le plus puissant (et le plus mal compris) caractéristiques.

    À l'aide de descripteurs (comme un commentaire, propriétés compter sur eux), j'ai écrit un bout de code qui permet (dans une certaine mesure) de ce que vous me demandez:

    class LockedAttribute(object):
def __init__(self, name):
self._name = name
self._set_count = 0
self._set_treshold = 1
def __get__(self, instance, cls):
return instance.__dict__[self._name]
def __set__(self, instance, value):
if self._set_count >= self._set_treshold:
raise AttributeError("Can't set attribute '{}'".format(self._name))
else:
instance.__dict__[self._name] = value
self._set_count += 1
def __delete__(self, instance):
raise AttributeError("Can't delete attribute '{}'".format(self._name))
class GenericStrategy(object):
portfolio = LockedAttribute("portfolio")
def __init__(self, portfolio):
self.portfolio = portfolio
try:
self.portfolio = portfolio
except AttributeError as e:
print("  ERROR: {}".format(e))
def set_portfolio(self, new_value):
self.portfolio = new_value
if __name__ == "__main__":
strategy = GenericStrategy("some portfolio name")
print("Portfolio: {}".format(strategy.portfolio))
try:
del strategy.portfolio
except AttributeError as e:
print("  ERROR: {}".format(e))
try:
strategy.set_portfolio("some 2nd portfolio name")
except AttributeError as e:
print("  ERROR: {}".format(e))
try:
strategy.portfolio = "some 3rd portfolio name"
except AttributeError as e:
print("  ERROR: {}".format(e))
print("Portfolio: {}".format(strategy.portfolio))

    Notes:

    • J'ai enlevé __ de l'attribut privé de son nom, ( portfolio ) pour éviter d'utiliser les mutilations dont je parlais, dans mon code (il serait plus difficile à lire)
    • Pour Py27 de compatibilité, les classes héritent de object. Si la compatibilité n'est pas obligatoire, l'héritage de la relation peut être supprimé (dans Py3x il est par défaut)
    • J'ai ajouté le try/except blocs pour illustrer le comportement, dans production ils doivent être supprimés
    • Comme je l'ai dit ci-dessus, si quelqu'un veut modifier ce comportement, peut
    • De cette façon, l'ensemble de l'objet de portefeuille ne peut pas être changé, mais je peux encore changer les attributs de l'objet du portefeuille. J'ai édité la question pour la rendre plus claire. Descripteurs sembler comme une chose, j'ai besoin d'apprendre comment ils fonctionnent.
    • Hmm, j'avais peur que ce serait la prochaine question. La réponse générale est que vous vous ne pouvez pas faire vraiment de preuve de balle. Un consommateur de votre classe/instance sera en mesure de jouer avec eux. Concernant la question elle-même, je n'ai pas de réponse. Une autre solution serait de faire de la portfolio type d'objets utilisation LockedAttribute ainsi, et de les faire en lecture seule (ou les initialiser dans GenericStrategy.__init__ - qui casserait toute agrégation), mais je doute que cela pourrait convenir à vos besoins.
    • J'ai l'impression que c'était impossible... Merci pour la réponse, de toute façon, le verrouillage de l'attribut de classe est super
    • Je vous remercie. Vous pouvez prendre un coup d'oeil à [Python]: abc module, ou de [Python]: __setattr__ méthode, vous pourriez peut-être quelque chose à partir de là pour vous rapprocher de votre objectif.
    InformationsquelleAutor CristiFati