Was ist der Sinn von einem Einzel - und einem Doppel-Unterstrich vor dem Objekt-Namen?

Einzelner Unterstrich

Namen, eine Klasse, mit einem führenden Unterstrich sind einfach zu geben, um anderen Programmierern, die das Attribut bzw. die Methode soll privat sein. Jedoch, nichts besonderes ist geschehen durch den Namen selbst.

Zitieren PEP-8:

_single_leading_underscore: schwache "interne Verwendung" - Anzeiger. E. g. from M import * importiert keine Objekte, deren name beginnt mit einem Unterstrich.

Doppelten Unterstrich (Name Mangling)

Vom die Python docs:

Jeder Bezeichner der form __spam (mindestens zwei führende Unterstriche, höchstens ein trailing underscore) ist textlich ersetzt mit _classname__spamwo classname ist die aktuelle Klassennamen mit führendem Unterstrich(s) entfernt. Diese mangeln wird ohne Berücksichtigung der syntaktisches position des Bezeichners, so kann es verwendet werden, um zu definieren, class-private Instanz-und Klassenvariablen, Methoden, Variablen gespeichert, die in globals, und auch Variablen gespeicherten Instanzen. private zu dieser Klasse in Instanzen anderer Klassen.

Und eine Warnung von der gleichen Seite:

Name mangling ist dazu bestimmt, Klassen eine einfache Möglichkeit zu definieren, "private" Instanzvariablen und-Methoden, ohne sich sorgen zu machen über die Instanz-Variablen definiert, die von abgeleiteten Klassen oder ausmisten mit Instanz-Variablen, die von code außerhalb der Klasse. Beachten Sie, dass die mangling Regeln sind so gestaltet sich meist um Unfälle zu vermeiden; es ist immer noch möglich, für eine bestimmte Seele, zugreifen oder ändern Sie eine variable, die als private.

Beispiel

