จะหลีกเลี่ยง 'ตัวเอง' อย่างชัดเจนใน Python ได้อย่างไร?

ฉันได้รับการเรียนรู้หลามโดยทำตามบางบทเรียน pygame

ในนั้นผมพบว่าการใช้งานที่กว้างขวางของคำหลักที่ตัวเองและมาจากพื้นหลัง Java ส่วนใหญ่ฉันพบว่าฉันให้ลืมที่จะพิมพ์ด้วยตนเอง ตัวอย่างเช่นแทนที่self.rect.centerxฉันจะพิมพ์rect.centerxเพราะสำหรับฉันแล้วrectเป็นตัวแปรสมาชิกของคลาสอยู่แล้ว

ขนาน Java ฉันจะคิดว่าสำหรับสถานการณ์นี้จะมีคำนำหน้าการอ้างอิงถึงตัวแปรสมาชิกด้วยนี้

ฉันติดคำนำหน้าตัวแปรสมาชิกทั้งหมดด้วยตนเองหรือมีวิธีการประกาศตัวแปรที่ทำให้ฉันหลีกเลี่ยงไม่ได้หรือไม่

แม้ว่าสิ่งที่ฉันแนะนำจะไม่ใช่pythonicแต่ฉันก็ยังอยากรู้ว่าเป็นไปได้ไหม

ฉันได้ดูคำถาม SO ที่เกี่ยวข้องเหล่านี้แล้ว แต่พวกเขาไม่ค่อยตอบในสิ่งที่ฉันต้องการ:

• Python - ทำไมถึงใช้ "self" ในชั้นเรียน
• ทำไมคุณต้องมีอาร์กิวเมนต์ "self" อย่างชัดเจนในเมธอด Python

Python ต้องการการระบุตนเอง ผลลัพธ์ที่ได้คือไม่มีความสับสนว่าสมาชิกคืออะไรและอะไรไม่ได้แม้ว่าจะไม่มีคำจำกัดความของคลาสแบบเต็มก็ตาม สิ่งนี้นำไปสู่คุณสมบัติที่เป็นประโยชน์เช่นคุณไม่สามารถเพิ่มสมาชิกที่ไม่ได้เป็นสมาชิกโดยบังเอิญและทำให้โค้ดแตก

ตัวอย่างที่ชัดเจนอย่างหนึ่ง: คุณสามารถเขียนคลาสโดยไม่ต้องมีความรู้เกี่ยวกับคลาสพื้นฐานและรู้อยู่เสมอว่าคุณกำลังเข้าถึงสมาชิกหรือไม่:

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

แต่คุณติดอยู่กับการใช้ชื่อสำหรับขอบเขต

ฉันไม่แนะนำให้คุณใช้สิ่งที่แตกต่างกับตัวเองเว้นแต่คุณจะมีเหตุผลที่น่าเชื่อถือเพราะมันจะทำให้มันเป็นมนุษย์ต่างดาวสำหรับ pythonistas ที่มีประสบการณ์

ใช่คุณต้องระบุเสมอselfเพราะ Explicit ดีกว่าโดยนัยตามปรัชญาของ python

นอกจากนี้คุณจะพบว่าวิธีที่คุณเขียนโปรแกรมใน 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)

ตอนนี้เราแทนที่ '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 เพื่อเข้าถึงสมาชิกของวัตถุดังนั้นฉันกลัวว่าคุณจะติดอยู่กับมัน

จริงๆแล้วคุณสามารถใช้สูตร "ตัวเองโดยนัย" จากการนำเสนอของ Armin Ronacher "5 years of bad ideas" (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 - ฟังก์ชั่นสถานะเพิ่มเติม

... แนวทางแบบผสมผสานทำงานได้ดีที่สุด เมธอดคลาสทั้งหมดของคุณที่ใช้คำนวณจริงควรถูกย้ายไปไว้ในการปิดและควรเก็บส่วนขยายเพื่อล้างไวยากรณ์ไว้ในคลาส รวบรวมการปิดลงในชั้นเรียนโดยปฏิบัติต่อชั้นเรียนเหมือนเนมสเปซ การปิดเป็นฟังก์ชั่นคงที่เป็นหลักดังนั้นจึงไม่ต้องใช้ selfs * แม้แต่ในคลาส ...

ฉันคิดว่ามันจะง่ายกว่าและอ่านได้ง่ายขึ้นถ้ามีคำว่า "member" เหมือนกับที่มีคำว่า "global" เพื่อที่คุณจะได้บอกล่ามซึ่งเป็นอ็อบเจกต์ที่เป็นสมาชิกของคลาส