Làm cách nào để tránh 'tự' rõ ràng trong Python?

Tôi đã học Python bằng cách làm theo một số hướng dẫn về pygame .

Trong đó tôi thấy sử dụng rộng rãi trong những từ khóa tự , và đến từ một nền chủ yếu Java, tôi thấy rằng tôi giữ quên gõ tự . Ví dụ, thay vì self.rect.centerxtôi sẽ gõ rect.centerx, bởi vì, với tôi, orth đã là một biến thành viên của lớp.

Song song Java tôi có thể nghĩ cho tình huống này là phải thêm tiền tố vào tất cả các tham chiếu đến các biến thành viên với điều này .

Tôi có bị mắc kẹt tiền tố với tất cả các biến thành viên với chính mình không , hay có cách nào để khai báo chúng cho phép tôi tránh phải làm như vậy không?

Ngay cả khi những gì tôi đề nghị không phải là pythonic , tôi vẫn muốn biết liệu điều đó có khả thi hay không.

Tôi đã xem xét những câu hỏi SO liên quan này, nhưng họ không trả lời tôi là gì sau:

• Python - tại sao lại sử dụng bản thân tự động trong một lớp?
• Tại sao bạn cần rõ ràng có đối số Tự khắc thành một phương thức Python?

Python yêu cầu tự xác định. Kết quả là không bao giờ có bất kỳ sự nhầm lẫn nào về những gì thành viên và những gì không, ngay cả khi không có định nghĩa đầy đủ về lớp. Điều này dẫn đến các thuộc tính hữu ích, chẳng hạn như: bạn không thể thêm các thành viên vô tình che giấu những người không phải thành viên và do đó phá vỡ mã.

Một ví dụ cực đoan: bạn có thể viết một lớp mà không có bất kỳ kiến ​​thức nào về các lớp cơ sở mà nó có thể có và luôn biết liệu bạn có truy cập thành viên hay không:

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

Đó là mã hoàn chỉnh ! (some_function trả về loại được sử dụng làm cơ sở.)

Khác, trong đó các phương thức của một lớp được cấu tạo động:

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

Hãy nhớ rằng, cả hai ví dụ này đều cực đoan và bạn sẽ không nhìn thấy chúng mỗi ngày, tôi cũng không khuyên bạn nên thường xuyên viết mã như thế này, nhưng chúng cho thấy rõ các khía cạnh của bản thân được yêu cầu rõ ràng.

Các câu trả lời trước đây là tất cả các biến thể của "bạn không thể" hoặc "bạn không nên". Trong khi tôi đồng ý với tình cảm sau, câu hỏi về mặt kỹ thuật vẫn chưa được trả lời.

Hơn nữa, có những lý do chính đáng tại sao một người nào đó có thể muốn làm điều gì đó dọc theo những gì câu hỏi thực sự đang hỏi. Một điều tôi đôi khi gặp phải là các phương trình toán học dài, trong đó việc sử dụng tên dài làm cho phương trình không thể nhận ra. Dưới đây là một số cách bạn có thể làm điều này trong một ví dụ đóng hộp:

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

Ví dụ thứ ba - tức là sử dụng for k in self.__dict__ : exec(k+'= self.'+k)về cơ bản là những gì câu hỏi thực sự yêu cầu, nhưng hãy để tôi nói rõ rằng tôi không nghĩ rằng đó thường là một ý tưởng tốt.

Để biết thêm thông tin và các cách để lặp qua các biến lớp hoặc thậm chí các hàm, hãy xem câu trả lời và thảo luận cho câu hỏi này . Để thảo luận về các cách khác để tự động đặt tên biến và tại sao điều này thường không phải là một ý tưởng tốt, hãy xem bài đăng trên blog này .

CẬP NHẬT: Dường như không có cách nào để tự động cập nhật hoặc thay đổi cục bộ trong một hàm trong Python3, vì vậy calc3 và các biến thể tương tự không còn có thể. Giải pháp tương thích python3 duy nhất tôi có thể nghĩ đến bây giờ là sử dụng 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 )

Mà, một lần nữa, sẽ là một thực tế khủng khiếp nói chung.

