2.python中self详解(程序适用于python3版本)
2019-04-11 10:29:31来源:博客园 阅读 ()
先介绍下Python中的类和实例
面向对象最重要的概念就是类(class)和实例(instance),类(class)是抽象的模板,比如学生这个抽象的事物,可以用一个Student类来表示。而实例是根据类创建出来的一个个具体的“对象”,每一个对象都从类中继承有相同的方法,但各自的数据可能不同。
1、以Student类为例,在Python中,定义类如下:
1 class Student(object): 2 pass
(Object)表示该类从哪个类继承下来的,Object类是所有类都会继承的类。
2、实例:定义好了类,就可以通过Student类创建出Student的实例,创建实例是通过类名+()实现:
1 student = Student() #创建对象,即类实例化
3、由于类起到模板的作用,因此,可以在创建实例的时候,可以把我们需要绑定的属性强制填写进去。这里就用到Python当中的一个内置方法__init__
方法,例如在Student类时,把name、score等属性绑上去:
1 class Student(object): 2 def __init__(self, name, score): 3 self.name = name 4 self.score = score
注意:(1)、__init__
方法的第一参数永远是self
,表示创建的类实例本身,因此,在__init__
方法内部,就可以把各种属性绑定到self,因为self就指向创建的实例本身。
(2)、有了__init__
方法,在创建实例的时候,就不能传入空的参数了,必须传入与__init__
方法匹配的参数,但self不需要传,Python解释器会自己把实例变量传进去,如下:
1 >>>student = Student("Hugh", 99) 2 >>>student.name 3 "Hugh" 4 >>>student.score 5 99
另外,这里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类本身是关联起来的,称之为类的方法:
1 class Student(obiect): 2 def __init__(self, name, score): 3 self.name = name 4 self.score = score 5 def print_score(self): 6 print("%s: %s" % (self.name, self.score))
1 >>>student = Student("Hugh", 99) 2 >>>student.print_score() 3 Hugh: 99
这样一来,我们从外部看Student类,就只需要知道,创建实例需要给出name和score。而如何打印,都是在Student类的内部定义的,这些数据和逻辑被封装起来了,调用很容易,但却不知道内部实现的细节。
如果要让内部属性不被外部访问,可以在属性的名称前加上两个下划线,在Python中,实例的变量名如果以两个下划线开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问,所以,我们把Student类改一改:
1 class Student(object): 2 3 def __init__(self, name, score): 4 self.__name = name 5 self.__score = score 6 def print_score(self): 7 print("%s: %s" %(self.__name,self.__score))
改完后,对于外部代码来说,没什么变动,但是已经无法从外部访问实例变量.__name
和实例变量.__score
了:
1 >>> student = Student('Hugh', 99) 2 >>> student.__name 3 Traceback (most recent call last): 4 File "<stdin>", line 1, in <module> 5 AttributeError: 'Student' object has no attribute '__name'
这样就确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护,代码更加健壮。
但是如果外部代码要获取name和score怎么办?可以给Student类增加get_name和get_score这样的方法:
1 class Student(object): 2 ... 3 4 def get_name(self): 5 return self.__name 6 7 def get_score(self): 8 return self.__score
如果又要允许外部代码修改score怎么办?可以给Student类增加set_score方法:
1 class Student(object): 2 ... 3 4 def set_score(self, score): 5 self.__score = score
需要注意的是,在Python中,变量名类似__xxx__
的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变量,特殊变量是可以直接访问的,不是private变量,所以,不能用__name__
、__score__
这样的变量名。
有些时候,你会看到以一个下划线开头的实例变量名,比如_name,这样的实例变量外部是可以访问的,但是,按照约定俗成的规定,当你看到这样的变量时,意思就是,“虽然我可以被访问,但是,请把我视为私有变量,不要随意访问”。
封装的另一个好处是可以随时给Student类增加新的方法,比如:get_grade
:
1 class Student(object): 2 ... 3 def get_grade(self): 4 if self.score >= 90: 5 return 'A' 6 elif self.score >= 60: 7 return 'B' 8 else: 9 return 'C'
同样的,get_grade
方法可以直接在实例变量上调用,不需要知道内部实现细节:
1 >>> student.get_grade() 2 'A'
6、self
的仔细用法
(1)、self代表类的实例,而非类。
1 class Test: 2 def ppr(self): 3 print(self) 4 print(self.__class__) 5 6 t = Test() 7 t.ppr() 8 执行结果: 9 <__main__.Test object at 0x000000000284E080> 10 <class '__main__.Test'>
从上面的例子中可以很明显的看出,self代表的是类的实例。而self.__class__
则指向类。
注意:把self换成this,结果也一样,但Python中最好用约定俗成的self。
(2)、self可以不写吗?
在Python解释器的内部,当我们调用t.ppr()时,实际上Python解释成Test.ppr(t),也就是把self替换成了类的实例。
1 class Test: 2 def ppr(): 3 print(self) 4 5 t = Test() 6 t.ppr()
运行结果如下:
1 Traceback (most recent call last): 2 File "cl.py", line 6, in <module> 3 t.ppr() 4 TypeError: ppr() takes 0 positional arguments but 1 was given
运行时提醒错误如下:ppr在定义时没有参数,但是我们运行时强行传了一个参数。
由于上面解释过了t.ppr()等同于Test.ppr(t),所以程序提醒我们多传了一个参数t。
这里实际上已经部分说明了self
在定义时不可以省略。
当然,如果我们的定义和调用时均不传类实例是可以的,这就是类方法。
1 class Test: 2 @classmethod 3 def ppr(cls): 4 print(__class__) 5 6 Test.ppr() 7 8 运行结果: 9 <class '__main__.Test'>
(3)、在继承时,传入的是哪个实例,就是那个传入的实例,而不是指定义了self的类的实例。
1 class Parent: 2 def pprt(self): 3 print(self) 4 5 class Child(Parent): 6 def cprt(self): 7 print(self) 8 c = Child() 9 c.cprt() 10 c.pprt() 11 p = Parent() 12 p.pprt()
运行结果:
1 <__main__.Child object at 0x0000000002A47080> 2 <__main__.Child object at 0x0000000002A47080> 3 <__main__.Parent object at 0x0000000002A47240>
解释:
运行c.cprt()时应该没有理解问题,指的是Child类的实例。
但是在运行c.pprt()时,等同于Child.pprt(c),所以self指的依然是Child类的实例,由于self中没有定义pprt()方法,所以沿着继承树往上找,发现在父类Parent中定义了pprt()方法,所以就会成功调用。
(4)、在描述符类中,self指的是描述符类的实例
1 class Desc: 2 def __get__(self, ins, cls): 3 print('self in Desc: %s ' % self ) 4 print(self, ins, cls) 5 class Test: 6 x = Desc() 7 def prt(self): 8 print('self in Test: %s' % self) 9 t = Test() 10 t.prt() 11 t.x
运行结果如下:
1 self in Test: <__main__.Test object at 0x0000000002A570B8> 2 self in Desc: <__main__.Desc object at 0x000000000283E208> 3 <__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运行的结果。
1 self in Test: <__main__.Test object at 0x00000000022570B8> 2 self in Desc: <__main__.Desc object at 0x000000000223E208> 3 <__main__.Desc object at 0x000000000223E208> None <class '__main__.Test'>
原文链接:https://www.cnblogs.com/ubuntu1987/p/10655496.html
如有疑问请与原作者联系
标签:
版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有
- Django模版中加载静态文件配置详解 2019-07-24
- Python 运算符 各类运算符总结 2019-07-24
- Frangi形态学滤波详解 2019-07-24
- 如何入门Python爬虫?爬虫原理及过程详解 2019-05-18
- Python 中的设计模式详解之:策略模式 2019-04-18
IDC资讯: 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营: 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程: Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术: Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧: 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作: FrontPages Dreamweaver Javascript css photoshop fireworks Flash