Python'da açıkça 'kendiliğinden' nasıl kaçınılır?

Bazılarını takip ederek Python öğreniyorum pygame eğitimlerini ederek .

Orada Anahtar kelime geniş kullanım alanı bulmuş kendini ve öncelikle Java arka plandan gelen, ben yazmaya unutuyorum bulmak kendini . Örneğin, yerine self.rect.centerxben yazarsınız rect.centerx, bana göre, çünkü rect zaten sınıfın üyesi değişkendir.

Java paralel bu durum ile üye değişkenleri ile ilgili tüm içeriği önek yaşıyor için aklınıza gelebilecek bu .

Tüm üye değişkenlerin önüne self koyuyor muyum, yoksa bunu yapmak zorunda kalmamamı sağlayacak onları bildirmenin bir yolu var mı?

Önerdiğim şey olmasa bile Önerdiğim pitonik olmasa bile, yine de mümkün olup olmadığını bilmek isterim.

Bu ilgili SO sorularına bir göz attım, ancak peşinde olduğum şeyi tam olarak yanıtlamıyorlar:

• Python - neden bir sınıfta "self" kullanılsın?
• Neden bir Python yönteminde açıkça "öz" argümanına ihtiyacınız var?

Python, kendini belirtmeyi gerektirir. Sonuç, sınıf tanımının tamamı görünmese bile, neyin üye olup neyin olmadığı konusunda hiçbir zaman kafa karışıklığı olmamasıdır. Bu, aşağıdaki gibi yararlı özelliklere yol açar: üye olmayanları yanlışlıkla gölgeleyen ve dolayısıyla kodu bozan üyeler ekleyemezsiniz.

Uç bir örnek: Bir sınıfı hangi temel sınıflara sahip olabileceğine dair hiçbir bilgi olmadan yazabilir ve bir üyeye erişip erişmediğinizi her zaman bilirsiniz:

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

Budur komple kod! (bazı_işlev, temel olarak kullanılan türü döndürür.)

Bir sınıfın yöntemlerinin dinamik olarak oluşturulduğu bir diğeri:

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

Unutmayın, bu örneklerin her ikisi de aşırıdır ve onları her gün görmezsiniz, ne de sık sık böyle kod yazmanızı önermiyorum, ancak açıkça kendiliğin açıkça gerekli olan yönlerini gösterirler.

Önceki yanıtların tümü temelde "yapamazsın" veya "yapmamalısın" ifadelerinin varyantlarıdır. İkinci düşünceye katılıyorum, ancak soru teknik olarak hala cevaplanmamış.

Dahası, birisinin asıl sorunun sorduğu çizgide bir şeyler yapmak istemesinin meşru nedenleri vardır. Bazen karşılaştığım bir şey, uzun isimler kullanmanın denklemi tanınmaz hale getirdiği uzun matematik denklemleridir. Hazır bir örnekte bunu nasıl yapabileceğinizin birkaç yolu:

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

Üçüncü örnek - yani kullanmak for k in self.__dict__ : exec(k+'= self.'+k), temelde sorunun aslında istediği şeydir, ancak bunun genel olarak iyi bir fikir olduğunu düşünmediğimi açıklığa kavuşturayım.

Daha fazla bilgi ve sınıf değişkenleri ve hatta işlevler arasında yineleme yapmanın yolları için, bu sorunun yanıtlarına ve tartışmaya bakın . Değişkenleri dinamik olarak adlandırmanın diğer yolları ve bunun neden genellikle iyi bir fikir olmadığı hakkında bir tartışma için bu blog gönderisine bakın .

GÜNCELLEME: olduğu görülmektedir hiçbir şekilde calc3 ve benzeri varyantlar artık mümkün böylece, dinamik güncelleştirme veya Python3 bir işlev değişikliği halk için. Şu an düşünebildiğim python3 uyumlu tek çözüm şudur 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 )

Bu da yine genel olarak korkunç bir uygulama olurdu.

Aslında selfbir anahtar kelime değildir, sadece Python'daki örnek yöntemlerinin ilk parametresine geleneksel olarak verilen addır. Ve bu ilk parametre, bir yöntemin sınıfınızın hangi örneğinin çağrıldığını bilmek için sahip olduğu tek mekanizma olduğu için atlanamaz.

Örneğin, istediğiniz adı kullanabilirsiniz.

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

ya da

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

ancak kapsam için bir ad kullanmak zorunda kalıyorsunuz.

Deneyimli pythonistalar için onu yabancı yapacağından, ikna edici bir nedeniniz olmadıkça kendinizden farklı bir şey kullanmanızı önermiyorum.

evet, her zaman belirtmelisiniz self, çünkü python felsefesine göre açık, örtükten daha iyidir.

Ayrıca, python'da programlama şeklinizin java'daki programlamadan çok farklı olduğunu da öğreneceksiniz, bu nedenle selfnesnenin içindeki her şeyi yansıtmadığınız için kullanımı azalmaya meyillidir. Bunun yerine, daha iyi test edilebilecek modül düzeyinde işlevi daha geniş bir şekilde kullanırsınız.

bu arada. İlk başta nefret ettim, şimdi tam tersinden nefret ediyorum. girintili tahrikli akış kontrolü için aynı.

"Öz", bir sınıfın mevcut nesne örneğinin geleneksel yer tutucusudur. Bir sınıf içindeki nesnenin özelliğine veya alanına veya yöntemine "kendisine" atıfta bulunuyormuşsunuz gibi başvurmak istediğinizde kullanılır. Fakat onu kısaltmak için Python programlama dünyasında biri "self" i kullanmaya başladı, diğer alemler "this" i kullanır ama onu değiştirilemeyen bir anahtar kelime olarak yaparlar. Kod okunabilirliğini artırmak için "its" i kullandım. Python'daki en iyi şeylerden biri - nesnenin örneği için "self" dışında kendi yer tutucunuzu seçme özgürlüğüne sahipsiniz. Kendine örnek:

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)

Şimdi 'ben'i' onun 'ile değiştiriyoruz:

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)

hangisi şimdi daha okunabilir?

self, nesnelerin üyelerine erişmek için kullanılan python sözdiziminin bir parçasıdır, bu yüzden korkarım ona takılıp kaldınız

Aslında Armin Ronacher "5 yıllık kötü fikirler" (google it) sunumundaki "Örtük benlik" tarifini kullanabilirsiniz.

Neredeyse Armin Ronacher'deki her şey gibi çok akıllıca bir tarif, ama bu fikrin çok çekici olduğunu düşünmüyorum. Ben açık tercih ediyorum düşünüyorum bu C # / Java.

Güncelleme. "Kötü fikir tarifi" bağlantısı: https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58

Evet, benlik sıkıcıdır. Ama daha mı iyi?

class Test:

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

    def run(_):
        print _.test

From: Self Hell - Daha durum bilgisi olan işlevler.

... melez bir yaklaşım en iyi sonucu verir. Gerçekte hesaplama yapan tüm sınıf yöntemleriniz kapanışlara taşınmalı ve sözdizimini temizlemek için uzantılar sınıflarda tutulmalıdır. Kapakları sınıflara doldurun, sınıfa daha çok bir ad alanı gibi davranın. Kapanışlar aslında statik fonksiyonlardır ve bu yüzden sınıfta bile selfs * gerektirmezler ...

Bence "üye" ifadesi de olsaydı, tıpkı "global" olduğu gibi, yorumlayıcıya hangi nesnelerin sınıfın üyeleri olduğunu söyleyebilirsiniz.