Método protegido en Python

Question

Duplicar posibles:
Making a method private in a python subclass
Private Variables and Methods in Python

¿Cómo puedo definir un método en una clase Python que está protegido y sólo las subclases pueden verlo?

Este es mi código:

class BaseType(Model): 
    def __init__(self): 
     Model.__init__(self, self.__defaults()) 


    def __defaults(self): 
     return {'name': {}, 
       'readonly': {}, 
       'constraints': {'value': UniqueMap()}, 
       'cType': {} 
     } 


    cType = property(lambda self: self.getAttribute("cType"), lambda self, data:    self.setAttribute('cType', data)) 
    name = property(lambda self: self.getAttribute("name"), lambda self, data: self.setAttribute('name', data)) 
    readonly = property(lambda self: self.getAttribute("readonly"), 
         lambda self, data: self.setAttribute('readonly', data)) 

    constraints = property(lambda self: self.getAttribute("constraints")) 

    def getJsCode(self): 
     pass 

    def getCsCode(self): 
     pass 


    def generateCsCode(self, template=None, constraintMap=None, **kwargs): 
     if not template: 
      template = self.csTemplate 

     if not constraintMap: constraintMap = {} 
     atts = "" 

     constraintMap.update(constraintMap) 

     for element in self.getNoneEmptyAttributes(): 
      if not AbstractType.constraintMap.has_key(element[0].lower()): 
       continue 
      attTemplate = Template(AbstractType.constraintMap[element[0].lower()]['cs']) 
      attValue = str(element[1]['value']) 
      atts += "%s " % attTemplate.substitute({'value': attValue}) 

     kwargs.update(dict(attributes=atts)) 

     return template.substitute(kwargs) 



class MainClass(BaseType, Model): 
    def __init__(self): 
     #Only Model will initialize 
     Model.__init__(self, self.__defaults()) 
     BaseType.__init__(self) 

    def __defaults(self): 
     return {'name': {}, 
       'fields': {'value': UniqueMap()}, 
       'innerClass': {'value': UniqueMap()}, 
       'types': {} 
     } 

    fields = property(lambda self: self.getAttribute("fields")) 
    innerClass = property(lambda self: self.getAttribute("innerClass")) 
    types = property(lambda self: self.getAttribute("types")) 


    @staticmethod 
    def isType(iType): 
    #  return type(widget) in WidgetSelector.widgets.itervalues() 
     return isinstance(iType, AbstractType) 

    def addType(self, type): 
     if not MainClass.isType(type): 
      raise Exception, "Unknown widget type %s" % type 
     self.types[type.name] = type 

quiero que sólo subclases de BaseType ver el método de BaseTypegenerateCsCode.

Answer 1

Python no admite la protección de acceso como lo hace C++/Java/C#. Todo es público El lema es: "Todos somos adultos aquí". Documente sus clases e insista en que sus colaboradores lean y sigan la documentación.

La cultura en Python es que los nombres que comienzan con guiones bajos significan, "no los uses a menos que realmente sepas que deberías". Puede optar por comenzar sus métodos "protegidos" con guiones bajos. Pero tenga en cuenta que esto es solo una convención, no cambia cómo se puede acceder al método.

Los nombres que comiencen con doble guión bajo (__name) están dañados, por lo que las jerarquías de herencia se pueden generar sin temor a colisiones de nombres. Algunas personas usan esto para métodos "privados", pero una vez más, no cambia la forma en que se puede acceder al método.

La mejor estrategia es acostumbrarse a un modelo donde todo el código en un solo proceso debe escribirse para llevarse bien.

Answer 2

No puede. Python intencionalmente no es compatible con el control de acceso. Por convención, los métodos que comienzan con un guión bajo son privados, y debe indicar claramente en la documentación quién debe usar el método.