我一直在通过一些pygame教程学习Python。
其中我发现广泛使用关键字self，由于我的主要背景是Java，我发现我经常忘记输入self。例如，我会输入rect.centerx而不是self.rect.centerx，因为对我来说，rect已经是类的成员变量了。
我能想到这种情况的Java对应方式是在所有成员变量的引用前加上this。
我是否必须在所有成员变量前面加上self，还是有一种声明方式可以让我避免这样做？
即使我提出的方法不符合“Pythonic”的规范，我仍然希望知道是否有可能实现。
我看过了这些相关的SO问题，但它们并不能完全回答我的问题:
在Java术语中：Python没有成员函数，所有类函数都是静态的，并且在作为成员函数调用时，第一个参数是对实际类实例的引用。
这意味着当您的代码有一个class MyClass并且您构建了一个实例m = MyClass()时，调用m.do_something()将被执行为MyClass.do_something(m)。
还要注意，这个第一个参数技术上可以被称为任何你想要的东西，但是惯例是使用self，如果你希望其他人（包括你未来的自己）能够轻松地阅读你的代码，你应该坚持这个惯例。
结果是，即使没有完整的类定义可见，也永远不会有关于什么是成员和什么不是的混淆。这导致了有用的属性，例如：您不能添加意外遮盖非成员的成员，从而破坏代码。
一个极端的例子：您可以编写一个类，而不需要知道它可能具有哪些基类，并始终知道您是否正在访问成员：
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.>
请记住，这两个例子都是极端的，你不会每天都看到它们，我也不建议你经常编写这样的代码，但它们确实清楚地展示了需要显式使用 self 的方面。
self 的好处。 - bguiz__shadow__ myFieldName来“祝福”您的遮蔽字段。那也会防止意外遮蔽，不是吗？ - einpoklumimport 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)——基本上就是问题实际上所要求的，但请让我明确一点，我认为这通常不是一个好主意。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 )
再次强调，这通常是一个可怕的做法。
locals().update(self.__dict__)，但它没有起作用。在Python 3中，即使是“exec”技巧也不再是一个选项。另一方面，globals().update(self.__dict__)确实可以工作，但通常来说这是一种可怕的做法。 - argentum2f实际上，self 不是关键字，它只是 Python 实例方法的第一个参数通常被赋予的名称。这个第一个参数不能被省略，因为它是方法知道被调用时属于哪个类的唯一机制。
你可以使用任何想要的名称，例如
class test(object):
def function(this, variable):
this.variable = variable
甚至更好
class test(object):
def function(s, variable):
s.variable = variable
但是你必须使用一个名称作为作用域。
我不建议除非你有充分的理由，否则使用与self不同的东西，因为这会让有经验的Python程序员感到陌生。
def 函数名(_, 变量名): _.变量名 = 变量 - Bob Steindef funcion(*args): args[0].variable = args[1] - Aemyl是的，根据Python哲学，显式优于隐式，因此您必须始终指定self。
您还会发现，在Python中编程的方式与在Java中编程的方式非常不同，因此使用self的倾向会减少，因为您不会将所有内容都投影到对象内部。相反，您更多地使用模块级函数，这样可以更好地进行测试。
顺便说一句。我一开始讨厌它，现在我讨厌相反的东西。对于基于缩进的流程控制也是如此。
self。那么将它们放在类中有什么意义呢？ - Stefano Borini“self”是类的当前对象实例的传统占位符。当你想要在类内部引用对象的属性、字段或方法时，可以使用它来表示“本身”。但为了缩短代码，Python编程领域中的某些人开始使用“self”，而其他领域则使用“this”，但它们将其作为关键字，无法替换。我更喜欢使用“its”来增加代码的可读性。这是Python中的一件好事——你可以自由选择对象实例的占位符，而不仅限于“self”。 例如：
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)
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)
s（或其他单个字母）代替its？ - WestCoastProjectss具有相同的含义：类实例的别名。我必须查找上下文中its的含义。 - WestCoastProjects...混合方法效果最佳。您所有实际进行计算的类方法都应该移动到闭包中，而用于清理语法的扩展应该保留在类中。将闭包放入类中，将类视为命名空间。闭包本质上是静态函数，因此甚至在类中也不需要self*...
__str__等），因为这些方法的调用方式与普通方法不同。 - Dunes我在这里遵循@argentum2f的答案中复制属性的想法。这可以通过装饰器自动化，并且适用于Python 3. 当然，复制属性意味着它们不能被更改，因此装饰器的名称为@const_self。
使用@const_self，您可以定义一个带有与要使用的属性相同名称的第一个参数的方法 - 没有self。
from cmath import sqrt
def const_self(fun):
fun_args = fun.__code__.co_varnames[:fun.__code__.co_argcount]
def fun_with_self(*args, **kwargs):
self = args[0]
other_args = list(args[1:])
used_attributes = [arg for arg in fun_args if hasattr(self, arg)]
self_args = [getattr(self, attr) for attr in used_attributes]
return fun(*(self_args + other_args), **kwargs)
return fun_with_self
class QuadraticEquation:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
@const_self
def roots(a, b, c, dummy, lazy = False):
print("Dummy is", dummy)
if lazy: return # A lazy calculator does not calculate
return (-b - sqrt(b**2 - 4*a*c)) /2/a, (-b + sqrt(b**2 - 4*a*c)) /2/a
当然，这段代码还有很多需要改进的地方：至少它会在你定义一个像def fun(a, dummy, b, c): print(a,b,c)这样的方法时失败，并且它不会保留docstring。但我认为它足以清晰地展示了这个想法。
self是Python语法中访问对象成员的一部分，所以我恐怕你必须使用它。
self不是Python语法的一部分，它只是一个变量名。你可以使用任何名字。此外，当调用Python方法时，始终会隐式地传递至少一个参数在第一个位置。该参数是实例。这就是为什么如果你忘记定义一个参数，它会给你一个错误的原因。 - Hunkoys实际上，您可以使用Armin Ronacher演讲“5年的坏主意”（google it）中的“隐式self”配方。
这是一个非常巧妙的配方，就像Armin Ronacher的几乎所有东西一样，但我认为这个想法并不是很吸引人。我认为我更喜欢C＃/ Java中的显式this。
更新。链接到“糟糕思想配方”：https://speakerdeck.com/mitsuhiko/5-years-of-bad-ideas?slide=58
def method(<del>self</del>)参数列表中隐含了它，但是使用这个巧妙的技巧仍然需要self.variable。 - David Lotts
m_仅用于非公共的非静态数据成员（至少在 C++ 中）。 - Roger Pate