Bagaimana cara menghindari 'diri' secara eksplisit dengan Python?

Saya telah belajar Python dengan mengikuti beberapa tutorial pygame .

Di sana saya menemukan banyak penggunaan kata kunci diri , dan terutama berasal dari latar belakang Jawa, saya menemukan bahwa saya terus lupa mengetik sendiri . Sebagai contoh, bukannya self.rect.centerxsaya akan mengetik rect.centerx, karena, bagi saya, rect sudah menjadi variabel anggota kelas.

Paralel Java yang dapat saya pikirkan untuk situasi ini adalah harus mengawali semua referensi ke variabel anggota dengan ini .

Apakah saya terjebak dengan awalan semua variabel anggota dengan diri saya sendiri , atau adakah cara untuk mendeklarasikannya agar saya dapat menghindari keharusan melakukannya?

Bahkan jika apa yang saya sarankan bukanlah pythonic , saya masih ingin tahu apakah itu mungkin.

Saya telah melihat pada pertanyaan-pertanyaan SO terkait ini, tetapi mereka tidak cukup menjawab apa yang saya cari:

• Python - mengapa menggunakan "diri" di kelas?
• Mengapa Anda perlu secara eksplisit memiliki argumen "diri" ke dalam metode Python?

Python membutuhkan menentukan sendiri. Hasilnya adalah tidak pernah ada kebingungan tentang apa yang anggota dan apa yang tidak, bahkan tanpa definisi kelas penuh yang terlihat. Ini mengarah ke properti yang berguna, seperti: Anda tidak dapat menambahkan anggota yang secara tidak sengaja membayangi bukan anggota dan karenanya memecahkan kode.

Salah satu contoh ekstrem: Anda dapat menulis kelas tanpa pengetahuan tentang kelas dasar apa yang mungkin dimilikinya, dan selalu tahu apakah Anda mengakses anggota atau tidak:

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

Itu kode lengkap ! (some_function mengembalikan tipe yang digunakan sebagai basis.)

Lain, di mana metode kelas secara dinamis disusun:

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

Ingat, kedua contoh ini ekstrem dan Anda tidak akan melihatnya setiap hari, saya juga tidak menyarankan Anda harus sering menulis kode seperti ini, tetapi mereka jelas menunjukkan aspek diri yang secara eksplisit diperlukan.

Jawaban sebelumnya pada dasarnya adalah varian "Anda tidak bisa" atau "Anda tidak boleh". Sementara saya setuju dengan sentimen terakhir, pertanyaannya secara teknis masih belum terjawab.

Selain itu, ada alasan sah mengapa seseorang mungkin ingin melakukan sesuatu sesuai dengan pertanyaan yang diajukan. Satu hal yang sering saya temui adalah persamaan matematika yang panjang di mana menggunakan nama panjang membuat persamaan tidak dapat dikenali. Berikut adalah beberapa cara bagaimana Anda bisa melakukan ini dalam contoh kalengan:

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

Contoh ketiga - yaitu menggunakan for k in self.__dict__ : exec(k+'= self.'+k) pada dasarnya adalah pertanyaan yang sebenarnya ditanyakan, tetapi izinkan saya menjadi jelas bahwa menurut saya umumnya itu bukan ide yang baik.

Untuk info lebih lanjut, dan cara untuk mengulangi melalui variabel kelas, atau bahkan fungsi, lihat jawaban dan diskusi untuk pertanyaan ini . Untuk diskusi tentang cara lain untuk memberi nama variabel secara dinamis, dan mengapa ini biasanya bukan ide yang baik, lihat posting blog ini .

UPDATE: Tampaknya tidak ada cara untuk secara dinamis memperbarui atau mengubah lokal dalam suatu fungsi di Python3, sehingga calc3 dan varian serupa tidak lagi mungkin. Satu-satunya solusi yang kompatibel dengan python3 yang dapat saya pikirkan sekarang adalah menggunakan 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 )

Yang, sekali lagi, akan menjadi praktik yang mengerikan pada umumnya.

Sebenarnya selfbukan kata kunci, itu hanya nama yang secara konvensional diberikan kepada parameter pertama metode contoh dengan Python. Dan parameter pertama itu tidak bisa dilewati, karena itu satu-satunya mekanisme yang dimiliki metode untuk mengetahui instance kelas Anda yang dipanggil.

Anda dapat menggunakan nama apa pun yang Anda inginkan, misalnya

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

atau bahkan

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

tetapi Anda tidak dapat menggunakan nama untuk ruang lingkup.

Saya tidak menyarankan Anda menggunakan sesuatu yang berbeda untuk diri sendiri kecuali Anda memiliki alasan yang meyakinkan, karena itu akan membuatnya asing untuk pythonista yang berpengalaman.

ya, Anda harus selalu menentukan self , karena eksplisit lebih baik daripada implisit, menurut filosofi python.

Anda juga akan menemukan bahwa cara Anda memprogram dalam python sangat berbeda dari cara Anda memprogram di java, maka penggunaan selfcenderung menurun karena Anda tidak memproyeksikan segala sesuatu di dalam objek. Sebaliknya, Anda menggunakan fungsi tingkat modul yang lebih besar, yang dapat diuji lebih baik.

ngomong-ngomong. Awalnya aku benci, sekarang aku benci yang sebaliknya. sama untuk kontrol aliran indent-driven.

"Diri" adalah placeholder konvensional dari instance objek saat ini dari kelas. Ini digunakan ketika Anda ingin merujuk ke properti objek atau bidang atau metode di dalam kelas seolah-olah Anda merujuk ke "sendiri". Tetapi untuk membuatnya lebih pendek seseorang di ranah pemrograman Python mulai menggunakan "diri", ranah lain menggunakan "ini" tetapi mereka menjadikannya sebagai kata kunci yang tidak dapat diganti. Saya lebih suka menggunakan "nya" untuk meningkatkan keterbacaan kode. Ini salah satu hal baik dalam Python - Anda memiliki kebebasan untuk memilih placeholder Anda sendiri untuk contoh objek selain "diri". Contoh untuk diri sendiri:

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)

Sekarang kita ganti 'diri' dengan 'nya':

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)

mana yang lebih mudah dibaca sekarang?

diri adalah bagian dari sintaks python untuk mengakses anggota objek, jadi saya khawatir Anda terjebak dengannya

Sebenarnya Anda bisa menggunakan resep "Implisit diri" dari presentasi Armin Ronacher "5 tahun ide buruk" (google it).

Ini resep yang sangat pintar, karena hampir semuanya dari Armin Ronacher, tetapi saya tidak berpikir ide ini sangat menarik. Saya pikir saya lebih suka eksplisit ini di C # / Java.

Memperbarui. Tautan ke "resep ide buruk": https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58

Ya, diri itu membosankan. Tapi, apakah ini lebih baik?

class Test:

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

    def run(_):
        print _.test

From: Self Hell - Lebih banyak fungsi stateful.

... pendekatan hibrida paling berhasil. Semua metode kelas Anda yang benar-benar melakukan komputasi harus dipindahkan ke penutupan, dan ekstensi untuk membersihkan sintaksis harus disimpan di kelas. Masukkan penutup ke dalam kelas, perlakukan kelas seperti namespace. Penutupan pada dasarnya adalah fungsi statis, dan karenanya tidak memerlukan selfs *, bahkan di dalam kelas ...

Saya pikir akan lebih mudah dan lebih mudah dibaca jika ada pernyataan "anggota" sama seperti ada "global" sehingga Anda dapat memberi tahu penerjemah yang merupakan objek anggota kelas.