Definindo funções de módulo privado em python

De acordo com http://www.faqs.org/docs/diveintopython/fileinfo_private.html :

Como a maioria das linguagens, o Python tem o conceito de elementos privados:

• Funções privadas, que não podem ser chamadas de fora do módulo

No entanto, se eu definir dois arquivos:

#a.py
__num=1

e:

#b.py
import a
print a.__num

quando eu executo b.pyele imprime 1sem dar nenhuma exceção. O diveintopython está errado ou entendi algo errado? E há alguma maneira de se definir a função de um módulo como privado?

No Python, "privacidade" depende dos níveis de "consentimento dos adultos" - você não pode forçá- lo (assim como na vida real ;-). Um único sublinhado à esquerda significa que você não deve acessá-lo "de fora" - dois sublinhados à esquerda (sem sublinhados à direita) transmitem a mensagem com mais força ainda ... mas, no final, ainda depende do social convenção e consenso: a introspecção do Python é forte o suficiente para que você não possa algemar todos os outros programadores do mundo para respeitar seus desejos.

((Btw, embora seja um segredo bem guardado, o mesmo vale para C ++: na maioria dos compiladores, uma #define private publiclinha simples antes de #includeinserir seu .harquivo é tudo o que é necessário para codificadores espertos fazerem hash de sua "privacidade" ...! -) )

Pode haver confusão entre o privado da classe e o privado do módulo .

Um módulo privado começa com um sublinhado.
Esse elemento não é copiado ao usar o from <module_name> import *formulário do comando import; no entanto, é importado se você estiver usando a import <moudule_name>sintaxe ( consulte a resposta de Ben Wilhelm )
Simplesmente remova um sublinhado do a .__ num do exemplo da pergunta e não será exibido nos módulos que importam a.py usando a from a import *sintaxe.

Uma classe privada começa com dois sublinhados (também conhecido como dunder, ou seja, sub-pontuação d-ouble).
Essa variável tem o nome "desconfigurado" para incluir o nome da classe, etc.
Ela ainda pode ser acessada fora da lógica da classe, através do nome desconfigurado.
Embora o nome errado possa servir como um dispositivo de prevenção moderado contra acesso não autorizado, seu principal objetivo é evitar possíveis colisões de nomes com membros da classe das classes ancestrais. Veja a referência engraçada, mas precisa, de Alex Martelli a adultos que consentem, enquanto ele descreve a convenção usada em relação a essas variáveis.

>>> 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
>>>

Esta pergunta não foi totalmente respondida, pois a privacidade do módulo não é puramente convencional e o uso da importação pode ou não reconhecer a privacidade do módulo, dependendo de como é usado.

Se você definir nomes particulares em um módulo, esses nomes serão importados para qualquer script que use a sintaxe 'import module_name'. Assim, supondo que você tenha definido corretamente em seu exemplo o módulo private, _num, em a.py, assim ..

#a.py
_num=1

..você poderia acessá-lo em b.py com o símbolo do nome do módulo:

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

Para importar apenas não privados do a.py, você deve usar a sintaxe from :

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

Por uma questão de clareza, no entanto, é melhor ser explícito ao importar nomes de módulos, em vez de importá-los todos com um '*':

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

Python permite classe privada membros da com o prefixo de sublinhado duplo. Essa técnica não funciona no nível do módulo, então estou pensando que isso é um erro no Dive Into Python.

Aqui está um exemplo de funções de classe privada:

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

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

Você pode adicionar uma função interna:

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

Algo assim se você realmente precisar desse nível de privacidade.

Essa é uma pergunta antiga, mas agora as variáveis ​​manipuladas do módulo privado (um sublinhado) e da classe privada (dois sublinhados) agora são abordadas na documentação padrão:

O tutorial do Python » Classes » Variáveis ​​privadas

incorporado com fechamentos ou funções é uma maneira. Isso é comum em JS, embora não seja necessário para plataformas que não sejam de navegador ou trabalhadores de navegador.

No Python, parece um pouco estranho, mas se algo realmente precisa ser oculto, pode ser o caminho. Mais ao ponto de usar a API python e manter as coisas que precisam estar ocultas no C (ou outra linguagem) é provavelmente a melhor maneira. Na falta disso, eu colocaria o código dentro de uma função, chamando isso e retornando os itens que você deseja exportar.

O Python possui três modos via., Privado, público e protegido. Ao importar um módulo, apenas o modo público é acessível. Portanto, os módulos privados e protegidos não podem ser chamados de fora do módulo, ou seja, quando são importados.