Probleme mit pseudo-privaten Python-Variablen und Klassenvererbung

Python-Klassen haben nicht das Konzept, den Zugriff auf Mitgliedsvariablen einzuschränken. Alle Variablen werden als öffentlich behandelt.

Daher ist es möglich, eine pseudo-private Variable zu erstellen, aber als ich versuchte, sie zusammen mit der Klassenvererbung zu verwenden, blieb ich stecken und machte mir eine Notiz zur Fehlerbehebung.

error_case

class BaseClass(object):
    def __init__(self):
        self.__param = "I'm BaseClass"
        
class ChildClass(BaseClass):
    def hello(self):
        print self.__param

ChildClass().hello()

AttributeError Traceback (most recent call last) in () ----> 1 ChildClass().hello() in hello(self) 5 class ChildClass(BaseClass): 6 def hello(self): ----> 7 print self.__param AttributeError: 'ChildClass' object has no attribute '_ChildClass__param'

## Pseudo private Variable

 Indem Sie dem Namen einer Mitgliedsvariablen zwei Unterstriche voranstellen, können Sie eine pseudo-private Variable erstellen.

 Bereiten Sie jedoch intern eine öffentliche Variable mit dem Namen `` _ _ {Klassenname} __ {Variablenname} `` `vor und verweisen Sie innerhalb der Klasse mit dem Namen` `` __ {Variablenname} `` darauf Ich versuche es nur. Deshalb ist es eine "pseudo" private Variable.


#### **`sample_program`**
```python

class Sample(object):
    def __init__(self):
        self.__param = "I'm Sample"

sample = Sample()
print sample.__param

AttributeError Traceback (most recent call last) in () 4 5 sample = Sample() ----> 6 print sample.__param AttributeError: 'Sample' object has no attribute '__param'

#### **`sample_program`**
```python

sample = Sample()
print sample._Sample__param

"I'm Sample"

## Kombination mit Klassenvererbung

 Wie im Fehlerfall oben schlägt ** der Versuch fehl, aus der untergeordneten Klasse heraus auf eine pseudo-private Variable zuzugreifen, die von einer Methode in der übergeordneten Klasse festgelegt wurde **.

 Anscheinend liegt die Ursache in den internen Spezifikationen der pseudo-privaten Variablen.

 Pseudomitgliedvariablen, die in der übergeordneten Klasse deklariert sind, scheinen intern in `` `self._BaseClass__param``` eingetaucht zu sein, selbst wenn sie vererbt werden.

 Wenn Sie dagegen versuchen, "self .__ param" aus einer untergeordneten Klasse zu sehen, wird natürlich auf "_ChildClass__param" "verwiesen, sodass ein Fehler zurückgegeben wird, der besagt, dass keine solche Variable vorhanden ist.

## Lösung

 Wenn Sie die Klassenvererbung verwenden, deklarieren Sie Getter zusammen in der übergeordneten Klasse.


#### **`successful_case1`**
```python

class BaseClass(object):
    def __init__(self):
        self.__param = "I'm BaseClass"
        
    def get_param(self):
        return self.__param
        
class ChildClass(BaseClass):
    def hello(self):
        print self.get_param()

"I'm BaseClass"

 (Update) Machen Sie es zu einer Eigenschaft der übergeordneten Klasse. Es ist möglich, eine direkte Einstellung von außen zu verhindern.


#### **`successful_case2`**
```python

class BaseClass(object):
   def __init__(self):
       self.__param = "I'm BaseClass"

   @property
   def _param(self):
       return self.__param

class ChildClass(BaseClass):
   def hello(self):
       print self._param

Es mag eine Situation sein, die selten vorkommt, aber unerwartet unpraktisch ist.

version

2.7.12 |Anaconda 4.2.0 (x86_64)| (default, Jul 2 2016, 17:43:17) \n[GCC 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2336.11.00)]