Як уникнути явного «я» в Python?

Я вивчав Python, дотримуючись деяких навчальних посібників із пігмаму .

У цьому я знайшов широке використання ключового слова self , і виходячи з передусім фону Java, я вважаю, що я все ще забуваю вводити self . Наприклад, замість того , щоб self.rect.centerxя надрукував би rect.centerx, тому що, мені, Прямокутник вже змінна член класу.

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

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

Навіть якщо те, що я пропоную, не є пітонічним , я все одно хотів би знати, чи це можливо.

Я переглянув ці пов'язані питання ЗО, але вони не дуже відповідають на те, що я хочу:

• Python - навіщо використовувати “self” у класі?
• Навіщо вам явно потрібно аргумент "само" в метод Python?

Python вимагає уточнення себе. Результат - ніколи не виникає плутанини щодо того, що є членом, а що ні, навіть не видно повного визначення класу. Це призводить до корисних властивостей, таких як: ви не можете додавати членів, які випадково затінюють не членів і тим самим порушують код.

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

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

Ось повний код! (деяка_функція повертає тип, який використовується в якості основи.)

Інший, де методи класу динамічно складаються:

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 сильно відрізняється від способу програмування у java, отже, використання selfмає тенденцію до зменшення, оскільки ви не проектуєте все всередині об’єкта. Скоріше, ви більше використовуєте функцію рівня модуля, яку можна краще перевірити.

до речі. Я спочатку ненавидів це, зараз ненавиджу навпаки. те ж саме для управління потоком з відступом.

"Я" - це звичайний заповнювач місця в поточному екземплярі об'єкта класу. Його використовують, коли ви хочете посилатися на властивість об'єкта або поле чи метод всередині класу так, ніби ви маєте на увазі "себе". Але щоб скоротити, хтось у царині програмування Python почав використовувати "self", інші сфери використовують "this", але вони роблять це як ключове слово, яке не можна замінити. Я скоріше використовував "його" для збільшення читабельності коду. Це одне з хороших речей у Python - у вас є свобода вибору власного заповнювача для екземпляра об'єкта, окрім як «я». Приклад для себе:

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)

Тепер ми замінюємо "Я" на "його":

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)

що зараз читабельніше?

Я є частиною синтаксису python для доступу до членів об’єктів, тому я боюся, що ви з цим застрягли

Насправді ви можете скористатися рецептом "Неявна себе" з презентації Арміна Ронахера "5 років поганих ідей" (google it)

Це дуже розумний рецепт, як майже все від Armin Ronacher, але я не думаю, що ця ідея дуже приваблива. Я думаю, що я вважаю за краще явне це в 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 - Більш видатні функції.

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

Я думаю, що було б легше і легше читати, якби було висловлювання «член» так само, як є «глобальне», щоб ви могли сказати перекладачеві, які є об’єкти, що належать до класу.