Metodo protetto in python

Question

Eventuali duplicati:
Making a method private in a python subclass
Private Variables and Methods in Python

Come posso definire un metodo in una classe di pitone che è protetto e solo sottoclassi possono vederlo?

Questo è il mio codice:

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 

voglio che appena sottoclassi BaseType vedono il metodo della BaseTypegenerateCsCode.

Answer 1

Python non supporta la protezione dell'accesso come fa C++/Java/C#. Tutto è pubblico. Il motto è: "Siamo tutti adulti qui". Documenta le tue lezioni e insisti affinché i tuoi collaboratori leggano e seguano la documentazione.

La cultura in Python è che i nomi che iniziano con caratteri di sottolineatura significano "non usarli a meno che tu non sappia davvero che dovresti". Potresti scegliere di iniziare i metodi "protetti" con caratteri di sottolineatura. Ma tieni presente che questa è solo una convenzione, non cambia il modo in cui è possibile accedere al metodo.

I nomi che iniziano con caratteri di sottolineatura doppio (__name) vengono storpiati, in modo che le gerarchie di ereditarietà possano essere create senza timore di conflitti di nomi. Alcune persone li usano per metodi "privati", ma, ancora una volta, non cambia il modo in cui è possibile accedere al metodo.

La strategia migliore è quella di abituarsi a un modello in cui tutto il codice in un singolo processo deve essere scritto per andare d'accordo.

Answer 2

Non è possibile. Python intenzionalmente non supporta il controllo degli accessi. Per convenzione, i metodi che iniziano con un carattere di sottolineatura sono privati ​​e si dovrebbe indicare chiaramente nella documentazione chi deve utilizzare il metodo.