Comments on: Attributs privés en Python

By: Sam

Sam — Tue, 26 Aug 2014 08:41:43 +0000

@Remram : parce que je ne savais pas que ça marchait. Tu m’apprends un truc :)

By: Remram

Remram — Thu, 14 Aug 2014 20:17:05 +0000

print(m.__dict__['_Monique__private'])

Pourquoi utiliser __dict__ ici ? Ca marche tout aussi bien sans :

print(m._Monique__private)

By: toub

toub — Thu, 03 Jul 2014 08:15:17 +0000

J’aime bien le principe de python de ne pas interdire l’accès aux attributs des classes, contrairement à C++, en laissant aux dev le choix d’accéder malgré tout à des attributs auxquels ils ne sont pas sensés accéder.
Mais je sais aussi que quand tout est accessible, on a vite fait de se retrouver avec du code bien pourri, qu’on ne peut plus faire évoluer parce que les régressions seraient trop importantes

Du coup j’ai opté pour la solution suivante : j’utilise le __ pour les attributs privés, et le _ pour les attributs protected

By: Fred

Fred — Sun, 22 Jun 2014 08:46:27 +0000

Bonjour
Ben je ne suis pas trop d’accord avec le “c’est une mauvaise idée”.
Déjà d’une part parce que dans mes projets, toutes mes variables internes à mes classes ont deux underscores. En effet, moi aussi je trouvais ça bien de m’interdire à moi-même d’accèder de façon directe à ces variables “internes”. Bon je connaissais __dict__ donc je savais que ce n’est pas une protection absolue mais ça ne me dérange pas (je me vois mal me hacker moi-même). Et en plus ayant découvert il y a peu de temps les assesseurs (les getters/setters qu’on peut créer via le property()), il m’arrive même maintenant de créer des variables privées mais accessibles de l’extérieur (c’est aussi faisable sans ça, bien sûr, mais c’est plus lourd).
Et donc tout changer pour ne mettre qu’un seul underscore serait assez fastidieux.

Et d’autre part, un seul underscore n’empêche pas l’accès direct aux variables. Ce n’est qu’une convention qui dit aux progs de ne pas le faire mais rien ne les empêche de taper à loisir dans le tas. Deux underscores ont au-moins l’avantage de lever l’exception quand on le fait. De toute façon, dans les deux cas (un ou deux underscores) la convention “c’est mal de passer outre” existe et elle est connue. Dans les deux cas (un ou deux underscores), on peut quand-même passer outre si on le désire. Mais dans le second (deux underscores), il y a quand-même l’avantage d’au-moins lever une exception…

By: Sam

Sam — Sun, 22 Jun 2014 02:47:10 +0000

Un bout de code serait utile.

By: yoshi_120

yoshi_120 — Sat, 21 Jun 2014 21:44:35 +0000

Bonjour,

J’ai testé avec python3 sur ubuntu.
Acceder a __private provoque une exception.
Mais si on change la valeur de __private
un acces ultérieur ne lance plus d’exception

Est ce normal ?

By: Marien

Marien — Sat, 21 Jun 2014 15:42:51 +0000

On peut noter aussi qu’un from module import * n’importe pas les objets commençant par “_” ou “__”. Il faut le faire explicitement si on veut pouvoir les manipuler.

By: Morgotth

Morgotth — Sat, 21 Jun 2014 11:03:08 +0000

Je connaissais pas ce comportement d’AttributeError avec __ :o

Par contre j’ai eu du mal à comprendre l’exemple avec __dict__ , le préfixe _Monique étant assez déroutant … Peut être que rajouter l’utilisation de vars aiderait :

class Monique:
   def __init__(self):
       self.a = 1
       self._b = 2
       self.__c = 3
 
m = Monique()
print(vars(m))
# {'_b': 2, 'a': 1, '_Monique__c': 3}
print(m.__dict__['_Monique__c'])
# 3

Rappel : vars affiche les attributs d’un objet sous forme de dictionnaire.

Et j’ai eu un doute : et si c’était pour cacher aux classes filles les attributs privés ??!

class Monique:
    def __init__(self):
        self.a = 1
        self._b = 2
        self.__c = 3
 
class SousMonique(Monique):
    def __init__(self):
        super().__init__()
        self.__d = 4
 
    def parle(self):
        try:
            # Ne marchera jamais
            return "%s et %s" % (self.__c, self.__d)
        except AttributeError:
            return "fix: %s et %s" % (self._Monique__c, self.__d)
 
 
l = SousMonique()
 
print(vars(l))
# {'a': 1, '_Monique__c': 3, '_b': 2, '_SousMonique__d': 4}
 
print(l.parle())
# fix: 3 et 4

L’objectif est sans doute d’imiter le comportement public/protected/private en Java. Mais on est en Python ici, heureusement que je n’utilise jamais de __ pour mes attributs :’)