Einführung in die Frage, ob Python-Zugriffsbeschränkungen privat oder öffentlich sind (mit Beispielen)

Dieser Artikel gibt Ihnen eine Einführung darüber, ob Python-Zugriffsbeschränkungen privat oder öffentlich sind (mit Beispielen). Ich hoffe, dass er für Freunde hilfreich ist.

1. Wissenspunkte

In einem Modul können wir viele Funktionen und Variablen definieren. Aber wir hoffen, dass einige Funktionen und Variablen von anderen verwendet werden können, und einige Funktionen und Variablen hoffen wir, nur innerhalb des Moduls verwendet zu werden, also?
Wir können dieses Ziel erreichen, indem wir definieren, ob die Funktion und die Variable öffentlich oder privat sind.
In Python wird dies durch das Unterstrich-Präfix „_“ erreicht.

öffentlich: öffentlich. Normale Funktions- und Variablennamen sind von diesem Typ und können direkt referenziert werden. Zum Beispiel Variablen abc, PI usw.;

Spezielle Variablen: Das Format ist __xxx__, beginnend mit __ und endend mit __. Kann direkt referenziert werden, hat aber spezielle Verwendungszwecke. Beispielsweise sind __author__ und __name__ spezielle Variablen. Im Allgemeinen sollten Sie diese Art von Variablennamen nicht für Variablen verwenden, die Sie selbst definieren.

privat: privat, nicht öffentlich, Format ähnlich _xxx_ und __xxx, z. B. __num.
sollte nicht direkt referenziert werden, es kann nur intern und nicht extern darauf zugegriffen werden.
Der interne Zustand des Objekts kann nicht nach Belieben geändert werden, sodass der Code durch den Schutz durch Zugriffsbeschränkungen robuster ist.

2. Beispiele

Innerhalb der Class-Klasse können Attribute und Methoden vorhanden sein. Externer Code kann Daten manipulieren, indem er die Instanzvariablenmethode direkt aufruft und so die interne komplexe Logik verbirgt. Es steht jedoch weiterhin externem Code frei, die Eigenschaften einer Instanz zu ändern. Beispiel:

>>>b.score
99
>>>b.score = 59
>>>b.score
59

Wenn Sie verhindern möchten, dass von außen auf interne Attribute zugegriffen wird, können Sie vor dem Namen des Attributs zwei Unterstriche „__“ hinzufügen, um es wie folgt zu einer privaten Variablen zu machen:

class Student(object):     
    def __init__(self, name, score):         
        self.__name = name         
        self.__score = score     
        
    def print_score(self):         
        print('%s: %s' % (self.__name, self.__score))

Versuchen Sie Folgendes: Beim Zugriff auf Eigenschaften von außen wird ein Fehler gemeldet, da auf private Variablen nicht extern zugegriffen werden kann.

>>> bart = Student('Bart Simpson', 98) 
>>> bart.__name  # 私有变量：不能被外部访问
Traceback (most recent call last):   
File "<stdin>", line 1, in <module> 
AttributeError: 'Student' object has no attribute '__name'

Aber was ist, wenn der externe Code den Namen und die Punktzahl erhalten möchte?
Fügen Sie Methoden hinzu, um Attribute in der Student-Klasse zu erhalten: get_name() und get_score(), wie folgt:

class Student(object):
    ...
    def get_name(self):          
        return self.__name      
    def get_score(self):          
        return self.__score

Was passiert, wenn externer Code die Punktzahl ändert? Sie können der Student-Klasse Einstellungsmethoden hinzufügen: set_score():

...
def set_score(self, score):  
    # 避免传入无效参数  
    if 0 <= score <= 100:  
        self.__score = score 
    else:              
        raise ValueError(&#39;bad score&#39;)

Dürfen dann die privaten Instanzvariablen, die mit einem doppelten Unterstrich beginnen, nicht von außen zugänglich sein? Nicht wirklich.
Sie können nicht direkt auf __name zugreifen, da der Python-Interpreter die Variable __name extern in _Student__name ändert, sodass Sie weiterhin über _Student__name auf die Variable __name zugreifen können.

>>> bart = Student('Bart Simpson', 98)
>>> bart.get_name() 
'Bart Simpson' 
>>> bart.__name = 'New Name'  # 给bart新增的__name变量 
>>> bart.__name               # ！与class内部的__name变量不是一个变量！
'New Name'  
>>> bart.get_name()           # get_name()内部返回self.__name (_Student__name)
'Bart Simpson'

Oberflächlich betrachtet setzt der externe Code die __name-Variable „erfolgreich“, aber tatsächlich ist diese __name-Variable nicht dieselbe Variable wie die __name-Variable innerhalb der Klasse! Die interne Variable __name wurde vom Python-Interpreter automatisch in _Student__name geändert, und der externe Code fügt bart eine neue Variable __name hinzu.

Python hat also keine Möglichkeit, den Zugriff auf private Funktionen oder Variablen vollständig einzuschränken, sodass es nicht „nicht direkt referenzierbar“ ist. Aus Programmiergewohnheiten sollten private Funktionen oder Variablen nicht referenziert werden. Was nützen sie?
Zum Beispiel:

def _private_1 (name):
    return 'hello,%s ' % name
def _private_2 (name):
    return 'hi , %s ' % name
def greeting(name):
    if len(name) > 3:
        return _private_1 (name)
    else:
        return _private_2 (name)

macht die Greeting()-Funktion im Modul verfügbar, verbirgt aber die interne Logik mit einer privaten Funktion. Auf diese Weise müssen Sie sich beim Aufruf der Funktion „gruss()“ nicht um die Details der internen privaten Funktion kümmern.
Dies ist eine sehr nützliche Methode zur Codekapselung und -abstraktion, das heißt: Alle Funktionen, auf die nicht von außen verwiesen werden muss, werden als privat definiert, und nur Funktionen, auf die von außen verwiesen werden muss, werden als öffentlich definiert .

3. Vollständiger Code

rrree

Das obige ist der detaillierte Inhalt vonEinführung in die Frage, ob Python-Zugriffsbeschränkungen privat oder öffentlich sind (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!