Jaki jest związek pomiędzy modelem danych Pythona a wbudowanymi funkcjami?

• wbudowane operatory używają bazowych metod lub atrybutów datamodel.
• wbudowane i operatory mają bardziej eleganckie zachowanie i ogólnie są bardziej kompatybilne do przodu.
• specjalne metody datamodelu są semantycznie niepublicznymi interfejsami.
• wbudowane operatory i operatory językowe mają być interfejsem użytkownika do zachowania realizowane specjalnymi metodami.

W związku z tym, powinieneś używać wbudowanych funkcji i operatorów tam, gdzie to możliwe, zamiast specjalnych metod i atrybutów datamodelu.

• możesz znaleźć podczas aktualizacji programu wykonywalnego Pythona lub przełączania się na inne implementacje Pythona (takie jak PyPy, IronPython lub Jython, lub innej nieprzewidzianej implementacji) pojawia się więcej zmian.)
• twoi koledzy prawdopodobnie źle pomyślą o twoich umiejętnościach językowych i sumienności, i uznają to za zapach kodu, doprowadzając Ciebie i resztę twojego kodu do większej kontroli.
• wbudowane funkcje są łatwe do przechwycenia zachowania. Stosowanie specjalnych metod bezpośrednio ogranicza moc Twojego Pythona do introspekcji i debugowania.

W głębi

Wbudowane funkcje i operatory wywołują specjalne metody i używają specjalnych atrybutów w modelu danych Pythona. Są czytelną i konserwowalną okleiną, która ukrywa wnętrza przedmiotów. Ogólnie rzecz biorąc, użytkownicy powinni używać wbudowanych i operatorów podanych w języku, a nie wywoływać specjalnych metod lub używać specjalnych atrybutów bezpośrednio.

Wbudowane funkcje i operatory mogą również mieć zachowanie awaryjne lub bardziej eleganckie niż bardziej prymitywne metody specjalne datamodel. Na przykład:

• next(obj, default) pozwala na podanie domyślnej wartości zamiast podnoszenia StopIteration, gdy iterator się wyczerpie, podczas gdy obj.__next__() nie.
• str(obj) powróci do obj.__repr__(), gdy obj.__str__() nie jest dostępna - podczas gdy wywołanie obj.__str__() bezpośrednio wywoła błąd atrybutu.
• obj != other fallsback to not obj == other w Pythonie 3 Gdy Nie __ne__ - wywołanie obj.__ne__(other) nie zajęłoby zaleta tego.

(wbudowane funkcje mogą być również łatwo przysłonięte, jeśli jest to konieczne lub pożądane, na globalnym zasięgu modułu lub modułu builtins, aby jeszcze bardziej dostosować zachowanie.)

Mapowanie wbudowanych operatorów do datamodelu

Tutaj jest mapowanie, z uwagami, wbudowanych funkcji i operatorów do odpowiednich specjalnych metod i atrybutów, których używają lub zwracają-zauważ, że zwykle zasada jest taka, że wbudowana funkcja Zwykle mapuje do nie jest to jednak na tyle spójne, aby uzasadnić podanie tej mapy poniżej: {]}

builtins/     special methods/
operators  -> datamodel               NOTES (fb == fallback)

repr(obj)     obj.__repr__()          provides fb behavior for str
str(obj)      obj.__str__()           fb to __repr__ if no __str__
bytes(obj)    obj.__bytes__()         Python 3 only
unicode(obj)  obj.__unicode__()       Python 2 only
format(obj)   obj.__format__()        format spec optional.
hash(obj)     obj.__hash__()
bool(obj)     obj.__bool__()          Python 3, fb to __len__
bool(obj)     obj.__nonzero__()       Python 2, fb to __len__
dir(obj)      obj.__dir__()
vars(obj)     obj.__dict__            does not include __slots__
type(obj)     obj.__class__           type actually bypasses __class__ -
                                      overriding __class__ will not affect type
