metodo - Definición de funciones de módulos privados en python
python clases funciones (8)
En Python, la "privacidad" depende de los niveles de acuerdo de los "adultos que dan su consentimiento": no se puede forzar (más de lo que se puede en la vida real ;-). Un único guión bajo significa que no se debe acceder "desde afuera": dos guiones bajos (sin guiones bajos) llevan el mensaje con más fuerza ... pero, al final, todavía depende de las redes sociales. convención y consenso: la introspección de Python es lo suficientemente contundente como para que no puedas esposar a todos los demás programadores del mundo para que respeten tus deseos.
((Por cierto, aunque es un secreto cercano, lo mismo vale para C ++: con la mayoría de los compiladores, una simple línea #define private public antes de #include su archivo .h es todo lo que se necesita para que los codificadores astutos hagan hash de su " intimidad"...!-))
De acuerdo con http://www.faqs.org/docs/diveintopython/fileinfo_private.html :
Como la mayoría de los lenguajes, Python tiene el concepto de elementos privados:
- Funciones privadas, que no se pueden llamar desde fuera de su módulo
Sin embargo, si defino dos archivos:
#a.py
__num=1
y:
#b.py
import a
print a.__num
cuando ejecuto b.py imprime 1 sin dar ninguna excepción. Está diveintopython mal, o no entendí bien algo? ¿Y hay alguna forma de definir la función de un módulo como privada?
Esta es una pregunta antigua, pero las variables mutiladas tanto del módulo privado (un guión bajo) como de la clase privada (dos guiones bajos) ahora están cubiertas en la documentación estándar:
Esta pregunta no recibió una respuesta completa, ya que la privacidad del módulo no es puramente convencional, y dado que el uso de la importación puede o no reconocer la privacidad del módulo, dependiendo de cómo se use.
Si define nombres privados en un módulo, esos nombres se importarán a cualquier script que use la sintaxis, ''import module_name''. Por lo tanto, suponiendo que haya definido correctamente en su ejemplo el módulo private, _num, en a.py, como tal ...
#a.py
_num=1
..usted podría acceder a él en b.py con el símbolo del nombre del módulo:
#b.py
import a
...
foo = a._num # 1
Para importar solo elementos no privados de a.py, debe usar la sintaxis from :
#b.py
from a import *
...
foo = _num # throws NameError: name ''_num'' is not defined
En aras de la claridad, sin embargo, es mejor ser explícito al importar nombres de los módulos, en lugar de importarlos con un ''*'':
#b.py
from a import name1
from a import name2
...
Puede haber confusión entre los privados de clase y los privados de módulo .
Un módulo privado comienza con un guión bajo
Tal elemento no se copia junto con el uso de la forma from <module_name> import * del comando de importación; Sin embargo, se importa si se usa la sintaxis import <moudule_name> ( ver la respuesta de Ben Wilhelm )
Simplemente elimine un guión bajo del a .__ num del ejemplo de la pregunta y no se mostrará en los módulos que importan a.py utilizando la sintaxis from a import * .
Una clase privada comienza con dos guiones bajos (también conocido como dunder ie d-ouble bajo puntaje)
Tal variable tiene su nombre "mutilado" para incluir el nombre de clase, etc.
Todavía se puede acceder fuera de la lógica de clase, a través del nombre destrozado.
Aunque el cambio de nombre puede servir como un dispositivo de prevención leve contra el acceso no autorizado, su objetivo principal es evitar posibles colisiones de nombres con los miembros de clase de las clases antecesoras. Vea la referencia divertida pero precisa de Alex Martelli a los adultos que consienten mientras describe la convención utilizada en relación con estas 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
>>>
Puedes agregar una función interna:
def public(self, args):
def private(self.root, data):
if (self.root != None):
pass #do something with data
Algo así si realmente necesitas ese nivel de privacidad.
Python permite miembros privados de la clase con el doble prefijo de subrayado. Esta técnica no funciona a nivel de módulo, así que estoy pensando que esto es un error en Dive Into Python.
Aquí hay un ejemplo de funciones de clase privadas:
class foo():
def bar(self): pass
def __bar(self): pass
f = foo()
f.bar() # this call succeeds
f.__bar() # this call fails
Python tiene tres modos vía., Privado, público y protegido. Mientras que la importación de un módulo solo se puede acceder al modo público. Por lo tanto, no se pueden llamar módulos privados y protegidos desde el exterior del módulo, es decir, cuando se importa.
incrustado con cierres o funciones es una forma. Esto es común en JS aunque no es necesario para plataformas que no sean de navegador o trabajadores de navegador.
En Python parece un poco extraño, pero si algo realmente necesita ser ocultado de lo que podría ser el camino. Más que nada utilizar la API de Python y mantener las cosas que requieren estar ocultas en la C (u otro idioma) es probablemente la mejor manera. De lo contrario, iría por poner el código dentro de una función, llamándolo y haciendo que devuelva los artículos que desea exportar.