Klassische objektorientierte Sprachen wie C++ und Java steuern den Zugriff auf Klassenressourcen durch öffentliche, private und geschützte Schlüsselwörter. Privaten Mitgliedern der Klasse wird der Zugriff von der Umgebung außerhalb der Klasse verweigert. Sie können nur innerhalb der Klasse behandelt werden.

Öffentliche Member

Öffentliche Member (im Allgemeinen in einer Klasse deklarierte Methoden) sind von außerhalb der Klasse zugänglich. Das Objekt derselben Klasse ist erforderlich, um eine öffentliche Methode aufzurufen. Diese Anordnung von privaten Instanzvariablen und öffentlichen Methoden gewährleistet das Prinzip der Datenkapselung.

Alle Member in einer Python-Klasse sind standardmäßig öffentlich. Auf jedes Mitglied kann von außerhalb der Klassenumgebung zugegriffen werden.

class Student: schoolName = 'XYZ School' # class attribute def __init__(self, name, age): self.name=name # instance attribute self.age=age # instance attribute

Sie können auf die Attribute der Student Klasse zugreifen und deren Werte wie unten gezeigt ändern.

>>> std = Student("Steve", 25)>>> std.schoolName'XYZ School'>>> std.name'Steve'>>> std.age = 20>>> std.age25

Geschützte Mitglieder

Geschützte Mitglieder einer Klasse sind innerhalb der Klasse zugänglich und stehen auch ihren Unterklassen zur Verfügung. Keine andere Umgebung darf darauf zugreifen. Dadurch können bestimmte Ressourcen der übergeordneten Klasse von der untergeordneten Klasse geerbt werden.

Pythons Konvention, eine Instanzvariable zu schützen, besteht darin, ein Präfix _ (einzelner Unterstrich) hinzuzufügen. Dies verhindert effektiv, dass darauf zugegriffen wird, es sei denn, es befindet sich innerhalb einer Unterklasse.

class Student: _schoolName = 'XYZ School' # protected class attribute def __init__(self, name, age): self._name=name # protected instance attribute self._age=age # protected instance attribute

Tatsächlich verhindert dies nicht, dass Instanzvariablen auf die Instanz zugreifen oder diese ändern. Sie können weiterhin die folgenden Operationen ausführen:

>>> std = Student("Swati", 25)>>> std._name'Swati'>>> std._name = 'Dipa'>>> std._name'Dipa'

Sie können jedoch eine Eigenschaft mit property decorator definieren und wie unten gezeigt schützen.

class Student:def __init__(self,name):self._name = name@propertydef name(self):return [email protected] name(self,newname):self._name = newname

Oben wird @property decorator verwendet, um die name() Methode als Eigenschaft und @name.setter decorator zu einer anderen Überladung der name() methode als Eigenschaft setter Methode. Jetzt ist _name geschützt.

>>> std = Student("Swati")>>> std.name'Swati'>>> std.name = 'Dipa'>>> std.name'Dipa'>>> std._name # still accessible

Oben haben wir std.name Eigenschaft verwendet, um _name Attribut zu ändern. Es ist jedoch immer noch in Python zugänglich. Daher würde der verantwortliche Programmierer es unterlassen, von außerhalb seiner Klasse auf Instanzvariablen zuzugreifen und diese zu ändern, denen _ vorangestellt ist.

Private Mitglieder

Python hat keinen Mechanismus, der den Zugriff auf eine Instanzvariable oder -methode effektiv einschränkt. Python schreibt eine Konvention vor, dem Namen der Variablen / Methode einen einfachen oder doppelten Unterstrich voranzustellen, um das Verhalten von geschützten und privaten Zugriffsspezifizierern zu emulieren.

Der doppelte Unterstrich __, der einer Variablen vorangestellt ist, macht sie privat. Es gibt einen starken Vorschlag, es nicht von außerhalb der Klasse zu berühren. Jeder Versuch, dies zu tun, führt zu einem AttributeError:

class Student: __schoolName = 'XYZ School' # private class attribute def __init__(self, name, age): self.__name=name # private instance attribute self.__salary=age # private instance attribute def __display(self): # private method print('This is private method.')

>>> std = Student("Bill", 25)>>> std.__schoolNameAttributeError: 'Student' object has no attribute '__schoolName'>>> std.__nameAttributeError: 'Student' object has no attribute '__name'>>> std.__display()AttributeError: 'Student' object has no attribute '__display'

Python führt die Namensänderung privater Variablen durch. Jedes Element mit einem doppelten Unterstrich wird in _object._class__variable geändert. Es kann also immer noch von außerhalb der Klasse zugegriffen werden, aber die Praxis sollte unterlassen werden.

>>> std = Student("Bill", 25)>>> std._Student__name'Bill'>>> std._Student__name = 'Steve'>>> std._Student__name'Steve'>>> std._Student__display()'This is private method.'

Somit bietet Python eine konzeptionelle Implementierung von öffentlichen, geschützten und privaten Zugriffsmodifikatoren, jedoch nicht wie andere Sprachen wie C #, Java, C ++.