Jakie jest znaczenie pojedynczego i podwójnego podkreślenia przed nazwą obiektu?

Doskonałe odpowiedzi na razie, ale niektórych ciekawostek brakuje. Jeśli używasz from foobar import *, a moduł foobar nie definiuje listy __all__, nazwy zaimportowane z modułu nie zawierają tych, które mają podkreślenie. Powiedzmy, że to głównie konwencja, ponieważ ta sprawa to dość niejasny kąt; -).

Konwencja leading-underscore jest szeroko stosowana nie tylko dlaprywatnych nazw, ale także dla tego, co C++ nazwałby protected - na przykład, nazwy metod, które są w pełni przeznaczone do nadpisywania przez podklasy (nawet te, które mają do nadpisania, ponieważ w klasie bazowej raise NotImplementedError!- ) są często nazwami jednokierunkowymi wskazującymi na kod przy użyciu instancji tej klasy (lub podklas), które nie mają być wywoływane bezpośrednio.

Na przykład, aby utworzyć kolejkę bezpieczną dla wątków z inną dyscypliną kolejkowania niż FIFO, Kolejka importowa, Kolejka podklas._get i _put; "kod klienta" nigdy nie wywołuje tych metod ("hook"), ale raczej ("organizowanie") publicznych metod, takich jak put i get (jest to znane jako metoda szablon wzór projektu -- zobacz np. tutaj dla interesującej prezentacji opartej na wideo mojego wystąpienia na ten temat, z dodatkiem synopsów transkryptu).

Edit: linki wideo w opisie rozmowy zostały przerwane. Pierwsze dwa filmy znajdziesz tutaj i tutaj .

__foo__: Jest to tylko konwencja, sposób, w jaki system Pythona używa nazw, które nie będą sprzeczne z nazwami użytkowników.

_foo: jest to tylko konwencja, sposób dla programisty, aby wskazać, że zmienna jest prywatna (cokolwiek to oznacza w Pythonie).

__foo: ma to prawdziwe znaczenie: interpreter zastępuje tę nazwę _classname__foo, aby upewnić się, że nazwa nie będzie pokrywać się z podobną nazwą w innej klasie.

Żadna inna forma podkreślenia nie ma znaczenia w Python world.

W tych konwencjach nie ma różnicy między klasą, zmienną, globalną itp.

._variable jest semiprivate i oznacza tylko dla konwencji

.__variable jest często błędnie uważany za superprivate, podczas gdy jego rzeczywiste znaczenie polega na tym, aby namemangle zapobiec przypadkowemu dostępowi[1]

.__variable__ jest zazwyczaj zarezerwowane dla wbudowanych metod lub zmiennych

Nadal możesz uzyskać dostęp do zmiennych .__mangled, jeśli desperacko chcesz. Podwójne podkreślenie tylko namemangles, lub zmienia nazwy, zmienna na coś w rodzaju instance._className__mangled

Przykład:

class Test(object):
    def __init__(self):
        self.__a = 'a'
        self._b = 'b'

>>> t = Test()
>>> t._b
'b'

T. _b jest dostępny, ponieważ jest ukryty tylko przez Konwencję

>>> t.__a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Test' object has no attribute '__a'

T._ _ a nie został znaleziony, ponieważ już nie istnieje z powodu namemanglingu

>>> t._Test__a
'a'

Poprzez dostęp do instance._className__variable zamiast tylko podwójnej nazwy podkreślenia, możesz uzyskać dostęp do ukrytej wartości

Pojedyncze podkreślenie na początku:

Python nie ma prawdziwych prywatnych metod. Zamiast tego jedno podkreślenie na początku nazwy metody lub atrybutu oznacza, że nie powinieneś uzyskiwać dostępu do tej metody, ponieważ nie jest ona częścią 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)

(ten fragment kodu został zaczerpnięty z kodu źródłowego django: django/forms/forms.py). w tym kodzie, errors jest własnością publiczną, ale metoda wywołana przez tę właściwość, _get_errors, jest "prywatna", więc nie powinieneś uzyskiwać dostępu to.

Dwa podkreślenia na początku:

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!

Wyjście:

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

Teraz Utwórz podklasę B i dostosuj metodę _ _ test

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

b = B()
b.test()

Wyjście będzie....

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

