Python中self用法详解

在介绍Python的self用法以前，先来介绍下Python中的类和实例……
咱们知道，面向对象最重要的概念就是类（class）和实例（instance），类是抽象的模板，好比学生这个抽象的事物，能够用一个Student类来表示。而实例是根据类建立出来的一个个具体的“对象”，每个对象都从类中继承有相同的方法，但各自的数据可能不一样。
一、以Student类为例，在Python中，定义类以下：

class Student(object):

pass

1
2
（Object）表示该类从哪一个类继承下来的，Object类是全部类都会继承的类。

二、实例：定义好了类，就能够经过Student类建立出Student的实例，建立实例是经过类名+()实现：

student = Student()
1
三、因为类起到模板的做用，所以，能够在建立实例的时候，把咱们认为必须绑定的属性强制填写进去。这里就用到Python当中的一个内置方法__init__方法，例如在Student类时，把name、score等属性绑上去:

class Student(object):

def __init__(self, name, score):
    self.name = name
    self.score = score

1
2
3
4
这里注意：（1）、__init__方法的第一参数永远是self，表示建立的类实例自己，所以，在__init__方法内部，就能够把各类属性绑定到self，由于self就指向建立的实例自己。（2）、有了__init__方法，在建立实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不须要传，Python解释器会本身把实例变量传进去：

student = Student("Hugh", 99)
student.name
"Hugh"
student.score
99
1
2
3
4
5
另外，这里self就是指类自己，self.name就是Student类的属性变量，是Student类全部。而name是外部传来的参数，不是Student类所自带的。故，self.name = name的意思就是把外部传来的参数name的值赋值给Student类本身的属性变量self.name。

