Dlaczego musisz mieć jawnie argument "self" w metodzie Pythona?

Ma na celu zminimalizowanie różnicy między metodami i funkcjami. Pozwala na łatwe generowanie metod w metaklasach lub dodawanie metod w czasie wykonywania do wcześniej istniejących klas.

Np.

>>> class C(object):
...     def foo(self):
...         print "Hi!"
...
>>>
>>> def bar(self):
...     print "Bork bork bork!"
...
>>>
>>> c = C()
>>> C.bar = bar
>>> c.bar()
Bork bork bork!
>>> c.foo()
Hi!
>>>

To również (o ile wiem) ułatwia implementację środowiska uruchomieniowego Pythona.

Proponuję przeczytać blog Guido van Rossuma na ten temat - Dlaczego jawne ja musi zostać.

Kiedy definicja metody jest dekorowana, nie wiemy, czy automatycznie nadać jej parametr "self", czy nie: dekorator może przekształcić funkcję w statyczną metodę (która nie ma "self"), czy metodę klasy (która ma zabawny rodzaj "self", który odnosi się do klasy zamiast instancji), lub może zrobić coś zupełnie innego (jest to "self"). trywialne jest napisanie dekoratora implementującego ' @ classmethod 'lub' @staticmethod ' w czystym Pythonie). Nie ma mowy, nie wiedząc, co robi dekorator, czy nadać metodzie zdefiniowanej ukrytym argumentem "ja", czy nie.

Odrzucam hacki typu special-casing '@classmethod ' i '@staticmethod'.

Python nie zmusza cię do używania "ja". Możesz nadać mu dowolne imię. Trzeba tylko pamiętać, że pierwszy argument w nagłówku definicji metody jest odniesieniem do obiektu.

Pozwala również na to: (w skrócie, wywołanie Outer(3).create_inner_class(4)().weird_sum_with_closure_scope(5) zwróci 12, ale zrobi to w najbardziej szalony sposób.

class Outer(object):
    def __init__(self, outer_num):
        self.outer_num = outer_num

    def create_inner_class(outer_self, inner_arg):
        class Inner(object):
            inner_arg = inner_arg
            def weird_sum_with_closure_scope(inner_self, num)
                return num + outer_self.outer_num + inner_arg
        return Inner

Oczywiście trudniej to sobie wyobrazić w językach takich jak Java i C#. Poprzez wyraźne odniesienie do siebie, możesz swobodnie odnosić się do dowolnego obiektu za pomocą tego odniesienia. Ponadto, taki sposób grania klasami w czasie wykonywania jest trudniejszy do zrobienia w bardziej statycznych językach - nie to, że jest to koniecznie dobre lub złe. Tylko, że Jawna jaźń pozwala na to wszystko szaleństwo istnienia.

Co więcej, wyobraź sobie to: chcielibyśmy dostosować zachowanie metod (do profilowania, lub jakiejś szalonej czarnej magii). Może to prowadzić nas do myślenia: co by było, gdybyśmy mieli klasę Method, której zachowanie moglibyśmy nadpisać lub kontrolować?

No to jest:

from functools import partial

class MagicMethod(object):
    """Does black magic when called"""
    def __get__(self, obj, obj_type):
        # This binds the <other> class instance to the <innocent_self> parameter
        # of the method MagicMethod.invoke
        return partial(self.invoke, obj)


    def invoke(magic_self, innocent_self, *args, **kwargs):
        # do black magic here
        ...
        print magic_self, innocent_self, args, kwargs

class InnocentClass(object):
    magic_method = MagicMethod()

And now: InnocentClass().magic_method() will act like expected. Metoda zostanie powiązana z parametrem innocent_self do InnocentClass, a z magic_self do instancji MagicMethod. Dziwne, co? To tak jakby mieć 2 słowa kluczowe this1 i this2 w językach takich jak Java i C#. Magia taka jak ta pozwala frameworkom robić rzeczy, które w przeciwnym razie byłyby znacznie bardziej gadatliwe.

Ponownie, nie chcę komentować etyki tych rzeczy. Chciałem tylko pokazać rzeczy, które byłyby trudniejsze do zrobienia bez wyraźnego odniesienia do siebie.

Myślę, że prawdziwym powodem oprócz "Zen Pythona" jest to, że funkcje są obywatelami pierwszej klasy w Pythonie.

Co zasadniczo czyni je obiektem. Teraz podstawową kwestią jest, jeśli twoje funkcje są również obiektowe, to w paradygmacie zorientowanym obiektowo, Jak wysyłasz wiadomości do obiektów, gdy same wiadomości są obiektami ?

Wygląda na problem jaj kurzych, aby zmniejszyć ten paradoks, jedynym możliwym sposobem jest albo przekazanie kontekstu wykonania metodom, albo Wykryj to. Ale ponieważ python może mieć zagnieżdżone funkcje, nie byłoby to możliwe, ponieważ kontekst wykonania zmieniłby się dla funkcji wewnętrznych.

Oznacza to, że jedynym możliwym rozwiązaniem jest jawne przekazanie "self" (kontekstu wykonania).

Więc uważam, że jest to problem implementacji Zen przyszedł znacznie później.

Myślę, że ma to związek z PEP 227:

Nazwy w zakresie klas nie są dostępne. Nazwy są rozwiązywane w najskrytszy domknięty zakres funkcji. Jeśli definicja klasy występuje w łańcuch zagnieżdżonych zakresów, proces rozdzielczości pomija klasę definicje. Reguła ta zapobiega dziwnym interakcjom między klasami atrybuty i dostęp do zmiennych lokalnych. Jeśli operacja wiążąca nazwę występuje w definicji klasy, tworzy atrybut na wynikowym obiekt klasy. Aby uzyskać dostęp tej zmiennej w metodzie lub w funkcji zagnieżdżone w metodzie, musi być użyte odniesienie do atrybutu, albo poprzez self lub poprzez nazwę klasy.

Jest jeszcze jedna bardzo prosta odpowiedź: zgodnie z zen Pythona, "explicit is better than implicit".