Jak widzieliśmy, A. test() nie wywołał B. _ _ test() metody, jak możemy się spodziewać. Ale w rzeczywistości jest to właściwe zachowanie dla __. Dwie metody o nazwie _ _ test() są automatycznie zmieniane na _a _ _ test() i _ B _ _ test (), więc nie są przypadkowo nadpisywane. Kiedy tworzysz metodę zaczynającą się od__, oznacza to, że nie chcesz, aby ktokolwiek mógł ją nadpisać, a zamierzasz uzyskać do niej dostęp tylko z wewnątrz jej własnej klasy.

Dwa podkreślenia na początku i na końcu:

Gdy widzimy metodę taką jak __this__, nie nazywaj tego. Jest to metoda, którą python ma wywoływać, nie ty. Przyjrzyjmy się:

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

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

Zawsze istnieje operator lub natywna funkcja, która wywołuje te magiczne metody. Czasami jest to tylko hak python wywołuje w określonych sytuacjach. Na przykład wywołanie __init__() jest wywołane, gdy obiekt zostanie utworzony po wywołaniu __new__() w celu zbudowania instancji...

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

Aby uzyskać więcej informacji, zobacz przewodnik PEP-8 . Więcej magicznych metod, zobacz ten PDF .

Https://dbader.org/blog/meaning-of-underscores-in-python

• pojedynczy podkreślnik wiodący (_var) : konwencja nazewnictwa wskazująca nazwę jest przeznaczona do użytku wewnętrznego. Generalnie nie jest to wymuszone przez interpreter Pythona (z wyjątkiem importowania symboli wieloznacznych) i ma na celu jedynie podpowiedź dla programisty.
• pojedynczy końcowy podkreślnik (var_) : używany przez Konwencję, aby uniknąć konfliktu nazw ze słowami kluczowymi Pythona.
• Podwójne Prowadzenie Underscore (__var) : wyzwala manipulację nazw, gdy jest używana w kontekście klasy. Wymuszone przez interpreter Pythona.
• podwójny znak podkreślenia (__var__) : wskazuje specjalne metody zdefiniowane przez język Python. Unikaj tego schematu nazewnictwa dla własnych atrybutów.
• pojedynczy podkreślnik (_) : czasami używany jako nazwa dla zmiennych tymczasowych lub nieistotnych ("don' t care"). Również: wynik ostatniego wyrażenia w REPL Pythona.

Czasami masz coś, co wydaje się być krotką z wiodącym podkreśleniem, jak w

def foo(bar):
    return _('my_' + bar)

W tym przypadku chodzi o to, że _() jest aliasem dla funkcji lokalizacyjnej, która operuje na tekście, aby umieścić go w odpowiednim języku itp. na podstawie lokalizacji. Na przykład, Sphinx robi to, a znajdziesz wśród importu

from sphinx.locale import l_, _

I w Sfinksie.locale, _ () jest przypisany jako alias niektórych funkcji lokalizacyjnych.

Ponieważ tak wiele osób odnosi się do rozmowy Raymonda , ułatwię to trochę, zapisując to, co powiedział: {]}

Intencją podwójnego podkreślenia nie była prywatność. Intencją było użycie go dokładnie w ten sposób

class Circle(object):

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

    def area(self):
        p = self.__perimeter()
        r = p / math.pi / 2.0
        return math.pi * r ** 2.0

    def perimeter(self):
        return 2.0 * math.pi * self.radius

    __perimeter = perimeter  # local reference


class Tire(Circle):

    def perimeter(self):
        return Circle.perimeter(self) * 1.25

To przeciwieństwo prywatności, chodzi o wolność. To sprawia, że Twoje podklasy są wolne, aby nadpisać jedną metodę bez łamania innych.

Say you don ' t keep a local reference of perimeter in Circle. Klasa pochodna Tire nadpisuje implementację perimeter, bez dotykania area. Kiedy wywołujesz Tire(5).area(), teoretycznie powinno ono nadal używać Circle.perimeter do obliczeń, ale w rzeczywistości używa Tire.perimeter, co nie jest zamierzonym zachowaniem. Dlatego potrzebujemy lokalnego referenta w kręgu.

Ale dlaczego __perimeter zamiast _perimeter? Ponieważ _perimeter nadal daje klasie pochodnej szansę na nadpisanie:

class Tire(Circle):

    def perimeter(self):
        return Circle.perimeter(self) * 1.25

    _perimeter = perimeter

Podwójne podkreślenie ma nazwę mangling, więc jest bardzo mała szansa, że lokalne odniesienie w klasie rodzica zostanie nadpisane w klasie pochodnej. w ten sposób "sprawia, że Twoje podklasy są wolne do nadpisywania jednej metody bez łamania pozostałych".

