Как избежать явного «я» в Python?

Я изучал Python, следуя некоторым руководствам по pygame .

В нем я нашел широкое использование ключевого слова self и, исходя в основном из Java, обнаружил, что все время забываю вводить self . Например, вместо self.rect.centerxя бы напечатал rect.centerx, потому что для меня rect уже является переменной-членом класса.

Параллель Java, о которой я могу думать в этой ситуации, заключается в том, что все ссылки на переменные-члены должны быть префиксом этого .

Я застрял в префиксе всех переменных-членов с помощью self или есть способ объявить их, что позволило бы мне избежать этого?

Даже если то, что я предлагаю, не питоническое , я все равно хотел бы знать, возможно ли это.

Я взглянул на эти связанные вопросы SO, но они не совсем отвечают на то, что мне нужно:

• Python - зачем использовать «я» в классе?
• Зачем вам явно нужен аргумент «self» в методе Python?

Python требует указания self. В результате никогда не возникает путаницы в том, что является членом, а что нет, даже без видимого полного определения класса. Это приводит к полезным свойствам, таким как: вы не можете добавлять элементы, которые случайно затеняют нечленов и тем самым нарушают код.

Один крайний пример: вы можете написать класс, не зная, какие базовые классы он может иметь, и всегда знать, обращаетесь ли вы к члену или нет:

class A(some_function()):
  def f(self):
    self.member = 42
    self.method()

Это полный код! (some_function возвращает тип, используемый в качестве основы.)

Другой, где методы класса динамически составляются:

class B(object):
  pass

print B()
# <__main__.B object at 0xb7e4082c>

def B_init(self):
  self.answer = 42
def B_str(self):
  return "<The answer is %s.>" % self.answer
# notice these functions require no knowledge of the actual class
# how hard are they to read and realize that "members" are used?

B.__init__ = B_init
B.__str__ = B_str

print B()
# <The answer is 42.>

Помните, что оба этих примера являются экстремальными, и вы не будете видеть их каждый день, и я не предлагаю вам часто писать такой код, но они ясно показывают, что аспекты себя явно требуются.

Предыдущие ответы в основном представляют собой варианты «нельзя» или «не следует». Хотя я согласен с последним мнением, технически вопрос все еще остается без ответа.

Более того, есть законные причины, по которым кто-то может захотеть сделать что-то в соответствии с тем, что задает фактический вопрос. Иногда я сталкиваюсь с длинными математическими уравнениями, в которых использование длинных имен делает уравнение неузнаваемым. Вот несколько способов сделать это в готовом примере:

import numpy as np
class MyFunkyGaussian() :
    def __init__(self, A, x0, w, s, y0) :
        self.A = float(A)
        self.x0 = x0
        self.w = w
        self.y0 = y0
        self.s = s

    # The correct way, but subjectively less readable to some (like me) 
    def calc1(self, x) :
        return (self.A/(self.w*np.sqrt(np.pi))/(1+self.s*self.w**2/2)
                * np.exp( -(x-self.x0)**2/self.w**2)
                * (1+self.s*(x-self.x0)**2) + self.y0 )

    # The correct way if you really don't want to use 'self' in the calculations
    def calc2(self, x) :
        # Explicity copy variables
        A, x0, w, y0, s = self.A, self.x0, self.w, self.y0, self.s
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

    # Probably a bad idea...
    def calc3(self, x) :
        # Automatically copy every class vairable
        for k in self.__dict__ : exec(k+'= self.'+k)
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

g = MyFunkyGaussian(2.0, 1.5, 3.0, 5.0, 0.0)
print(g.calc1(0.5))
print(g.calc2(0.5))
print(g.calc3(0.5))

Третий пример - т.е. использование for k in self.__dict__ : exec(k+'= self.'+k)- это в основном то, о чем на самом деле спрашивается вопрос, но позвольте мне прояснить, что я не думаю, что в целом это хорошая идея.

Для получения дополнительной информации и способов перебора переменных класса или даже функций см. Ответы и обсуждение этого вопроса . Для обсуждения других способов динамического именования переменных и того, почему это обычно не очень хорошая идея, см. Это сообщение в блоге .

