为何Python定义的class中的函数须要self做为第一个参数

Why must ‘self’ be used explicitly in method definitions and calls?

　　The idea was borrowed from Modula-3. It turns out to be very useful, for a variety of reasons.

　　First, it’s more obvious that you are using a method or instance attribute instead of a local variable. Reading self.x or self.meth() makes it absolutely clear that an instance variable or method is used even if you don’t know the class definition by heart. In C++, you can sort of tell by the lack of a local variable declaration (assuming globals are rare or easily recognizable) – but in Python, there are no local variable declarations, so you’d have to look up the class definition to be sure. Some C++ and Java coding standards call for instance attributes to have an m_ prefix, so this explicitness is still useful in those languages, too.

　　Second, it means that no special syntax is necessary if you want to explicitly reference or call the method from a particular class. In C++, if you want to use a method from a base class which is overridden in a derived class, you have to use the :: operator – in Python you can write baseclass.methodname(self, <argument list>). This is particularly useful for __init__() methods, and in general in cases where a derived class method wants to extend the base class method of the same name and thus has to call the base class method somehow.

　　Finally, for instance variables it solves a syntactic problem with assignment: since local variables in Python are (by definition!) those variables to which a value is assigned in a function body (and that aren’t explicitly declared global), there has to be some way to tell the interpreter that an assignment was meant to assign to an instance variable instead of to a local variable, and it should preferably be syntactic (for efficiency reasons). C++ does this through declarations, but Python doesn’t have declarations and it would be a pity having to introduce them just for this purpose. Using the explicit self.var solves this nicely. Similarly, for using instance variables, having to write self.var means that references to unqualified names inside a method don’t have to search the instance’s directories. To put it another way, local variables and instance variables live in two different namespaces, and you need to tell Python which namespace to use.

 

中文翻译(原创)：

　　这种作法是借鉴自Modula-3, 在不少方面来看到都是颇有用的。
　　首先，让你很明显看出这是在使用一个实例方法或属性，而不是一个局部变量

      即使对类的定义不清楚，遇到self.x或者self.meth()都会明白这是实例属性或方法。

在C++中，若是局部变量未声明，编译器会告诉你；可是，在python中，因为局部变量不须要声明，
使得你须要在类的定义中去找。一些C++及Java的编码规范须要使用m_作前缀来定义实例属性，在这些语言中，这种明确的
定义是很是有用的。

　　其次，这样作能够不须要特别的语法，来供一个class去调用这些方法

     在C++中，若是你想在子类中调用基类中被那些被子类复写的方法，

你须要使用::操做符 - 在Python中，你可使用baseclass.methodname(self, <argument list>)的
方式来调用，这对于__init__()方法特别有用，另外对于子类中复写的方法想要调用基类中同名方法时也很是有效。

　　最后，属性解决了赋值的语法问题

     由于python中的局部变量都是在函数体中被赋值的(它们没有被定义成全局变量)，
须要有一种方式来告诉解释器某一个赋值操做是赋给属性仍是局部变量，这样能够更好地语法检查(为了高效)。C++经过声明
来作到这一点，可是Python没有声明，为此而引入声明也不划算。明确地使用self.var能够很好地解决这个问题。
使用self.var意味着：在一个方法中引用一个非法的变量不须要在实例目录中去查找(这一部分不太可以理解)。另外，局部
变量和实例变量存在于不一样的命名空间，你须要告诉python到底应该使用哪一个命名空间。

 

参考:　http://docs.python.org/2/faq/design.html#why-must-self-be-used-explicitly-in-method-definitions-and-calls