Jeśli twoja klasa nie zostanie odziedziczona, lub nadpisanie metody niczego nie zepsuje, to po prostu nie potrzebujesz __double_leading_underscore.

Jeśli ktoś naprawdę chce zrobić zmienną tylko do odczytu, IMHO najlepszym sposobem byłoby użycie property() z przekazanym do niej tylko getterem. Dzięki property() możemy mieć pełną kontrolę nad danymi.

class PrivateVarC(object):

    def get_x(self):
        pass

    def set_x(self, val):
        pass

    rwvar = property(get_p, set_p)  

    ronly = property(get_p) 

Rozumiem, że OP zadał trochę inne pytanie, ale ponieważ znalazłem inne pytanie pytające o "jak ustawić zmienne prywatne" oznaczone duplikatem z tym, pomyślałem o dodaniu tej dodatkowej informacji tutaj.

Świetne odpowiedzi i wszystkie są poprawne.Podałem prosty przykład wraz z prostą definicją/znaczeniem.

Znaczenie:

Some_variable -- ► it ' s public everyone can see this.

_some_variable --► to jest publiczne każdy może to zobaczyć, ale jest to konwencja wskazująca na prywatne...warning żadne egzekwowanie nie jest wykonywane przez Pythona.

_ _ some_varaible --► Python zamienia nazwę zmiennej na _classname_ _ some_varaible (aka name mangling) i zmniejsza / ukrywa jej widoczność i być bardziej jak prywatna zmienna.

Żeby być szczerym zgodnie z dokumentacją Pythona

""prywatne" zmienne instancji, do których nie można uzyskać dostępu z wyjątkiem wewnątrz obiektu nie istnieje w Pythonie "

Przykład:

class A():
    here="abc"
    _here="_abc"
    __here="__abc"


aObject=A()
print(aObject.here) 
print(aObject._here)
# now if we try to print __here then it will fail because it's not public variable 
#print(aObject.__here)

Oto prosty przykład jak właściwości podwójnego podkreślenia mogą wpływać na dziedziczoną klasę. Tak więc z następującą konfiguracją:

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"

Jeśli następnie utworzysz instancję potomną w REPL Pythona, zobaczysz poniższy

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'

Pojedyncze podkreślenie wiodące jest konwencją. nie ma różnicy z punktu widzenia interpretera, czy nazwy zaczynają się od pojedynczego podkreślenia, czy nie.

Podwójne podkreślniki prowadzące i końcowe są używane do wbudowanych metod, takich jak __init__, __bool__, itd.

Podwójne podkreślniki wiodące bez końcowych odpowiedników są również konwencją, jednak metody klasy będą zniekształcone przez interpreter. Dla zmiennych lub podstawowych nazw funkcji nie ma różnicy istnieje.

Twoje pytanie jest dobre, nie chodzi tylko o metody. Funkcje i obiekty w modułach są zwykle poprzedzone jednym podkreśleniem i mogą być poprzedzone dwoma.

Ale _ _ podwójne _ nazwy podkreślenia nie są zniekształcane w modułach, na przykład. Dzieje się tak, że Nazwy zaczynające się od jednego (lub więcej) podkreślenia nie są importowane, jeśli zaimportujesz wszystkie z modułu (z modułu import*), ani nazwy pokazane w pomocy(moduł).

"prywatne" zmienne instancji, do których nie można uzyskać dostępu poza obiektem, nie istnieją w Pythonie. Jednak istnieje konwencja, PO której następuje większość kodu Pythona: nazwa poprzedzona podkreśleniem (np. _spam) powinna być traktowana jako Niepubliczna część API (niezależnie od tego, czy jest to funkcja, metoda czy Element danych). Należy go uznać za szczegółową implementację i może ulec zmianie bez Uwaga.

Odniesienie https://docs.python.org/2/tutorial/classes.html#private-variables-and-class-local-references

Poznanie faktów _ i _ _ jest dość łatwe; Inne odpowiedzi wyrażają je całkiem dobrze. Użycie jest znacznie trudniejsze do określenia.

Tak to widzę:

_

Powinny być użyte do wskazania, że funkcja nie jest przeznaczona do użytku publicznego, jak na przykład API. To i ograniczenie importu sprawiają, że zachowuje się podobnie jak internal w c#.

__

Powinny być używane, aby uniknąć kolizji nazw w hirarchii dziedziczenia i aby uniknąć opóźnień. Podobnie jak prywatne w c#.

