Définition de fonctions de module privé en python

Selon http://www.faqs.org/docs/diveintopython/fileinfo_private.html :

Comme la plupart des langages, Python a le concept d'éléments privés:

• Fonctions privées, qui ne peuvent pas être appelées depuis l' extérieur de leur module

Cependant, si je définis deux fichiers:

#a.py
__num=1

et:

#b.py
import a
print a.__num

quand je l'exécute, b.pyil imprime 1sans donner aucune exception. Diveintopython est-il mauvais, ou ai-je mal compris quelque chose? Et est - il possible de ne pas définir la fonction d'un module en privé?

En Python, la "confidentialité" dépend des niveaux d'accord des "adultes consentants" - vous ne pouvez pas la forcer (pas plus que vous ne le pouvez dans la vie réelle ;-). Un seul trait de soulignement principal signifie que vous n'êtes pas censé y accéder "de l'extérieur" - deux traits de soulignement principaux (sans traits de soulignement finaux) véhiculent le message encore plus avec force ... mais, en fin de compte, cela dépend toujours des réseaux sociaux. convention et consensus: l'introspection de Python est suffisamment puissante pour que vous ne puissiez pas menotter tous les autres programmeurs du monde pour respecter vos souhaits.

((Btw, bien que ce soit un secret bien gardé, il en va de même pour le C ++: avec la plupart des compilateurs, une simple #define private publicligne avant de #includesaisir votre .hfichier est tout ce qu'il faut pour que les codeurs rusés hachent votre "confidentialité" ...! -)) )

Il peut y avoir confusion entre les classes privées et les modules privés .

Un module privé commence par un trait de soulignement
Un tel élément n'est pas copié lors de l'utilisation du from <module_name> import *formulaire de la commande d'importation; il est cependant importé si vous utilisez la import <moudule_name>syntaxe ( voir la réponse de Ben Wilhelm )
Supprimez simplement un trait de soulignement du numéro a .__ de l'exemple de la question et il ne s'affichera pas dans les modules qui importent a.py en utilisant la from a import *syntaxe.

Une classe privée commence par deux traits de soulignement (alias dunder ie d-ouble under-score)
Une telle variable a son nom "mangled" pour inclure le nom de classe etc.
Elle peut toujours être consultée en dehors de la logique de la classe, via le nom mangled.
Bien que le changement de nom puisse servir de moyen de prévention léger contre les accès non autorisés, son objectif principal est d'empêcher d'éventuelles collisions de noms avec les membres de la classe des classes ancêtres. Voir la référence amusante mais précise d'Alex Martelli aux adultes consentants alors qu'il décrit la convention utilisée en ce qui concerne ces variables.

>>> class Foo(object):
...    __bar = 99
...    def PrintBar(self):
...        print(self.__bar)
...
>>> myFoo = Foo()
>>> myFoo.__bar  #direct attempt no go
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Foo' object has no attribute '__bar'
>>> myFoo.PrintBar()  # the class itself of course can access it
99
>>> dir(Foo)    # yet can see it
['PrintBar', '_Foo__bar', '__class__', '__delattr__', '__dict__', '__doc__', '__
format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__
', '__subclasshook__', '__weakref__']
>>> myFoo._Foo__bar  #and get to it by its mangled name !  (but I shouldn't!!!)
99
>>>

Cette question n'a pas reçu de réponse complète, car la confidentialité des modules n'est pas purement conventionnelle, et puisque l'utilisation de l' importation peut ou non reconnaître la confidentialité des modules, selon la façon dont elle est utilisée.

Si vous définissez des noms privés dans un module, ces noms seront importés dans tout script utilisant la syntaxe «import module_name». Ainsi, en supposant que vous avez correctement défini dans votre exemple le module private, _num, dans a.py, comme ça.

#a.py
_num=1

..vous pourrez y accéder dans b.py avec le symbole du nom du module:

#b.py
import a
...
foo = a._num # 1

Pour importer uniquement des utilisateurs non privés à partir de a.py, vous devez utiliser la syntaxe from :

#b.py
from a import *
...
foo = _num # throws NameError: name '_num' is not defined

Par souci de clarté, cependant, il vaut mieux être explicite lors de l'importation de noms à partir de modules, plutôt que de les importer tous avec un '*':

#b.py
from a import name1 
from a import name2
...

Python permet aux membres de classe privés avec le préfixe de soulignement double. Cette technique ne fonctionne pas au niveau du module, donc je pense que c'est une erreur dans Dive Into Python.

Voici un exemple de fonctions de classe privées:

class foo():
    def bar(self): pass
    def __bar(self): pass

f = foo()
f.bar()   # this call succeeds
f.__bar() # this call fails

Vous pouvez ajouter une fonction interne:

def public(self, args):
   def private(self.root, data):
       if (self.root != None):
          pass #do something with data

Quelque chose comme ça si vous avez vraiment besoin de ce niveau de confidentialité.

C'est une question ancienne, mais les variables mutilées privées du module (un trait de soulignement) et privées de classe (deux traits de soulignement) sont désormais couvertes dans la documentation standard:

Le didacticiel Python » Classes » Variables privées

intégré avec des fermetures ou des fonctions est un moyen. Ceci est courant dans JS bien qu'il ne soit pas requis pour les plates-formes autres que les navigateurs ou les navigateurs.

En Python, cela semble un peu étrange, mais si quelque chose doit vraiment être caché, cela pourrait être le cas. Plus précisément, utiliser l'API python et garder les choses qui doivent être cachées dans le C (ou un autre langage) est probablement la meilleure façon. À défaut, j'irais mettre le code dans une fonction, l'appeler et lui faire retourner les éléments que vous souhaitez exporter.

Python a trois modes via., Privé, public et protégé. Lors de l'importation d'un module, seul le mode public est accessible. Les modules privés et protégés ne peuvent donc pas être appelés de l'extérieur du module, c'est-à-dire lors de son importation.