Zusammenfassung der Verwendung einzelner Python-Unterstreichungen/doppelter Unterstreichungen

Python verwendet Unterstriche als Variablenpräfixe und -suffixe, um spezielle Variablen/Methoden zu kennzeichnen.

Es gibt vier Hauptsituationen
1. __object # public
2. __object__ # speziell, Python-Systemverwendung, Benutzer sollte nicht so definieren
3. __object # privat (Name Mangel während der Laufzeit)
4. _object # Befolgen Sie die Python-Codierungskonvention und betrachten Sie es als privat.
Kernstil: Vermeiden Sie die Verwendung eines Unterstrichs am Anfang eines Variablennamens.

Da der Unterstrich für den Interpreter eine besondere Bedeutung hat und das von integrierten Bezeichnern verwendete Symbol ist, empfehlen wir Programmierern, die Verwendung eines Unterstrichs am Anfang von Variablennamen zu vermeiden. Im Allgemeinen gilt der Variablenname _object als „privat“ und kann nicht außerhalb des Moduls oder der Klasse verwendet und nicht mit „from moduleimport *“ importiert werden. Wenn die Variable privat ist, empfiehlt es sich, _object zur Darstellung der Variablen zu verwenden. Da der Variablenname __object__ für Python eine besondere Bedeutung hat, sollte dieser Benennungsstil für gewöhnliche Variablen vermieden werden.

Pythons Beschreibung von privat, es gibt kein Konzept von geschützt in Python, es ist entweder öffentlich oder privat, aber privat in Python ist nicht wie C++, Java, es ist nicht privat im eigentlichen Sinne, durch den Namen The Der Mangling-Mechanismus (Namensanpassung (der Zweck besteht darin, zu verhindern, dass Unterklassen versehentlich die Methoden oder Attribute der Basisklasse überschreiben), d. h. mit vorangestelltem „einzelnen Unterstrich“ + Klassennamen, z. B.: _Class__object) kann auf privat zugreifen.

Die Mitgliedsvariablen, die mit „einfacher Unterstrich“ beginnen, werden als geschützte Variablen bezeichnet, was bedeutet, dass nur das Klassenobjekt und das Unterklassenobjekt selbst auf diese Variablen zugreifen können, die mit „doppeltem Unterstrich“ beginnen. Dies bedeutet, dass nur das Klassenobjekt selbst darauf zugreifen kann, selbst Unterklassenobjekte können nicht auf diese Daten zugreifen. (Wie unten gezeigt)
Der Beginn mit einem einzelnen Unterstrich (_foo) stellt Klassenattribute dar, auf die nicht direkt zugegriffen werden kann. Sie müssen über die von der Klasse bereitgestellte Schnittstelle aufgerufen werden und können nicht mit „from xxx import *“ importiert werden Der Beginn mit einem doppelten Unterstrich (__foo) stellt die privaten Mitglieder der Klasse dar; (__foo__), der mit einem doppelten Unterstrich beginnt und endet, stellt die spezielle methodenspezifische Identifikation in Python dar, z. B. __init__(), der den Konstruktor der Klasse darstellt.

1.class Foo():

2 🎜>6.           print „Dies ist eine öffentliche Methode“                                                                                  def _halfprivate_method():
12. Drucken Sie „Dies ist eine führende Unterstrichmethode“
Instanziieren Sie ein Objekt von Foo,

1 ()
1. f.public_method() # OK
3. f.__fullprivate_method() # Fehler aufgetreten
5 🎜>6. ._Foo__fullprivate()_method() # OK

Wie aus dem obigen Beispiel ersichtlich ist, kann auf f._halfprivate_method() tatsächlich direkt zugegriffen werden. Gemäß der Python-Konvention sollten sie jedoch als privat betrachtet und nicht extern verwendet werden (wenn Sie sie verwenden müssen, gibt es keine gute Programmierpraxis, sie nicht extern zu verwenden). Gleichzeitig ist laut Python-Dokument der Umfang von _object und __object auf dieses Modul beschränkt.