help(obj)     obj.__doc__             help uses more than just __doc__
len(obj)      obj.__len__()           provides fb behavior for bool
iter(obj)     obj.__iter__()          fb to __getitem__ w/ indexes from 0 on
next(obj)     obj.__next__()          Python 3
next(obj)     obj.next()              Python 2
reversed(obj) obj.__reversed__()      fb to __len__ and __getitem__
other in obj  obj.__contains__(other) fb to __iter__ then __getitem__
obj == other  obj.__eq__(other)
obj != other  obj.__ne__(other)       fb to not obj.__eq__(other) in Python 3
obj < other   obj.__lt__(other)       get >, >=, <= with @functools.total_ordering
complex(obj)  obj.__complex__()
int(obj)      obj.__int__()
float(obj)    obj.__float__()
round(obj)    obj.__round__()
abs(obj)      obj.__abs__()

Moduł operator ma length_hint, który ma zabezpieczenie zaimplementowane odpowiednią specjalną metodą, jeśli __len__ nie jest zaimplementowany:

length_hint(obj)  obj.__length_hint__() 

Przerywane Poszukiwania

Przerywane wyszukiwania są kontekstowe. Bez specjalnej implementacji metod, najpierw poszukaj w hierarchii klas deskryptorów danych( takich jak właściwości i szczeliny), a następnie w instancji __dict__ (na przykład zmienne), następnie w hierarchii klas dla deskryptorów Nie-danych (jak metody). Specjalne metody implementują następujące zachowania:

obj.attr      obj.__getattr__('attr')       provides fb if dotted lookup fails
obj.attr      obj.__getattribute__('attr')  preempts dotted lookup
obj.attr = _  obj.__setattr__('attr', _)    preempts dotted lookup
del obj.attr  obj.__delattr__('attr')       preempts dotted lookup

Deskryptory

Deskryptory są nieco zaawansowane - możesz pominąć te wpisy i wrócić później-przypomnij sobie, że instancja deskryptora znajduje się w hierarchii klas (jak metody, sloty i właściwości). Deskryptor danych implementuje albo __set__ albo __delete__:

obj.attr        descriptor.__get__(obj, type(obj)) 
obj.attr = val  descriptor.__set__(obj, val)
del obj.attr    descriptor.__delete__(obj)

Gdy klasa jest instancjowana (zdefiniowana), następująca metoda deskryptora __set_name__ jest wywoływana, jeśli jakiś deskryptor ma ją poinformować deskryptor o jego nazwie atrybutu. (Jest to nowość w Pythonie 3.6.) cls jest taki sam jak type(obj) powyżej, a 'attr' oznacza nazwę atrybutu:

class cls:
    @descriptor_type
    def attr(self): pass # -> descriptor.__set_name__(cls, 'attr') 

Items (notacja dolna)

obj[name]         -> obj.__getitem__(name)
obj[name] = item  -> obj.__setitem__(name, item)
del obj[name]     -> obj.__delitem__(name)

Specjalny przypadek dla podklas dict, __missing__ jest wywoływane, jeśli __getitem__ nie znajdzie klucza:

obj[name]         -> obj.__missing__(name)  

Operatory

Istnieją również specjalne metody dla +, -, *, @, /, //, %, divmod(), pow(), **, <<, >>, &, ^, | operatory, na przykład:

obj + other   ->  obj.__add__(other), fallback to other.__radd__(obj)
obj | other   ->  obj.__or__(other), fallback to other.__ror__(obj)

obj += other  ->  obj.__iadd__(other)
obj |= other  ->  obj.__ior__(other)

I operacje jednostkowe:

+obj          ->  obj.__pos__()
-obj          ->  obj.__neg__()
~obj          ->  obj.__invert__()

Menedżery Kontekstu

Menedżer kontekstu definiuje __enter__, która jest wywoływana przy wprowadzaniu bloku kodu (jego wartość zwracana, Zwykle self, jest aliasowana przez as), i __exit__, która jest gwarantowana przy opuszczaniu bloku kodu, z informacjami o wyjątkach.

with obj as cm:     ->  cm = obj.__enter__()
    raise Exception('message')
->  obj.__exit__(Exception, Exception('message'), traceback_object)

Jeśli __exit__ otrzyma wyjątek i następnie zwraca wartość false, po opuszczeniu metody będzie ją ponownie uruchamiać.

Jeśli nie ma wyjątku, __exit__ otrzymujeNone dla tych trzech argumentów, a wartość zwracana jest bez znaczenia:

with obj:           ->  obj.__enter__()
    pass
->  obj.__exit__(None, None, None)