>>> class MyClass():
...     def __init__(self):
...             self.__superprivate = "Hello"
...             self._semiprivate = ", world!"
...
>>> mc = MyClass()
>>> print mc.__superprivate
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: myClass instance has no attribute '__superprivate'
>>> print mc._semiprivate
, world!
>>> print mc.__dict__
{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

InformationsquelleAutor der Antwort Andrew Keeton

__foo__: dies ist nur eine Konvention, eine Möglichkeit für das Python-system zu verwenden, Namen, die keine Konflikte mit den Benutzer-Namen.

_foo: dies ist nur eine Konvention, eine Möglichkeit für den Programmierer, um anzuzeigen, dass die variable ist privat (was auch immer das bedeutet in Python).

__foo: dieses echte Bedeutung hat: der interpreter ersetzt diesen Namen mit _classname__foo als ein Weg, um sicherzustellen, dass die Namen überschneiden sich nicht mit ähnlichen Namen in einer anderen Klasse.

Keine andere form unterstreicht Bedeutung in der Python-Welt.

Gibt es keinen Unterschied zwischen Klassen, Variablen, global, etc, die in diesen Konventionen.

InformationsquelleAutor der Antwort Ned Batchelder

Einzelner Unterstrich am Anfang:

Python keine realen privaten Methoden. Stattdessen wird ein Unterstrich am Anfang einer Methode oder Attribut-name heißt, Sie sollten nicht auf diese Methode zugreifen, denn es ist nicht Teil der API.

class BaseForm(StrAndUnicode):

    def _get_errors(self):
        "Returns an ErrorDict for the data provided for the form"
        if self._errors is None:
            self.full_clean()
        return self._errors

    errors = property(_get_errors)

(Dieses code-snippet stammt aus django-source-code: django/forms/forms.py). In diesem code errors ist ein öffentliches Eigentum, aber die Methode dieser Eigenschaft fordert, _get_errors, ist "privat", so sollten Sie nicht darauf zugreifen.

Zwei Unterstriche am Anfang:

Dies bewirkt, dass eine Menge Verwirrung. Es sollte nicht verwendet werden, zum erstellen einer private-Methode. Es sollte verwendet werden, um zu vermeiden, dass Ihre Methode von einer Unterklasse überschrieben oder versehentlich zugegriffen. Mal sehen, ein Beispiel:

class A(object):
    def __test(self):
        print "I'm a test method in class A"

    def test(self):
        self.__test()

a = A()
a.test()
# a.__test() # This fails with an AttributeError
a._A__test() # Works! We can access the mangled name directly!

Ausgabe:

$ python test.py
I'm test method in class A
I'm test method in class A

Nun erstellen Sie eine Unterklasse B und machen die Anpassung für __test Methode

class B(A):
    def __test(self):
        print "I'm test method in class B"

b = B()
b.test()

Ausgang sein wird....

$ python test.py
I'm test method in class A

Wie wir gesehen haben, A. test() nicht rufen Sie B.__test () - Methode, wie wir erwarten. Aber in der Tat, dies ist das richtige Verhalten, für __. Die zwei Methoden mit dem Namen __test() werden automatisch umbenannt (entstellten) _A__test() und _B__test(), so dass Sie nicht versehentlich überschreiben. Wenn Sie eine Methode erstellen, beginnend mit __ es bedeutet, dass Sie nicht wollen, um jemand in der Lage sein, um es zu überschreiben, und Sie nur wollen, um es von innen seine eigene Klasse.

Zwei Unterstriche am Anfang und am Ende:

Wenn wir sehen, dass eine Methode wie __this__nennen Sie es nicht. Dies ist eine Methode, die python aufrufen soll, nicht Sie. Lassen Sie uns nehmen einen Blick:

>>> name = "test string"
>>> name.__len__()
11
>>> len(name)
11

>>> number = 10
>>> number.__add__(40)
50
>>> number + 50
60

Es ist immer ein operator oder eine native Funktion, die nennt diese Magische Methoden. Manchmal ist es nur ein Haken python Anrufe in bestimmten Situationen. Zum Beispiel __init__() wird aufgerufen, wenn das Objekt erstellt wird, nachdem __new__() genannt wird, zum erstellen der Instanz...

Nehmen wir ein Beispiel...

class FalseCalculator(object):

    def __init__(self, number):
        self.number = number

    def __add__(self, number):
        return self.number - number

    def __sub__(self, number):
        return self.number + number

number = FalseCalculator(20)
print number + 10      # 10
print number - 20      # 40

Für mehr details, siehe die PEP-8-Anleitung. Für mehr Magische Methoden finden Sie unter PDF.

InformationsquelleAutor der Antwort

Unterstrich (_) in Python

Folgenden sind verschiedene Orte, an denen _ wird verwendet, in Python:

Einzelner Unterstrich:

• Dolmetscher
• Nach einem Namen
• Bevor Sie einen Namen

Doppelten Unterstrich:

• __leading_double_Unterstrich

• before_after

• Einzelner Unterstrich

Dolmetscher:

_ gibt den Wert des zuletzt ausgeführten Ausdrucks Wert in Python REPL

>>> a = 10
>>> b = 10
>>> _
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '_' is not defined
>>> a+b
20
>>> _
20
>>> _ * 2
40
>>> _
40
>>> _ / 2
20

Ignoriert Werte:

Mehrere Zeit, die wir nicht wollen, return-Werte zu dieser Zeit zuweisen dieser Werte zu wnderscore. Es verwendet als " Wegwerf-variable.

# Ignore a value of specific location/index
for _ in rang(10)
    print "Test"

# Ignore a value when unpacking
a,b,_,_ = my_method(var1)

Nach einem Namen

Python hat Ihre standardmäßig keywords, die wir nicht verwenden können, als den Namen der variable. Zur Vermeidung solcher Konflikt zwischen python-Schlüsselwort und die variable, die wir benutzen den Unterstrich nach dem Namen

Beispiel:

>>> class MyClass():
...     def __init__(self):
...             print "OWK"

>>> def my_defination(var1 = 1, class_ = MyClass):
...     print var1
...     print class_

>>> my_defination()
1
__main__.MyClass
>>>

Bevor Sie einen Namen

Führenden Unterstrich vor der variable/Funktion/Methode-name zeigt an, für den Programmierer, Es ist nur für die interne Verwendung, die geändert werden können, wenn die Klasse wollen.

Hier-Namen-Präfix durch einen Unterstrich wird behandelt, als nicht-öffentlich.
Wenn Sie angeben, aus Import * werden alle Namen beginnt mit " _ " werden nicht importiert.

Python nicht angeben, wirklich privat ist, sodass diese Karten kann man direkt aufrufen von anderen Modulen, wenn es angegeben ist in alleWir nennen es auch schwache Private

class Prefix:
...     def __init__(self):
...             self.public = 10
...             self._private = 12
>>> test = Prefix()
>>> test.public
10
>>> test._private
12
Python class_file.py

def public_api():
    print "public api"

def _private_api():
    print "private api"

Aufrufende Datei von REPL

>>> from class_file import *
>>> public_api()
public api

>>> _private_api()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '_private_api' is not defined

>>> import class_file
>>> class_file.public_api()
public api
>>> class_file._private_api()
private api
Double Underscore(__)

__leading_double_Unterstrich

Doppelten führenden Unterstriche sagen python-interpreter neu schreiben Namen um Konflikte zu vermeiden in der Unterklasse.Dolmetscherin ändert die variable name mit Klasse Erweiterung und das feature, bekannt als die Mangeln.
testFile.py

class Myclass():
    def __init__(self):
        self.__variable = 10

Aufruf von REPL

>>> import testFile
>>> obj = testFile.Myclass()
>>> obj.__variable
Traceback (most recent call last):
File "", line 1, in
AttributeError: Myclass instance has no attribute '__variable'
nce has no attribute 'Myclass'
>>> obj._Myclass__variable
10

In Mangeln python-interpreter ändern Sie die variable name mit ___. Also Mehrere Zeit als Privates Mitglied, weil eine andere Klasse kann nicht auf die variable direkt. Hauptzweck __ ist die Verwendung der variable/Methode in der Klasse nur, Wenn Sie es verwenden möchten, die außerhalb der Klasse, die Sie können stellen öffentliche api

class Myclass():
    def __init__(self):
        self.__variable = 10
    def func(self)
        print self.__variable

Aufruf von REPL

>>> import testFile
>>> obj = testFile.Myclass()
>>> obj.func()
10

__, BEVOR SIE_NACH__

Namen mit mit __ und endet mit der gleichen Auffassung, spezielle Methoden in Python. Python bieten, diese Methoden zu nutzen, wie es der operator überladen, die vom Benutzer abhängig.

Python bietet dieses übereinkommen unterscheiden zwischen der Benutzer-definierte Funktion mit dem Modul die Funktion

class Myclass():
    def __add__(self,a,b):
        print a*b

Aufruf von REPL

>>> import testFile
>>> obj = testFile.Myclass()
>>> obj.__add__(1,2)
2
>>> obj.__add__(5,2)
10

Referenz

InformationsquelleAutor der Antwort

Einzige führende Unterstriche ist eine Konvention. es gibt keinen Unterschied von der Dolmetscherin, wenn, ob Namen beginnt mit einem einzigen Unterstrich oder nicht.

Doppel-führende und nachfolgende Unterstriche werden verwendet für integrierte Methoden, wie __init____bool__ usw.

Doppelte führende Unterstriche w/o nachgestellte Gegenstücke sind eine Konvention, aber auch die Klasse Methoden werden verstümmelt durch den Dolmetscher. Für Variablen oder basic-Funktion Namen kein Unterschied besteht.

InformationsquelleAutor der Antwort SilentGhost

Hier ist ein einfaches anschauliches Beispiel, wie doppelten Unterstrich Eigenschaften beeinflussen kann eine geerbte Klasse. Also mit folgendem setup:

class parent(object):
    __default = "parent"
    def __init__(self, name=None):
        self.default = name or self.__default

    @property
    def default(self):
        return self.__default

    @default.setter
    def default(self, value):
        self.__default = value


class child(parent):
    __default = "child"

wenn Sie dann erstellen Sie eine untergeordnete Instanz in der python-REPL, sehen Sie das unten

child_a = child()
child_a.default            # 'parent'
child_a._child__default    # 'child'
child_a._parent__default   # 'parent'

child_b = child("orphan")
## this will show 
child_b.default            # 'orphan'
child_a._child__default    # 'child'
child_a._parent__default   # 'orphan'

Dies mag offensichtlich sein, einige, aber es erwischte mich unvorbereitet, in einer viel komplexeren Umwelt

InformationsquelleAutor der Antwort

Immer die Fakten der _ und __ ist ziemlich einfach; die übrigen Antworten äußern Sie ziemlich gut. Die Verwendung ist weitaus schwieriger zu bestimmen.

Dies ist, wie ich es sehe:

_

Sollte verwendet werden, um anzugeben, dass eine Funktion nicht für die öffentliche Nutzung, wie zum Beispiel eine API. Diese und der import Einschränkung machen Verhalten sich ähnlich wie internal in c#.

__

Sollte verwendet werden, um zu vermeiden, den Namen Kollision in der inheritace hirarchy und vermeiden Sie späte Bindung nutzen. Ähnlich wie private in c#.

==>

Möchten Sie darauf hinweisen, dass etwas nicht für die öffentliche Nutzung, aber es sollte wirken wie protected verwenden _.
Wenn Sie möchten, um anzuzeigen, dass etwas ist nicht für die öffentliche Nutzung, aber es sollte wirken wie private verwenden __.

Dies ist auch ein Zitat, dass ich mag sehr viel:

Das problem ist, dass der Autor einer Klasse kann legitim finde "diese
Attribut/Methode name sollte sein eigenes, nur von innen zugänglich
diese definition der Klasse" und nutzen Sie die __private-Konvention. Aber später,
ein Benutzer der Klasse kann eine Unterklasse, die berechtigterweise muss
der Zugang zu diesem Namen. Also entweder die Superklasse muss geändert werden
(das kann schwierig oder unmöglich sein), oder die Unterklasse code
manuell entstellte Namen (die ist hässlich und zerbrechlich am besten).

Aber das problem ist meiner Meinung nach, dass wenn es keine IDE, die Sie warnt, wenn Sie überschreiben die Methoden, Suche nach dem Fehler könnte eine Weile dauern, wenn Sie versehentlich überschrieben eine Methode aus einer Basisklasse.

InformationsquelleAutor der Antwort