==>

Jeśli chcesz zaznaczyć, że coś nie jest do użytku publicznego, ale powinno działać tak, jak protected Użyj _. Jeśli chcesz zaznaczyć, że coś nie jest do użytku publicznego, ale powinno działać tak, jak private użyj __.

Jest to również cytat, który bardzo lubię:

Problem polega na tym, że autor klasy może słusznie myśleć " to nazwa atrybutu/metody powinna być prywatna, dostępna tylko od wewnątrz ta definicja klasy " i używać konwencji _ _ private. Ale później, użytkownik tej klasy może utworzyć podklasę, która dostęp do tego nazwiska. Więc albo superklasa musi zostać zmodyfikowana (co może być trudne lub niemożliwe), lub kod podklasy musi używaj ręcznie zniekształconych nazw (co jest w najlepszym razie brzydkie i kruche).

Ale problem z tym jest moim zdaniem, że jeśli nie ma IDE, które ostrzega cię, gdy nadpisujesz metody, znalezienie błędu może zająć trochę czasu, jeśli przypadkowo nadpisałeś metodę z klasa podstawowa.

W przypadku metod, możesz użyć podwójnego podkreślenia, aby ukryć prywatne 'metody'z następującym wzorem:

# Private methods of MyClass
def _MyClass__do_something(obj:'MyClass'):
    print('_MyClass__do_something() called. type(obj) = {}'.format(type(obj)))

class MyClass():
    def __init__(self):
        __do_something(self)

mc = MyClass()

Wyjście:

_MyClass__do_something() called. type(obj) = <class '__main__.MyClass'>

Natknąłem się na to dzisiaj, kiedy próbowałem użyć podwójnego podkreślenia dla metod klasowych i dostałem błąd NameError: name '_<class><method>' is not defined.

• _var: zmienne z wiodącym pojedynczym podkreśleniem w Pythonie są klasycznymi zmiennymi, które mają informować innych użytkowników kodu, że ta zmienna powinna być zarezerwowana do użytku wewnętrznego. Różnią się one w jednym punkcie od klasycznych zmiennych: nie są importowane podczas importu wieloznacznego obiektu / modułu, w którym są zdefiniowane (wyjątki przy definiowaniu __all__ zmienna ). Eg:

  # foo.py
  
  var = "var"
  _var = "_var"
  

  # bar.py
  
  from foo import *
  
  print(dir())  # list of defined objects, contains 'var' but not '_var'
  print(var)    # var
  print(_var)   # NameError: name '_var' is not defined
  

• _ : pojedyncze podkreślenie jest szczególnym przypadkiem wiodące pojedyncze zmienne podkreślenia. Jest używana przez Konwencję jako zmienna kosza, do przechowywania wartości, która nie jest przeznaczona do późniejszego dostępu. Nie jest również importowany przez import wildcard. Na przykład: ta pętla for wyświetla" nie mogę rozmawiać w klasie " 10 razy i nigdy nie musi mieć dostępu do zmiennej _.

  for _ in range(10):
      print("I must not talk in class")
  

• __var: podwójne zmienne podkreślenia początkowego(co najmniej dwa początkowe podkreślenia, co najwyżej jeden końcowy podkreślenie). Gdy są używane jako atrybuty klasy (zmienne i metody), zmienne te podlegają namagnesowaniu nazw: poza klasą python zmieni nazwę atrybutu na _<Class_name>__<attribute_name>. Przykład:

  class MyClass:
      __an_attribute = "attribute_value"
  
  my_class = MyClass()
  print(my_class._MyClass__an_attribute)  # "attribute_value"
  print(my_class.__an_attribute)  # AttributeError: 'MyClass' object has no attribute '__an_attribute'
  

  Gdy są używane jako zmienne spoza klasy, zachowują się jak pojedyncze początkowe zmienne podkreślenia.

• __var__: podwójne interlinia i końcowe podkreślenie (co najmniej dwa interlinia i końcowe podkreślenie). Nazywany również dunders . Ta konwencja nazewnictwa jest używana przez Pythona do wewnętrznego definiowania zmiennych. Unikaj używania tego konwencja zapobiegająca konfliktom nazw, które mogą powstać w przypadku aktualizacji Pythona. Zmienne Dunder zachowują się jak pojedyncze początkowe zmienne podkreślenia: nie podlegają manipulowaniu nazw, gdy są używane wewnątrz klas, ale nie są importowane w importach wieloznacznych.