Les méthodes privées en Python

Python n'a pas la notion de privé de méthodes ou d'attributs, il est tout au sujet de la façon de mettre en œuvre votre classe. Mais vous pouvez utiliser des pseudo-variables privées(name mangling), toute variable précédée par __(deux caractères de soulignement) devient une pseudo-variable privée.

De la docs:

Car il y a un cas d'utilisation pour la classe de membres privés (à savoir
éviter les collisions de noms de noms avec les noms définis par les sous-classes), il y
est prise en charge limitée pour un tel mécanisme, appelé name mangling. Tout
identifiant de la forme __spam (au moins deux des principaux souligne, à
plus une fuite trait de soulignement) est textuellement remplacé par
_classname__spam, où classname est l'actuel nom de la classe avec un trait de soulignement(s) dépouillé. Cette déformation se fait sans égard
à la position syntaxique de l'identifiant, tant qu'il se produit
dans la définition d'une classe.

class A:
    def __private(self):
       pass

Donc __private maintenant devient réellement _A__private

exemple de la méthode statique:

>>> class A:
...     @staticmethod         #not required in py3.x
...     def __private():
...         print 'hello'
...         
>>> A._A__private()
hello

OriginalL'auteur Ashwini Chaudhary

Beaucoup de grandes choses ici avec l'obfuscation utilisant des caractères de soulignement. Personnellement, j'ai grandement bénéficier de la langue de conception de décision à rendre les choses publiques, car elle réduit le temps qu'il faut pour comprendre et utiliser les nouveaux modules.

Toutefois, si vous êtes déterminé à mettre en oeuvre privé des attributs/méthodes, et vous êtes prêt à être unpythonic, vous pouvez faire quelque chose le long des lignes de:

from pprint import pprint


# CamelCase because it 'acts' like a class
def SneakyCounter():

    class SneakyCounterInternal(object):

        def __init__(self):
            self.counter = 0

        def add_two(self):
            self.increment()
            self.increment()

        def increment(self):
            self.counter += 1

        def reset(self):
            print 'count prior to reset: {}'.format(self.counter)
            self.counter = 0

    sneaky_counter = SneakyCounterInternal()

    class SneakyCounterExternal(object):

        def add_two(self):
            sneaky_counter.add_two()

        def reset(self):
            sneaky_counter.reset()

    return SneakyCounterExternal()


# counter attribute is not accessible from out here
sneaky_counter = SneakyCounter()

sneaky_counter.add_two()
sneaky_counter.add_two()
sneaky_counter.reset()

# `increment` and `counter` not exposed (AFAIK)
pprint(dir(sneaky_counter))

Difficile d'imaginer un cas où vous voulez le faire, mais c'est possible.

OriginalL'auteur circld

vous ne le faites pas:

• La pythonic façon de ne pas documenter ces méthodes/membres à l'aide de docstrings, seulement avec de "vrais" commentaires de code. Et de la convention consiste à ajouter un simple ou un double trait de soulignement ;

• Ensuite, vous pouvez utiliser la double souligne en face de vos membres, de sorte que vous ils sont locales faites à la classe (c'est surtout le nom d'une déformation, c'est à dire le vrai nom du membre en dehors de la classe devient : instance.__classname_membername). C'est utile pour éviter les conflits lors de l'utilisation de l'héritage, ou de créer un "espace privé" entre les enfants d'une classe.

• AFAICT, il est possible de "masquer" des variables en utilisant des metaclasses, mais qui ne respecte pas l'ensemble de la philosophie de python, donc je ne rentrerai pas dans les détails à ce sujet

OriginalL'auteur zmo