欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python中的self参数(python中self用法详解)

程序员文章站 2024-03-27 15:30:04
我们知道,面向对象最重要的概念就是类(class)和实例(instance),类是抽象的模板,比如学生这个抽象的事物,可以用一个student类来表示。而实例是根据类创建出来的一个个具体的“对象”,每...

我们知道,面向对象最重要的概念就是类(class)和实例(instance),类是抽象的模板,比如学生这个抽象的事物,可以用一个student类来表示。而实例是根据类创建出来的一个个具体的“对象”,每一个对象都从类中继承有相同的方法,但各自的数据可能不同。

1、定义类

以student类为例,在python中,定义类如下:

class student(object):
    pass

(object)表示该类从哪个类继承下来的,object类是所有类都会继承的类。即class name(*)中*是表示从哪个类继承下来的

2、由类创建实例

定义好了类,就可以通过student类创建出student的实例,创建实例是通过类名+()实现:

student = student()

3、添加属性

由于类起到模板的作用,因此,可以在创建实例的时候,把我们认为必须绑定的属性强制填写进去。这里就用到python当中的一个内置方法__init__方法,例如在student类时,把name、score等属性绑上去:

class student(object):
	  slogan = 'i ame a student'				# 类属性:类名访问
    def __init__(self, name, score):
        self.name =i name						  # 实例属性 :实例与类名均可访问
        self.score = score						# 实例属性
  • __init__方法的第一参数永远是self,表示类的实例本身,因此,在__init__方法内部,就可以把各种属性绑定到self,因为self就指向创建的实例本身(通过self绑定的属性是实例属性)
  • 另外,这里self就是指由类创建的实例本身,self.name是student类实例本身的属性变量,而name是外部传来的参数,所以,self.name = name的意思就是把外部传来的参数name的值赋值给student类实例本身自己的属性变量self.name
  • 有了__init__方法,在创建实例的时候,就不能传入空的参数了,必须传入与__init__方法匹配的参数,但self不需要传,python解释器会自己把实例变量传进去
>>>student = student("hugh", 99)
>>>student.name
"hugh"
>>>student.score
99

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)
>>>student = student("hugh", 99)
>>>student.print_score
hugh: 99

这样一来,我们从外部看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)

改完后,对于外部代码来说,没什么变动,但是已经无法从外部访问实例变量.__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'

这样就确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护,代码更加健壮。

但是如果外部代码要获取name和score怎么办?可以给student类增加get_name和get_score这样的方法:

class student(object):
    ...
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score

如果又要允许外部代码修改score怎么办?可以给student类增加set_score方法:

class student(object):
    ...
    def set_score(self, score):
        self.__score = score

需要注意的是,在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'

同样的,get_grade方法可以直接在实例变量上调用,不需要知道内部实现细节:

>>> student.get_grade()
'a'

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

从上面的例子中可以很明显的看出,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()
运行结果如下:
traceback (most recent call last):
  file "cl.py", line 6, in <module>
    t.ppr()
typeerror: ppr() takes 0 positional arguments but 1 was given

运行时提醒错误如下:ppr在定义时没有参数,但是我们运行时强行传了一个参数。由于上面解释过了t.ppr()等同于test.ppr(t),所以程序提醒我们多传了一个参数t。这里实际上已经部分说明了self在定义时不可以省略

当然,如果我们的定义和调用时均不传类实例是可以的,这就是类方法

class test:
    def ppr():
        print(__class__)
test.ppr()
运行结果:
<class '__main__.test'>
  • (3)在继承时,传入的是哪个实例,就是那个传入的实例,而不是指定义了self的类的实例。
class parent:
    def pprt(self):
        print(self)
class child(parent):
    def cprt(self):
        print(self)
c = child()
c.cprt()
c.pprt()			# 等同于child.pprt(c)
p = parent()
p.pprt()
运行结果:
<__main__.child object at 0x0000000002a47080>
<__main__.child object at 0x0000000002a47080>
<__main__.parent object at 0x0000000002a47240>

运行c.cprt()时应该没有理解问题,指的是child类的实例。

但是在运行c.pprt()时,等同于child.ppt(rc),所以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
运行结果如下:
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'>

这里主要的疑问应该在: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'>

题外话:由于在很多时候描述符类中仍然需要知道调用该描述符的实例是谁,所以在描述符类中存在第二个参数ins(insctance),用来表示调用它的类实例,所以t.x时可以看到第三行中的运行结果中第二项为<main.test object at 0x0000000002a570b8>。而采用test.x进行调用时,由于没有实例,所以返回none。

总结

  • self在定义时需要定义,但是在调用时会自动传入。
  • self的名字并不是规定死的,但是最好还是按照约定是用self
  • self总是指调用时的类的实例。