Les classes Python n'ont pas le concept de restreindre l'accès aux variables membres. Toutes les variables sont traitées comme publiques.
Par conséquent, il est possible de créer une variable pseudo-privée, mais lorsque j'ai essayé de l'utiliser avec l'héritage de classe, je suis resté bloqué, j'ai donc pris une note en guise de dépannage.
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)
## Pseudo variable privée
Vous pouvez créer une pseudo variable privée en préfixant le nom d'une variable membre avec deux traits de soulignement.
Cependant, en interne, préparez une variable publique nommée `` `` _ {classname} __ {variable name} `` ``, et faites-y référence depuis la classe avec le nom `` __ {variable name} `` ``. J'essaye juste de le faire. C'est pourquoi c'est une variable privée "pseudo".
#### **`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)
#### **`sample_program`**
```python
sample = Sample()
print sample._Sample__param
"I'm Sample"
## Combinaison avec héritage de classe
Comme dans le cas d'erreur en haut, ** une tentative d'accès à une variable pseudo-privée définie par une méthode de la classe parent depuis l'intérieur de la classe enfant échoue **.
Apparemment, la cause est due aux spécifications internes de la variable pseudo-privée.
Les variables pseudo-membres déclarées dans la classe parente semblent être plongées en interne dans `` self._BaseClass__param '', même si elles sont héritées.
D'un autre côté, lorsque vous essayez de voir `` `` self .__ param``` à partir d'une classe enfant, c'est naturellement `` _ChildClass__param``` qui fait référence, donc une erreur indiquant qu'il n'y a pas de telle variable est renvoyée.
## Solution
Si vous utilisez l'héritage de classe, déclarez les getters ensemble dans la classe parent.
#### **`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"
(Mise à jour) Faites-en une propriété de la classe parent. Il est possible d'empêcher le réglage direct de l'extérieur.
#### **`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
Il peut s'agir d'une situation qui se produit rarement, mais qui est inopinément gênante.
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)]
Recommended Posts