========================================== == =================================
Verstehen Sie den Python-Benennungsmechanismus (beginnend mit Single und Double). Unterstriche) (Nachdruck: http://blog.csdn.net/lanphaday)
Einführung
Ich lade alle herzlich ein, die Ausgabe des folgenden Programms zu erraten:
Klasse A(Objekt):
def __init__(self):
self.__private()
self.public()
def __private(self):
print 'A.__private()'
def public(self):
print ' A.public()'
class B(A):
def __private(self):
print 'B.__private()'
def public(self):
print 'B.public()'
b = B()
Erster Blick
Die richtige Antwort lautet:
A.__private()
B.public()
Wenn Sie Wenn Sie es richtig erraten haben, müssen Sie diesen Blog-Beitrag von mir nicht lesen. Wenn Sie nicht richtig geraten haben oder Fragen im Kopf haben, dann ist dieser Blog-Beitrag genau das Richtige für Sie.
Alles beginnt damit, warum „A.__private()“ ausgegeben wird. Aber um zu erklären, warum, müssen wir den Benennungsmechanismus von Python verstehen.
Laut Python-Handbuch ist der Variablenname (Bezeichner) ​​ein atomares Element von Python. Wenn ein Variablenname an ein Objekt gebunden ist, bezieht sich der Variablenname auf das Objekt, genau wie in der menschlichen Gesellschaft, oder? Wenn ein Variablenname in einem Codeblock erscheint, handelt es sich um eine lokale Variable. Wenn ein Variablenname in einem Modul erscheint, handelt es sich um eine globale Variable. Ich glaube, dass jeder ein gutes Verständnis für Module hat, aber Codeblöcke können etwas verwirrend sein. Erklären Sie hier:
Ein Codeblock ist ein Teil des Python-Programmtexts, der als ausführbare Einheit verwendet werden kann. Module, Funktionskörper und Klassendefinitionen sind allesamt Codeblöcke. Darüber hinaus ist jeder interaktive Skriptbefehl auch ein Codeblock; eine Skriptdatei ist ebenfalls ein Codeblock, und ein Befehlszeilenskript ist ebenfalls ein Codeblock.
Als nächstes sprechen wir über die Sichtbarkeit von Variablen. Wir stellen das Konzept des Bereichs vor. Der Bereich ist die Sichtbarkeit des Variablennamens innerhalb des Codeblocks. Wenn eine lokale Variable in einem Codeblock definiert ist, umfasst der Gültigkeitsbereich diesen Codeblock. Wenn eine Variable in einem Funktionscodeblock definiert ist, erstreckt sich der Gültigkeitsbereich auf jeden Codeblock im Funktionsblock, es sei denn, dort ist eine andere Variable mit demselben Namen definiert. Der Umfang der in einer Klasse definierten Variablen ist jedoch auf den Klassencodeblock beschränkt und erstreckt sich nicht auf den Methodencodeblock.
Minzong
Gemäß der Theorie im vorherigen Abschnitt können wir den Code in drei Codeblöcke unterteilen: die Definition von Klasse A, die Definition von Klasse B und die Definition von Variable b. Gemäß der Klassendefinition wissen wir, dass der Code drei Mitgliedsvariablen für Klasse A definiert (Pythons Funktionen sind auch Objekte, daher funktioniert es, wenn die Mitgliedsmethoden Mitgliedsvariablen genannt werden.); Klasse B definiert zwei Mitgliedsvariablen. Dies kann durch den folgenden Code überprüft werden:
>>> print 'n'.join(dir(A))
_A__private
__init__
public
>>> ; print 'n'.join(dir(B))
_A__private
_B__private
__init__
public
Hey, warum hat Klasse A ein Attribut namens _A__private? Und __privat ist verschwunden! Hier geht es um die Unterdrückung privater Variablen in Python.
Erkunden
Freunde, die Python kennen, wissen, dass Python Variablen, die mit zwei oder mehr Unterstrichen beginnen und nicht mit zwei oder mehr Unterstrichen enden, als private Variablen behandelt. Private Variablen werden vor der Codegenerierung in eine Langform konvertiert (öffentlich gemacht). Der Konvertierungsmechanismus sieht folgendermaßen aus: Fügen Sie den Klassennamen am Anfang der Variablen ein und fügen Sie dann am Anfang einen Unterstrich hinzu. Dies wird als Verstümmelung privater Namen bezeichnet. Beispielsweise wird der __private-Bezeichner in Klasse A in _A__private umgewandelt, weshalb _A__private und __private im vorherigen Abschnitt verschwunden sind.
Zwei weitere Abschweifungen:
Erstens, weil der Identifikator durch Rollen länger wird. Wenn er 255 überschreitet, schneidet Python ihn ab. Achten Sie auf die dadurch verursachten Namenskonflikte.
Zweitens führt Python keine Komprimierung mehr durch, wenn alle Klassennamen mit Unterstrichen benannt sind. Zum Beispiel:
>>> class ____(object):
def __init__(self):
self.__method()
def __method(self):
print ' ____ . __method()'
>>> print 'n'.join(dir(____))
__class__
__delattr__
__dict__
__doc__
__getattribute__
__hash__
__init__
__method                                                        >__weakref__
>> ;> obj = ____()
____.__meth od()
>>> obj.__method() # Kann sein extern aufgerufen
____.__method()
Jetzt gehen wir zurück Mal sehen, warum „A.__private()“ ausgegeben wird!
Die Wahrheit
Ich glaube, kluge Leser haben die Antwort inzwischen erraten, oder? Wenn Sie noch nicht darüber nachgedacht haben, möchte ich Ihnen einen Hinweis geben: Die Wahrheit ähnelt der Makrovorverarbeitung in der C-Sprache.
Da Klasse A eine private Mitgliedsfunktion (Variable) definiert, wird das Komprimieren privater Variablen vor der Codegenerierung durchgeführt (beachten Sie die rot markierte Zeile im vorherigen Abschnitt?). Nach dem Rollen sieht der Code der Klasse A wie folgt aus:
Klasse A(Objekt):
def __init__(self):
self._A__private() # Diese Zeile hat sich geändert
self.public()
def _A__private(self): # Diese Zeile hat sich auch geändert
                                print 'A.__private ()'
def public(self):
print 'A.public()'
Ist es nicht ein bisschen wie eine Makroerweiterung in der C-Sprache?
Da die Methode __init__ bei der Definition von Klasse B nicht überschrieben wurde, wird A.__init__ weiterhin aufgerufen, dh self._A__private() wird ausgeführt und „A.__private()“ wird natürlich ausgegeben.
Die folgenden zwei Codeteile können die Überzeugungskraft erhöhen und das Verständnis verbessern:
>>> Klasse C(A):
def __init__(self): # Schreiben Sie __init__ neu und nennen Sie self nicht mehr ._A__private
self.__private() # Was hier gebunden ist, ist _C_private
self.public()
def __private(self):
print 'C.__priv ate()'
def public( self):
print 'C.public()'
>>> c = C()
C.__private()
C.public()
# ## ######################
>>> Klasse A(Objekt):
def __init__(self) :
self._A__private()  # Rufen Sie eine undefinierte Funktion auf, Python wird sie mir geben.                                                              ( )'
def public(self):
print 'A.public()'
>>>a = A()
A.__private()
A.public ()