Podczas definiowania metody w klasie w Pythonie wygląda to mniej więcej tak:

class MyClass(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

Ale w niektórych innych językach, takich jak C #, istnieje odwołanie do obiektu, z którym metoda jest powiązana, za pomocą słowa kluczowego „this” bez deklarowania go jako argumentu w prototypie metody.

Czy była to celowa decyzja dotycząca projektu języka w Pythonie, czy też są jakieś szczegóły implementacji, które wymagają podania „siebie” jako argumentu?

Lubię cytować zen Pythona Petersa. „Wyraźne jest lepsze niż ukryte”.

W Javie i C ++ this.można wydedukować „ ”, chyba że masz nazwy zmiennych, które uniemożliwiają wywnioskowanie. Więc czasami tego potrzebujesz, a czasami nie.

Python decyduje się, aby takie rzeczy były jawne, a nie oparte na regułach.

Ponadto, ponieważ nic nie jest implikowane ani zakładane, części implementacji są ujawniane. self.__class__, self.__dict__I innych „wewnętrzne” struktury dostępne są w oczywisty sposób.

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

na przykład

>>> 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 także (o ile wiem) ułatwia implementację środowiska uruchomieniowego Pythona.

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

Kiedy dekorowana jest definicja metody, nie wiemy, czy automatycznie nadawać jej parametr „self”, czy też nie: dekorator mógłby przekształcić funkcję w metodę statyczną (która nie ma „self”), czy metodę klasową (która ma zabawny rodzaj self, które odwołuje się do klasy zamiast instancji) lub może zrobić coś zupełnie innego (napisanie dekoratora, który implementuje '@classmethod' lub '@staticmethod' w czystym Pythonie, jest trywialne). Nie ma sposobu, nie wiedząc, co robi dekorator, czy obdarzyć definiowaną metodę niejawnym argumentem „ja”, czy nie.

Odrzucam hacki typu „@classmethod” i „@staticmethod”.

Python nie zmusza cię do używania "self". Możesz nadać mu dowolną nazwę. Musisz tylko pamiętać, że pierwszy argument w nagłówku definicji metody to odwołanie 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 #. Wyraźnie określając odniesienie do siebie, możesz swobodnie odwoływać się do dowolnego obiektu za pomocą tego odniesienia. Ponadto taki sposób grania z klasami w czasie wykonywania jest trudniejszy do wykonania w bardziej statycznych językach - niekoniecznie jest to dobre lub złe. Chodzi tylko o to, że jawne ja pozwala istnieć całym tym szaleństwu.

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

Cóż, oto 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()

A teraz: InnocentClass().magic_method()będzie działać zgodnie z oczekiwaniami. Metoda zostanie powiązana z innocent_selfparametrem to InnocentClassi z magic_selfinstancją MagicMethod. Dziwne co? To tak, jakby 2 słowa kluczowe this1i this2w językach takich jak Java i C #. Taka magia pozwala frameworkom robić rzeczy, które w innym przypadku byłyby znacznie bardziej szczegółowe.

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 of Python” jest to, że funkcje są obywatelami pierwszej klasy w Pythonie.

Co zasadniczo czyni je przedmiotem. Teraz podstawową kwestią jest to, że jeśli twoje funkcje również są obiektami, w jaki sposób w paradygmacie zorientowanym obiektowo wysyłasz komunikaty do obiektów, gdy same komunikaty są obiektami?

Wygląda na problem z jajami kurzymi. Aby zmniejszyć ten paradoks, jedynym możliwym sposobem jest przekazanie kontekstu wykonania do metod lub wykrycie go. Ale ponieważ Python może mieć funkcje zagnieżdżone, byłoby to niemożliwe, ponieważ kontekst wykonania zmieniłby się dla funkcji wewnętrznych.

Oznacza to, że jedynym możliwym rozwiązaniem jest jawne przekazanie „siebie” (kontekstu wykonania).

Więc uważam, że jest to problem z implementacją Zen pojawił się 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 najbardziej wewnętrznym obejmującym zakresie funkcji. Jeśli definicja klasy występuje w łańcuchu zagnieżdżonych zasięgów, proces rozstrzygania pomija definicje klas. Ta reguła zapobiega dziwnym interakcjom między atrybutami klas a dostępem do zmiennych lokalnych. Jeśli operacja wiązania nazwy występuje w definicji klasy, tworzy atrybut na wynikowym obiekcie klasy. Aby uzyskać dostęp do tej zmiennej w metodzie lub w funkcji zagnieżdżonej w metodzie, należy użyć odwołania do atrybutu, poprzez self lub za pośrednictwem nazwy klasy.

Jak wyjaśniono w self w Pythonie, Demystified

coś w rodzaju obj.meth (args) staje się Class.meth (obj, args). Proces wywołujący jest automatyczny, podczas gdy proces odbierający nie jest (jest to jawne). Z tego powodu pierwszym parametrem funkcji w klasie musi być sam obiekt.

class Point(object):
    def __init__(self,x = 0,y = 0):
        self.x = x
        self.y = y

    def distance(self):
        """Find distance from origin"""
        return (self.x**2 + self.y**2) ** 0.5

Modły:

>>> p1 = Point(6,8)
>>> p1.distance()
10.0

w tym () definiuje trzy parametry, ale właśnie przekazaliśmy dwa (6 i 8). Podobnie distance () wymaga podania jednego, ale nie przekazano żadnych argumentów.

Dlaczego Python nie narzeka na niezgodność numeru tego argumentu ?

Generalnie, gdy wywołujemy metodę z pewnymi argumentami, wywoływana jest odpowiednia funkcja klasy poprzez umieszczenie obiektu metody przed pierwszym argumentem. Zatem wszystko, jak obj.meth (args), staje się Class.meth (obj, args). Proces wywołujący jest automatyczny, a proces odbierający nie (jest to jawne).

Z tego powodu pierwszym parametrem funkcji w klasie musi być sam obiekt. Zapisywanie tego parametru jako self jest jedynie konwencją . Nie jest to słowo kluczowe i nie ma specjalnego znaczenia w Pythonie. Moglibyśmy użyć innych nazw (takich jak ta), ale zdecydowanie odradzam. Większość programistów spotyka się z dezaprobatą używania nazw innych niż self i pogarsza czytelność kodu („Liczy się czytelność”).
...
W pierwszym przykładzie self.x jest atrybutem instancji, podczas gdy x jest zmienną lokalną. Nie są takie same i znajdują się w różnych przestrzeniach nazw.

Self Is Here to Stay

Wiele osób zaproponowało uczynienie siebie słowem kluczowym w Pythonie, na przykład w C ++ i Javie. Pozwoliłoby to wyeliminować zbędne użycie jawnego self z formalnej listy parametrów w metodach. Chociaż ten pomysł wydaje się obiecujący, to się nie wydarzy. Przynajmniej nie w najbliższej przyszłości. Głównym powodem jest kompatybilność wsteczna . Oto blog od samego twórcy Pythona wyjaśniający, dlaczego jawne ja musi zostać.

Parametr „self” zachowuje bieżący obiekt wywołujący.

class class_name:
    class_variable
    def method_name(self,arg):
        self.var=arg 
obj=class_name()
obj.method_name()

tutaj argument self przechowuje obiekt obj. Stąd wyrażenie self.var oznacza obj.var

Jest też inna bardzo prosta odpowiedź: zgodnie z zenem Pythona , „wyraźne jest lepsze niż niejawne”.