ОБНОВЛЕНИЕ: похоже, нет способа динамически обновлять или изменять локальные переменные в функции в Python3, поэтому calc3 и подобные варианты больше невозможны. Единственное решение, совместимое с python3, которое я могу придумать, - это использовать globals:

def calc4(self, x) :
        # Automatically copy every class variable in globals
        globals().update(self.__dict__)
        sqrt, exp, pi = np.sqrt, np.exp, np.pi
        return ( A/( w*sqrt(pi) )/(1+s*w**2/2)
                * exp( -(x-x0)**2/w**2 )
                * (1+s*(x-x0)**2) + y0 )

Что, опять же, было бы ужасной практикой в ​​целом.

На самом деле selfэто не ключевое слово, это просто имя, условно присвоенное первому параметру методов экземпляра в Python. И этот первый параметр нельзя пропустить, так как это единственный механизм, который имеет метод, чтобы узнать, какой экземпляр вашего класса он вызывается.

Вы можете использовать любое имя, которое хотите, например

class test(object):
    def function(this, variable):
        this.variable = variable

или даже

class test(object):
    def function(s, variable):
        s.variable = variable

но вы застряли в использовании имени для области видимости.

Я не рекомендую вам использовать что-то отличное от себя, если у вас нет убедительной причины, поскольку это сделает это чуждым для опытных питонистов.

да, вы всегда должны указывать self, потому что явное лучше, чем неявное, согласно философии Python.

Вы также обнаружите, что способ программирования на Python очень отличается от того, как вы программируете на Java, поэтому использование self имеет тенденцию к уменьшению, поскольку вы не проецируете все внутри объекта. Скорее, вы шире используете функции уровня модуля, которые можно лучше протестировать.

Кстати. Сначала я ненавидел это, теперь ненавижу противоположное. то же самое для управления потоком с отступом.

«Я» - это обычный заполнитель текущего экземпляра объекта класса. Он используется, когда вы хотите обратиться к свойству объекта, полю или методу внутри класса, как если бы вы ссылались на «себя». Но чтобы сделать его короче, кто-то из области программирования Python начал использовать «self», в других областях используется «this», но они делают его как ключевое слово, которое нельзя заменить. Я скорее использовал «его» для повышения читабельности кода. Это одна из хороших вещей в Python - у вас есть свобода выбора собственного заполнителя для экземпляра объекта, кроме «self». Пример для себя:

class UserAccount():    
    def __init__(self, user_type, username, password):
        self.user_type = user_type
        self.username = username            
        self.password = encrypt(password)        

    def get_password(self):
        return decrypt(self.password)

    def set_password(self, password):
        self.password = encrypt(password)

Теперь заменим self на its:

class UserAccount():    
    def __init__(its, user_type, username, password):
        its.user_type = user_type
        its.username = username            
        its.password = encrypt(password)        

    def get_password(its):
        return decrypt(its.password)

    def set_password(its, password):
        its.password = encrypt(password)

что теперь более читабельно?

self является частью синтаксиса python для доступа к членам объектов, поэтому я боюсь, что вы застряли на нем

На самом деле вы можете воспользоваться рецептом «Неявное Я» из презентации Армина Ронахера «5 лет плохих идей» (погуглите).

Это очень умный рецепт, как и почти все от Армина Ронахера, но я не думаю, что эта идея очень привлекательна. Я думаю, что предпочел бы это явно в C # / Java.

Обновить. Ссылка на «рецепт плохой идеи»: https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58

Да, это утомительно. Но так ли лучше?

class Test:

    def __init__(_):
        _.test = 'test'

    def run(_):
        print _.test

От: Self Hell - Больше функций с отслеживанием состояния.

... гибридный подход работает лучше всего. Все методы вашего класса, которые фактически выполняют вычисления, должны быть перемещены в замыкания, а расширения для очистки синтаксиса должны храниться в классах. Поместите замыкания в классы, обращаясь с классом как с пространством имен. Замыкания по сути являются статическими функциями и поэтому не требуют selfs * даже в классе ...

Я думаю, что было бы проще и читабельнее, если бы был оператор «член» так же, как и «глобальный», чтобы вы могли сообщить интерпретатору, какие объекты являются членами класса.