python self简介

约定不等于承诺〃 2022-05-29 12:57 158阅读 0赞

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

class Student(object):
        pass

*  1
 *  2

（Object）表示该类从哪个类继承下来的，Object类是所有类都会继承的类。

2、实例：定义好了类，就可以通过Student类创建出Student的实例，创建实例是通过类名+()实现：

student = Student()

*  1

3、由于类起到模板的作用，因此，可以在创建实例的时候，把我们认为必须绑定的属性强制填写进去。这里就用到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`。

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

5、既然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

6、`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的任何方法。

那么我们如果直接通过类来调用属性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'>