Jak uniknąć jawnego „ja” w Pythonie?

Uczyłem się Pythona, postępując zgodnie z kilkoma samouczkami dotyczącymi pygame .

Tam znalazłem szerokie zastosowanie słowa kluczowego self , a ponieważ wywodzę się głównie z języka Java, stwierdzam, że ciągle zapominam o wpisaniu self . Na przykład zamiast self.rect.centerxwpisywać rect.centerx, ponieważ dla mnie rect jest już zmienną składową klasy.

Równoległość Java, o której mogę pomyśleć w tej sytuacji, polega na poprzedzeniu wszystkich odwołań do zmiennych składowych tym .

Czy utknąłem z przedrostkiem wszystkich zmiennych składowych self , czy jest sposób ich zadeklarowania, który pozwoliłby mi uniknąć konieczności robienia tego?

Nawet jeśli to, co sugeruję, nie jest pythonowe , nadal chciałbym wiedzieć, czy jest to możliwe.

Rzuciłem okiem na te powiązane pytania SO, ale nie do końca odpowiadają one, o co mi chodzi:

• Python - po co używać „self” w klasie?
• Dlaczego potrzebujesz jawnie wstawić argument „self” do metody Pythona?

Python wymaga określenia self. W rezultacie nigdy nie ma nieporozumień co do tego, co jest składnikiem, a co nie, nawet bez widocznej pełnej definicji klasy. Prowadzi to do przydatnych właściwości, takich jak: nie można dodawać elementów członkowskich, które przypadkowo przesłaniają elementy niebędące członkami i tym samym łamią kod.

Jeden skrajny przykład: możesz napisać klasę bez wiedzy o tym, jakie klasy bazowe może mieć, i zawsze wiedzieć, czy uzyskujesz dostęp do członka, czy nie:

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

To cały kod! (some_function zwraca typ używany jako podstawa).

Inny, w którym metody klasy są tworzone dynamicznie:

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

Pamiętaj, że oba te przykłady są ekstremalne i nie będziesz ich widzieć codziennie, ani nie sugeruję, abyś często pisał taki kod, ale jasno pokazują aspekty tego, jak ja sam jesteś wyraźnie wymagany.

Wszystkie poprzednie odpowiedzi są w zasadzie wariantami „nie możesz” lub „nie powinieneś”. Chociaż zgadzam się z tym drugim zdaniem, to pytanie technicznie nadal pozostaje bez odpowiedzi.

Ponadto istnieją uzasadnione powody, dla których ktoś mógłby chcieć zrobić coś podobnego do tego, o co chodzi w tym pytaniu. Czasami napotykam na długie równania matematyczne, w których używanie długich nazw sprawia, że ​​równanie jest nierozpoznawalne. Oto kilka sposobów, jak możesz to zrobić na przykładzie puszki:

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

Trzeci przykład - tj. Używanie for k in self.__dict__ : exec(k+'= self.'+k)jest w zasadzie tym, o co właściwie chodzi w pytaniu, ale pozwól mi wyjaśnić, że nie uważam, że jest to ogólnie dobry pomysł.

Aby uzyskać więcej informacji i sposobów iteracji po zmiennych klasowych, a nawet funkcjach, zobacz odpowiedzi i dyskusję na to pytanie . Omówienie innych sposobów dynamicznego nazywania zmiennych oraz powodów, dla których zwykle nie jest to dobry pomysł, można znaleźć w tym poście na blogu .

AKTUALIZACJA: Wydaje się, że nie ma możliwości dynamicznej aktualizacji lub zmiany ustawień lokalnych w funkcji w Pythonie3, więc calc3 i podobne warianty nie są już możliwe. Jedynym rozwiązaniem kompatybilnym z Python3, o którym mogę teraz pomyśleć, jest użycie 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 )

Co znowu byłoby straszną praktyką w ogóle.

Właściwie selfnie jest słowem kluczowym, to tylko nazwa tradycyjnie nadana pierwszemu parametrowi metod instancji w Pythonie. I tego pierwszego parametru nie można pominąć, ponieważ jest to jedyny mechanizm, jaki posiada metoda, aby wiedzieć, która instancja Twojej klasy jest wywoływana.

Możesz na przykład użyć dowolnej nazwy

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

lub nawet

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

ale utkniesz z użyciem nazwy zakresu.

Nie polecam używania czegoś innego dla siebie, chyba że masz przekonujący powód, ponieważ byłoby to obce dla doświadczonych pytonistów.

tak, musisz zawsze określać self, ponieważ wyraźne jest lepsze niż niejawne, zgodnie z filozofią Pythona.

Dowiesz się również, że sposób, w jaki programujesz w Pythonie, bardzo różni się od sposobu, w jaki programujesz w Javie, stąd użycie selfma tendencję do zmniejszania się, ponieważ nie wyświetlasz wszystkiego wewnątrz obiektu. Zamiast tego w większym stopniu wykorzystujesz funkcję na poziomie modułu, którą można lepiej przetestować.

tak poza tym. Na początku tego nienawidziłem, teraz nienawidzę czegoś odwrotnego. to samo dla sterowania przepływem sterowanym wcięciem.

„Self” to konwencjonalny symbol zastępczy dla bieżącej instancji obiektu klasy. Jest używany, gdy chcesz odwołać się do właściwości, pola lub metody obiektu wewnątrz klasy, tak jakbyś odnosił się do „samego siebie”. Ale żeby to skrócić, ktoś w dziedzinie programowania w Pythonie zaczął używać "self", inne dziedziny używają "this", ale robią to jako słowo kluczowe, którego nie można zastąpić. Raczej użyłem „jego”, aby zwiększyć czytelność kodu. To jedna z dobrych rzeczy w Pythonie - masz swobodę wyboru własnego symbolu zastępczego dla instancji obiektu innego niż „self”. Przykład dla siebie:

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)

Teraz zamieniamy „siebie” na „jego”:

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)

który jest teraz bardziej czytelny?

self jest częścią składni Pythona, która umożliwia dostęp do elementów obiektów, więc obawiam się, że utknąłeś z tym

Właściwie możesz skorzystać z przepisu „Ukryte ja” z prezentacji Armina Ronachera „5 lat złych pomysłów” (wygoogluj to).

To bardzo sprytny przepis, jak prawie wszystko od Armina Ronachera, ale nie sądzę, żeby ten pomysł był zbyt atrakcyjny. Myślę, że wolałbym jawne to w C # / Java.

Aktualizacja. Link do „przepisu na zły pomysł”: https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58

Tak, jaźń jest nudna. Ale czy jest lepiej?

class Test:

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

    def run(_):
        print _.test

Od: Self Hell - Więcej funkcji stanowych.

... podejście hybrydowe działa najlepiej. Wszystkie metody klas, które faktycznie wykonują obliczenia, powinny zostać przeniesione do domknięć, a rozszerzenia czyszczące składnię powinny zostać zachowane w klasach. Upychaj zamknięcia na klasy, traktując klasę podobnie jak przestrzeń nazw. Zamknięcia są zasadniczo funkcjami statycznymi, a więc nie wymagają self *, nawet w klasie ...

Myślę, że byłoby łatwiej i bardziej czytelnie, gdyby istniało stwierdzenie „member”, tak jak jest „global”, dzięki czemu można powiedzieć tłumaczowi, które obiekty należą do klasy.