Визначаючи метод на класі в Python, він виглядає приблизно так:

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

Але в деяких інших мовах, таких як C #, ви маєте посилання на об'єкт, до якого метод пов'язаний з ключовим словом "це", не оголошуючи його як аргумент у прототипі методу.

Чи було це навмисне мовне дизайнерське рішення в Python чи є якісь деталі реалізації, які потребують передачі "Я" в якості аргументу?

Мені подобається цитувати Пітерсона Дзен Пітона. "Явне краще, ніж неявне."

У Java та C ++ ' this.' можна вивести, за винятком випадків, коли у вас є імена змінних, які унеможливлюють виведення. Тож вам іноді це потрібно, а іноді - ні.

Python вирішує зробити такі речі явними, а не спиратися на правило.

Крім того, оскільки нічого не мається на увазі чи передбачається, частини реалізації піддаються впливу. self.__class__, self.__dict__І інші «внутрішні» структури доступні очевидним чином.

Це звести до мінімуму різницю між методами та функціями. Це дозволяє легко генерувати методи в метакласах або додавати методи під час виконання до вже існуючих класів.

напр

>>> 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!
>>>

Це також (наскільки я знаю) полегшує реалізацію виконання пітона.

Я пропоную прочитати блог Гідо ван Россума на цю тему - Чому явне самоврядування повинно залишатися .

Коли декорування визначення методу оформлено, ми не знаємо, чи автоматично надати йому параметр "self" чи ні: декоратор може перетворити функцію в статичний метод (у якого немає "self"), або в метод класу (який має кумедний вид самості, який посилається на клас замість екземпляра), або він може зробити щось зовсім інше (тривіально написати декоратор, який реалізує '@classmethod' або '@staticmethod' в чистому Python). Неможливо, не знаючи, що робить декоратор, надавати методу, який визначається, неявним аргументом "я" чи ні.

Я відкидаю хаки, такі як "@classmethod" та "@staticmethod".

Python не змушує вас використовувати "self". Ви можете дати йому будь-яке ім'я. Вам просто потрібно пам’ятати, що перший аргумент у заголовку визначення методу - це посилання на об’єкт.

Також дозволяє це зробити: (коротше кажучи, виклик Outer(3).create_inner_class(4)().weird_sum_with_closure_scope(5)поверне 12, але зробить це найвиразнішими способами.

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

Звичайно, це важче уявити в таких мовах, як Java та C #. Зробивши явну самопосилання, ви можете посилатися на будь-який об’єкт за допомогою цієї самонавірки. Крім того, такий спосіб гри з заняттями під час виконання важче зробити в більш статичних мовах - це не обов'язково добре чи погано. Просто явне «я» дозволяє всій цій божевільності існувати.

Більше того, уявіть собі це: ми хотіли б налаштувати поведінку методів (для профілювання чи божевільної чорної магії). Це може змусити нас задуматися: а якби у нас був клас Method, поведінку якого ми могли б перекрити чи контролювати?

Ну ось це:

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()

А тепер: InnocentClass().magic_method()діятиме так, як очікувалося. Метод буде пов'язаний з innocent_selfпараметром до InnocentClassі з magic_selfекземпляром MagicMethod. Дивно, так? Це як два ключові слова this1та this2такі мови, як Java та C #. Магія, як це, дозволяє рамкам робити речі, які інакше були б набагато більш багатослівними.

Знову ж таки, я не хочу коментувати етику цього матеріалу. Мені просто хотілося показати речі, які було б важче зробити без явного посилання на себе.

Я думаю, що справжня причина, окрім "Дзен Пітона", полягає в тому, що Функції є громадянами першого класу в Python.

Що по суті робить їх Об'єктом. Тепер основоположним питанням є те, якщо ваші функції також об'єктні, то в об'єктно-орієнтованій парадигмі, як би ви надсилали повідомлення об’єктам, коли самі повідомлення є об'єктами?

Схоже на проблему з курячим яйцем, щоб зменшити цей парадокс, єдиний можливий спосіб - це передати контекст виконання методам або виявити його. Але оскільки python може мати вкладені функції, зробити це було б неможливо, оскільки контекст виконання змінився б для внутрішніх функцій.

Це означає, що єдино можливим рішенням є явне проходження 'себе' (контекст виконання).

Тож я вважаю, що це проблема впровадження, в яку з'явився Дзен значно пізніше.

Я думаю, що це стосується PEP 227:

Назви в межах класу недоступні. Імена розв’язуються в найпотужнішій області застосування функції. Якщо визначення класу відбувається в ланцюжку вкладених областей, процес роздільної здатності пропускає визначення класів. Це правило запобігає непарній взаємодії між атрибутами класу та локальним змінним доступом. Якщо операція зв’язування імені відбувається у визначенні класу, вона створює атрибут на результуючому об'єкті класу. Для доступу до цієї змінної у методі або у функції, вкладеній у метод, слід використовувати посилання на атрибут, або через self, або через ім'я класу.

Як пояснено в самоврядування в Python, Demystified

все на зразок obj.meth (args) стає Class.meth (obj, args). Процес виклику є автоматичним, поки процес прийому не є (явний). З цієї причини першим параметром функції в класі повинен бути сам об’єкт.

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

Виклики:

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

init () визначає три параметри, але ми просто пройшли два (6 і 8). Аналогічно відстань () вимагає передавання одного, але нульового аргументу.

Чому Python не скаржиться на невідповідність цього аргументу ?

Як правило, коли ми викликаємо метод з деякими аргументами, відповідна функція класу викликається шляхом розміщення об'єкта методу перед першим аргументом. Отже, що-небудь на зразок obj.meth (args) стає Class.meth (obj, args). Процес виклику є автоматичним, поки процес прийому не є (явний).

З цієї причини першим параметром функції в класі повинен бути сам об’єкт. Запис цього параметра як самостійна - це лише умова . Це не ключове слово і не має особливого значення в Python. Ми можемо використовувати інші назви (як це), але я настійно пропоную вам цього не робити. Використання імен, окрім self, спокушається більшістю розробників і погіршує читабельність коду ("Читання читання").
...
У першому прикладі self.x є атрибутом екземпляра, тоді як x - локальна змінна. Вони не однакові і лежать у різних просторах імен.

Сам тут залишився

Багато хто запропонував самостійно зробити ключове слово в Python, наприклад, у C ++ та Java. Це дозволило б усунути зайве використання явного "Я" зі списку формальних параметрів у методах. Хоча ця ідея здається перспективною, вона не відбудеться. Принаймні, не найближчим часом. Основна причина - відстала сумісність . Ось блог від самого творця Python, який пояснює, чому явне «я» має залишатися.

Є ще одна дуже проста відповідь: згідно з дзен пітона "явний кращий, ніж неявний".