四、和普通数相比，在类中定义函数只有一点不一样，就是第一参数永远是类的自己实例变量self，而且调用时，不用传递该参数。除此以外，类的方法(函数）和普通函数没啥区别，你既能够用默认参数、可变参数或者关键字参数（args是可变参数，args接收的是一个tuple，*kw是关键字参数，kw接收的是一个dict）。

五、既然Student类实例自己就拥有这些数据，那么要访问这些数据，就不必从外面的函数去访问，而能够直接在Student类的内部定义访问数据的函数（方法），这样，就能够把”数据”封装起来。这些封装数据的函数是和Student类自己是关联起来的，称之为类的方法：

class Student(obiect):

def __init__(self, name, score):
    self.name = name
    self.score = score
def print_score(self):
    print "%s: %s" % (self.name, self.score)

1
2
3
4
5
6

student = Student("Hugh", 99)
student.print_score
Hugh: 99
1
2
3
这样一来，咱们从外部看Student类，就只须要知道，建立实例须要给出name和score。而如何打印，都是在Student类的内部定义的，这些数据和逻辑被封装起来了，调用很容易，但殊不知道内部实现的细节。

若是要让内部属性不被外部访问，能够把属性的名称前加上两个下划线，在Python中，实例的变量名若是以开头，就变成了一个私有变量（private），只有内部能够访问，外部不能访问，因此，咱们把Student类改一改：

class Student(object):

def __init__(self, name, score):
    self.__name = name
    self.__score = score
def print_score(self):
    print "%s: %s" %(self.__name,self.__score)

1
2
3
4
5
6
7
改完后，对于外部代码来讲，没什么变更，可是已经没法从外部访问实例变量.__name和实例变量.__score了：

student = Student('Hugh', 99)
student.__name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'
1
2
3
4
5
这样就确保了外部代码不能随意修改对象内部的状态，这样经过访问限制的保护，代码更加健壮。

可是若是外部代码要获取name和score怎么办？能够给Student类增长get_name和get_score这样的方法：

class Student(object):

...

def get_name(self):
    return self.__name

def get_score(self):
    return self.__score

1
2
3
4
5
6
7
8
若是又要容许外部代码修改score怎么办？能够给Student类增长set_score方法：

class Student(object):

...

def set_score(self, score):
    self.__score = score

1
2
3
4
5
须要注意的是，在Python中，变量名相似__xxx__的，也就是以双下划线开头，而且以双下划线结尾的，是特殊变量，特殊变量是能够直接访问的，不是private变量，因此，不能用__name__、__score__这样的变量名。

有些时候，你会看到以一个下划线开头的实例变量名，好比_name，这样的实例变量外部是能够访问的，可是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我能够被访问，可是，请把我视为私有变量，不要随意访问”。

封装的另外一个好处是能够随时给Student类增长新的方法，好比：get_grade:

class Student(object):

...
def get_grade(self):
    if self.score >= 90:
        return 'A'
    elif self.score >= 60:
        return 'B'
    else:
        return 'C'

1
2
3
4
5
6
7
8
9
一样的，get_grade方法能够直接在实例变量上调用，不须要知道内部实现细节：

student.get_grade()
'A'
1
2
六、self的仔细用法
(1)、self表明类的实例，而非类。

class Test:

def ppr(self):
    print(self)
    print(self.__class__)

t = Test()
t.ppr()
执行结果：
<__main__.Test object at 0x000000000284E080>
<class '__main__.Test'>
1
2
3
4
5
6
7
8
9
10
从上面的例子中能够很明显的看出，self表明的是类的实例。而self.__class__则指向类。
注意：把self换成this，结果也同样，但Python中最好用约定俗成的self。
（2）、self能够不写吗？
在Python解释器的内部，当咱们调用t.ppr()时，实际上Python解释成Test.ppr(t)，也就是把self替换成了类的实例。

class Test:

def ppr():
    print(self)

t = Test()
t.ppr()
1
2
3
4
5
6
运行结果以下：

Traceback (most recent call last):
File "cl.py", line 6, in <module>

t.ppr()

TypeError: ppr() takes 0 positional arguments but 1 was given
1
2
3
4
运行时提醒错误以下：ppr在定义时没有参数，可是咱们运行时强行传了一个参数。

因为上面解释过了t.ppr()等同于Test.ppr(t)，因此程序提醒咱们多传了一个参数t。

这里实际上已经部分说明了self在定义时不能够省略。

固然，若是咱们的定义和调用时均不传类实例是能够的，这就是类方法。

class Test:

def ppr():
    print(__class__)

Test.ppr()

运行结果：
<class '__main__.Test'>
1
2
3
4
5
6
7
8
（3）、在继承时，传入的是哪一个实例，就是那个传入的实例，而不是指定义了self的类的实例。

class Parent:

def pprt(self):
    print(self)

class Child(Parent):

def cprt(self):
    print(self)

c = Child()
c.cprt()
c.pprt()
p = Parent()
p.pprt()
1
2
3
4
5
6
7
8
9
10
11
12
运行结果：

<__main__.Child object at 0x0000000002A47080>
<__main__.Child object at 0x0000000002A47080>
<__main__.Parent object at 0x0000000002A47240>
1
2
3
解释：
运行c.cprt()时应该没有理解问题，指的是Child类的实例。
可是在运行c.pprt()时，等同于Child.pprt(c)，因此self指的依然是Child类的实例，因为self中没有定义pprt()方法，因此沿着继承树往上找，发如今父类Parent中定义了pprt()方法，因此就会成功调用。

（4）、在描述符类中，self指的是描述符类的实例

class Desc:

def __get__(self, ins, cls):
    print('self in Desc: %s ' % self )
    print(self, ins, cls)

class Test:

x = Desc()
def prt(self):
    print('self in Test: %s' % self)

t = Test()
t.prt()
t.x
1
2
3
4
5
6
7
8
9
10
11
运行结果以下：

self in Test: <__main__.Test object at 0x0000000002A570B8>
self in Desc: <__main__.Desc object at 0x000000000283E208>
<__main__.Desc object at 0x000000000283E208> <__main__.Test object at 0x0000000002A570B8> <class '__main__.Test'>
1
2
3
这里主要的疑问应该在：Desc类中定义的self不是应该是调用它的实例t吗？怎么变成了Desc类的实例了呢？
由于这里调用的是t.x，也就是说是Test类的实例t的属性x，因为实例t中并无定义属性x，因此找到了类属性x，而该属性是描述符属性，为Desc类的实例而已，因此此处并无顶用Test的任何方法。 若是你在学习Python的过程当中碰见了不少疑问和难题，能够加-q-u-n 227 -435-450里面有软件视频资料免费

那么咱们若是直接经过类来调用属性x也能够获得相同的结果。

下面是把t.x改成Test.x运行的结果。

self in Test: <__main__.Test object at 0x00000000022570B8>self in Desc: <__main__.Desc object at 0x000000000223E208><__main__.Desc object at 0x000000000223E208> None <class '__main__.Test'>123总结：以上是以前学习Python时的小结，，同时为pyspark中调用self遇到的问题作铺垫，后面也会对比java，未完待续…….