Niektóre Metaklasy Specjalne Metody

isinstance(obj, cls) -> cls.__instancecheck__(obj)
issubclass(sub, cls) -> cls.__subclasscheck__(sub)

Ważne jest to, że podczas gdy builtins jak next i bool nie zmieniają się między Pythonem 2 i 3, podstawowe nazwy implementacji zmieniają się.

W ten sposób korzystanie z wbudowanych oferuje również większą kompatybilność.

Kiedy mam używać specjalnych nazw?

W Pythonie Nazwy zaczynające się od podkreślenia są semantycznie niepublicznymi nazwami dla użytkowników. Podkreśleniem jest sposób Stwórcy powiedzenie: "Ręce precz, nie dotykaj."

Jest to nie tylko kulturowe, ale także w traktowaniu API przez Pythona. gdy pakiet __init__.py używa import * do dostarcza API z podpakietu, jeśli podpakiet nie zawiera __all__, wyklucza Nazwy zaczynające się od podkreślenia. Nie można również wykluczyć podpakietu __name__.

Narzędzia autocompletion IDE są mieszane pod względem nazw zaczynających się od podkreślenia jako Niepubliczne. Jednak bardzo doceniam, że nie widzę __init__, __new__, __repr__, __str__, __eq__, itd. (ani żaden z użytkowników nie stworzył interfejsów niepublicznych) kiedy wpisuję nazwę obiektu i kropka.

Tak twierdzę:

Specjalne metody "dunder" nie są częścią publicznego interfejsu. Unikaj używania ich bezpośrednio.

Głównym przypadkiem użycia jest implementacja własnego obiektu lub podklasy wbudowanego obiektu.

Użyj specjalnego atrybutu __name__ na funkcjach lub klasach

Kiedy udekorujemy funkcja, zazwyczaj otrzymujemy w zamian funkcję wrappera, która ukrywa pomocne informacje o funkcji. Użyjemy dekoratora @wraps(fn), aby upewnić się, że nie utracimy tej informacji, ale jeśli potrzebujemy nazwy funkcji, musimy użyć atrybutu __name__ bezpośrednio:

from functools import wraps

def decorate(fn): 
    @wraps(fn)
    def decorated(*args, **kwargs):
        print('calling fn,', fn.__name__) # exception to the rule
        return fn(*args, **kwargs)
    return decorated

Podobnie, wykonuję następujące czynności, gdy potrzebuję nazwy klasy obiektu w metodzie (używanej na przykład w __repr__):

def get_class_name(self):
    return type(self).__name__
          # ^          # ^- must use __name__, no builtin e.g. name()
          # use type, not .__class__

Używanie specjalnych atrybutów do pisania niestandardowych klas lub podklasowanych builtins

Kiedy chcemy zdefiniować własne zachowanie, musimy użyć nazw modeli danych.

To ma sens, ponieważ jesteśmy wykonawcami, te atrybuty nie są dla nas prywatne.

class Foo(object):
    # required to here to implement == for instances:
    def __eq__(self, other):      
        # but we still use == for the values:
        return self.value == other.value
    # required to here to implement != for instances:
    def __ne__(self, other): # docs recommend for Python 2.
        # use the higher level of abstraction here:
        return not self == other  

Jednak, nawet w tym przypadku, nie używamy self.value.__eq__(other.value) lub not self.__eq__(other) (zobacz moją odpowiedź tutaj , aby udowodnić, że ta ostatnia może prowadzić do nieoczekiwanego zachowania.) Zamiast tego powinniśmy użyć wyższego poziomu abstrakcji.

Kolejny punkt, w którym musimy użyć specjalnego nazwy metod są wtedy, gdy jesteśmy w implementacji dziecka i chcemy przekazać je rodzicowi. Na przykład:

class NoisyFoo(Foo):
    def __eq__(self, other):
        print('checking for equality')
        # required here to call the parent's method
        return super(NoisyFoo, self).__eq__(other) 

Podsumowanie

Specjalne metody pozwalają użytkownikom zaimplementować interfejs dla wewnętrznych obiektów.

Używaj wbudowanych funkcji i operatorów, gdzie tylko możesz. Używaj specjalnych metod tylko wtedy, gdy nie ma udokumentowanego publicznego API.