Trên thực tế selfkhông phải là một từ khóa, nó chỉ là tên được quy ước cho tham số đầu tiên của các phương thức cá thể trong Python. Và tham số đầu tiên đó không thể bị bỏ qua, vì đó là cơ chế duy nhất mà một phương thức có thể biết về trường hợp nào của lớp bạn được gọi.

Bạn có thể sử dụng bất cứ tên nào bạn muốn, ví dụ

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

hoặc thậm chí

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

nhưng bạn bị mắc kẹt với việc sử dụng tên cho phạm vi.

Tôi không khuyên bạn nên sử dụng một cái gì đó khác biệt cho bản thân trừ khi bạn có một lý do thuyết phục, vì nó sẽ khiến nó trở nên xa lạ đối với những con trăn có kinh nghiệm.

vâng, bạn phải luôn luôn chỉ định self, bởi vì rõ ràng là tốt hơn ngầm định, theo triết lý python.

Bạn cũng sẽ thấy rằng cách bạn lập trình trong python rất khác so với cách bạn lập trình trong java, do đó việc sử dụng selfcó xu hướng giảm vì bạn không chiếu mọi thứ vào bên trong đối tượng. Thay vào đó, bạn sử dụng chức năng cấp mô-đun lớn hơn, có thể được kiểm tra tốt hơn.

nhân tiện. Tôi ghét nó lúc đầu, bây giờ tôi ghét điều ngược lại. tương tự cho điều khiển dòng chảy thụt lề.

"Bản thân" là trình giữ chỗ thông thường của thể hiện đối tượng hiện tại của một lớp. Nó được sử dụng khi bạn muốn tham chiếu đến thuộc tính hoặc trường hoặc phương thức của đối tượng trong một lớp như thể bạn đang đề cập đến "chính nó". Nhưng để làm cho nó ngắn hơn một người nào đó trong vương quốc lập trình Python bắt đầu sử dụng "tự", các vương quốc khác sử dụng "này" nhưng họ làm cho nó như một từ khóa không thể thay thế. Tôi thay vì sử dụng "của nó" để tăng khả năng đọc mã. Đó là một trong những điều tốt trong Python - bạn có quyền tự do chọn trình giữ chỗ của riêng bạn cho ví dụ của đối tượng chứ không phải là "bản thân". Ví dụ cho bản thân:

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)

Bây giờ chúng tôi thay thế 'tự' bằng 'của nó':

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)

cái nào dễ đọc hơn bây giờ?

self là một phần của cú pháp python để truy cập các thành viên của các đối tượng, vì vậy tôi sợ bạn bị mắc kẹt với nó

Trên thực tế, bạn có thể sử dụng công thức "Tự ẩn" từ bài thuyết trình của Armin Ronacher "5 năm ý tưởng tồi" (google nó).

Đó là một công thức rất thông minh, vì hầu hết mọi thứ từ Armin Ronacher, nhưng tôi không nghĩ ý tưởng này rất hấp dẫn. Tôi nghĩ rằng tôi thích rõ ràng điều này trong C # / Java.

Cập nhật. Liên kết đến "công thức ý tưởng tồi": https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58

Vâng, bản thân là tẻ nhạt. Nhưng, nó có tốt hơn không?

class Test:

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

    def run(_):
        print _.test

Từ: Tự địa ngục - Chức năng nhà nước hơn.

... một phương pháp lai hoạt động tốt nhất. Tất cả các phương thức lớp của bạn thực sự tính toán nên được chuyển thành các bao đóng và các phần mở rộng để dọn sạch cú pháp nên được giữ trong các lớp. Nhét các bao đóng vào các lớp, coi lớp giống như một không gian tên. Các bao đóng về cơ bản là các hàm tĩnh và do đó không yêu cầu tự *, ngay cả trong lớp ...

Tôi nghĩ rằng nó sẽ dễ dàng và dễ đọc hơn nếu có một câu lệnh thành viên của Cameron, giống như có toàn cầu, vì vậy bạn có thể nói với người phiên dịch là thành viên của đối tượng của lớp.