其他分享
首页 > 其他分享> > 20201217-2 类变量的作用及析构函数

20201217-2 类变量的作用及析构函数

作者:互联网

实例变量的作用是描述每个具体对象特定的属性
每个人都属于人这个类
但是可以分清,因为有共同点也有不同点,不同点就是通过实例变量存储的

类变量的用途是什么?
大家共用的属性,节省开销
1-1class Person:
    cn = "中国"def __init__(self,name,age,addr):
        self.name = name 

p1 = Person('name','age','addr')# 不需要传国籍,默认中国
1-1-2# 如果像下面那样,把国籍写在后面class Person:
    cn = "中国"def __init__(self,name,age,addr,cn="china"):
        self.name = name 

p1 = Person('name','age','addr')# 不传国籍也是 ok 的# 结果是一样的# 但是,在实例中,每一个实例都创建了一个 cn# 如果 14亿 人,就创建了 14亿个 cn# 这样是没有必要的,一份就可以了所以,类变量的作用是节省开销
2-1析构函数
析构函数的作用和构造函数刚好相反
在实例释放或销毁的时候自动执行的,通常用于做一些收尾工作
如关闭一些数据库连接,打开的临时文件
2-1-1# 析构函数怎么写呢?class Role:
    n = 123name = "我是类name"     # 这是 类变量def __init__(self, name,role, weapon, life_value=100, money=15000):  
        self.name = name    # 这是 实例变量self.role = role
        self.weapon = weapon
        self.lifevalue = life_value
        self.money = money# 这个是给每个实例的def __del__(self):# 不用传参数,是在实例释放时,自动执行的,无法传参的print("%s 彻底死了...."%self.name)# 下面这些是给类中共有的,是在类的内存中存着的def shot(self):print ("shooting...")    def got_shot(self):print("%s:ah...I got shot..."%self.name)   
    def buy_gun(self,gun_name):print ("%s just bought %s" % (self.name,gun_name))

r1 = Role('变态','terrorist', 'B22')# 如何让角色死掉呢?--->变态 彻底死了....# 没有进行操作,自己就执行了
2-1-2class Role:
    n = 123name = "我是类name"     # 这是 类变量def __init__(self, name,role, weapon, life_value=100, money=15000):  
        self.name = name    # 这是 实例变量self.role = role
        self.weapon = weapon
        self.lifevalue = life_value
        self.money = money# 这个是给每个实例的def __del__(self):# 不用传参数,是在实例释放时,自动执行的,无法传参的print("%s 彻底死了...."%self.name)# 下面这些是给类中共有的,是在类的内存中存着的def shot(self):print ("shooting...")    def got_shot(self):print("%s:ah...I got shot..."%self.name)   
    def buy_gun(self,gun_name):print ("%s just bought %s" % (self.name,gun_name))

r1 = Role('坏人','terrorist', 'B22')
r1.buy_gun("AK47")
r1.got_shot()--->坏人 just bought AK47
坏人:ah...I got shot...
坏人 彻底死了....# 没有调用,但是在最后执行了
2-1-3# 加上 r2class Role:
    n = 123name = "我是类name"     # 这是 类变量def __init__(self, name,role, weapon, life_value=100, money=15000):  
        self.name = name    # 这是 实例变量self.role = role
        self.weapon = weapon
        self.lifevalue = life_value
        self.money = money# 这个是给每个实例的def __del__(self):# 不用传参数,是在实例释放时,自动执行的,无法传参的print("%s 彻底死了...."%self.name)# 下面这些是给类中共有的,是在类的内存中存着的def shot(self):print ("shooting...")    def got_shot(self):print("%s:ah...I got shot..."%self.name)   
    def buy_gun(self,gun_name):print ("%s just bought %s" % (self.name,gun_name))

r1 = Role('坏人','terrorist', 'B22')
r1.buy_gun("AK47")
r1.got_shot()

r2 = Role('jack','terrorist','B22')
r2.got_shot()--->坏人 just bought AK47
坏人:ah...I got shot...
jack:ah...I got shot...
坏人 彻底死了....
jack 彻底死了....# del 的作用是以实例对象,释放或者销毁的时候,自动执行# 如果不主动删除,对象就会一直在内存里,直到程序退出# 最后执行是因为程序退出了
2-1-4如果不想等到程序退出,想直接删掉,应该怎么办?class Role:
    n = 123name = "我是类name"     # 这是 类变量def __init__(self, name,role, weapon, life_value=100, money=15000):  
        self.name = name    # 这是 实例变量self.role = role
        self.weapon = weapon
        self.lifevalue = life_value
        self.money = money# 这个是给每个实例的def __del__(self):# 不用传参数,是在实例释放时,自动执行的,无法传参的print("%s 彻底死了...."%self.name)# 下面这些是给类中共有的,是在类的内存中存着的def shot(self):print ("shooting...")    def got_shot(self):print("%s:ah...I got shot..."%self.name)   
    def buy_gun(self,gun_name):print ("%s just bought %s" % (self.name,gun_name))

r1 = Role('坏人','terrorist', 'B22')
r1.buy_gun("AK47")
r1.got_shot()del r1

r2 = Role('jack','terrorist','B22')
r2.got_shot()# r2 实例化之后,才执行的 r1 彻底死了# 现在 在 r2 实例化之前,就删掉 r1 看它是否会执行--->坏人 just bought AK47
坏人:ah...I got shot...
坏人 彻底死了....
jack:ah...I got shot...
jack 彻底死了....# 删掉 r1 就先彻底死了这个就叫 析构方法 或者析构函数
2-2现在声明了一个实例,就相当于调用了一次
以后就再也不用了,程序如果连续运行两年,期间只用了一次,按理说应该是被销毁的
所以,到底有没有被自动销毁?

Python 是从上到下的解释性语言,从上到下一步一步走
Python 如何知道现在用还是不用?
只要变量名还在,python 就认为是在用# 如果明确告诉 python 不想用了, del r1 删掉,删的不是内存的数据,删的是变量名# 等同于把小房子的门牌号 拆了# 门牌号拿走,就代表这个房子可以拆了# python 有一个定时循环计数器,隔一段时间会进行垃圾回收 “这个房子没有门牌号,拆了”# 垃圾留多了,就会溢出
2-3私有方法、私有属性
属性可以分两种,静态属性和动态属性
静态属性就是变量,动态属性就是方法
但是,一般的,我们称呼的属性,就是指变量
方法一般就叫方法

私有方法就是方法,私有属性就是属性
私有就是指别人访问不了,外面无法访问,只能自己访问

比如,造了一个人,心脏只能人自己访问,而无法拿出来访问
2-3-1私有属性不想让别人访问,应该怎么办?class Role:
    n = 123name = "我是类name"     # 这是 类变量def __init__(self, name,role, weapon, life_value=100, money=15000):  
        self.name = name    # 这是 实例变量self.role = role
        self.weapon = weapon# self.lifevalue = life_value     # life_value 相当于生命值;应该需要通过特定的方法才可以修改生命值;中枪生命值自动消减,外面是不能修改的# 所以,可以把它变成私有属性self.__life_value = life_value
        self.money = money# 这个是给每个实例的def __del__(self):pass# 不用传参数,是在实例释放时,自动执行的,无法传参的# print("%s 彻底死了...."%self.name)# 下面这些是给类中共有的,是在类的内存中存着的def shot(self):print ("shooting...")    def got_shot(self):print("%s:ah...I got shot..."%self.name)   
    def buy_gun(self,gun_name):print ("%s just bought %s" % (self.name,gun_name))

r1 = Role('坏人','terrorist', 'B22')
r1.buy_gun("AK47")
r1.got_shot()print(r1.__lifevalue)--->AttributeError: 'Role' object has no attribute '__lifevalue'所以这个时候,life_value 就是私有属性了
把这个变量隐藏了,对外面是不可见的
2-3-2虽然不能改,但是想知道生命值
上面是完全无法访问的,应该怎么办?
定义一个方法,因为内部是可以访问的class Role:
    n = 123name = "我是类name"     # 这是 类变量def __init__(self, name,role, weapon, life_value=100, money=15000):  
        self.name = name    # 这是 实例变量self.role = role
        self.weapon = weapon# self.lifevalue = life_value     # life_value 相当于生命值;应该需要通过特定的方法才可以修改生命值;中枪生命值自动消减,外面是不能修改的# 所以,可以把它变成私有属性self.__life_value = life_value
        self.money = money# 这个是给每个实例的def __del__(self):passdef show_status(self):print("name:%s weapon:%s life_val:%s"%(self.name,
                                                self.weapon,
                                                self.__life_value))# 下面这些是给类中共有的,是在类的内存中存着的def shot(self):print ("shooting...")    def got_shot(self):print("%s:ah...I got shot..."%self.name)   
    def buy_gun(self,gun_name):print ("%s just bought %s" % (self.name,gun_name))

r1 = Role('坏人','terrorist', 'B22')
r1.buy_gun("AK47")
r1.got_shot()# 这时如果想访问 lifevalue,就直接 r1.show_status()print(r1.show_status())--->坏人 just bought AK47
坏人:ah...I got shot...
name:坏人 weapon:B22 life_val:100None
2-3-3私有属性在内部可以改,可以在内部访问class Role:
    n = 123name = "我是类name"     # 这是 类变量def __init__(self, name,role, weapon, life_value=100, money=15000):  
        self.name = name    # 这是 实例变量self.role = role
        self.weapon = weapon# self.lifevalue = life_value     # life_value 相当于生命值;应该需要通过特定的方法才可以修改生命值;中枪生命值自动消减,外面是不能修改的# 所以,可以把它变成私有属性self.__life_value = life_value
        self.money = money# 这个是给每个实例的def __del__(self):passdef show_status(self):print("name:%s weapon:%s life_val:%s"%(self.name,
                                                self.weapon,
                                                self.__life_value))# 下面这些是给类中共有的,是在类的内存中存着的def shot(self):print ("shooting...")    def got_shot(self):
        self.__life_value -= 50print("%s:ah...I got shot..."%self.name)   
    def buy_gun(self,gun_name):print ("%s just bought %s" % (self.name,gun_name))

r1 = Role('坏人','terrorist', 'B22')
r1.buy_gun("AK47")# 这时,先 got_shot,然后在打印 life_valr1.got_shot()print(r1.show_status())--->坏人 just bought AK47
坏人:ah...I got shot...
name:坏人 weapon:B22 life_val:50None
2-4私有方法也是一样的,在前面加 __class Role:
    n = 123name = "我是类name"     # 这是 类变量def __init__(self, name,role, weapon, life_value=100, money=15000):  
        self.name = name    # 这是 实例变量self.role = role
        self.weapon = weapon# self.lifevalue = life_value     # life_value 相当于生命值;应该需要通过特定的方法才可以修改生命值;中枪生命值自动消减,外面是不能修改的# 所以,可以把它变成私有属性self.__life_value = life_value
        self.money = money# 这个是给每个实例的def __del__(self):passdef show_status(self):print("name:%s weapon:%s life_val:%s"%(self.name,
                                                self.weapon,
                                                self.__life_value))# 下面这些是给类中共有的,是在类的内存中存着的def __shot(self):print ("shooting...")    def got_shot(self):
        self.__life_value -= 50print("%s:ah...I got shot..."%self.name)   
    def buy_gun(self,gun_name):print ("%s just bought %s" % (self.name,gun_name))

r1 = Role('坏人','terrorist', 'B22')
r1.buy_gun("AK47")# 这时,先 got_shot,然后在打印 life_valr1.got_shot()
r1.__shot()     # 这样外面就无法访问了,这就是私有方法print(r1.show_status())

私有方法和私有属性,前面加两个下划线

 

标签:__,life,shot,name,self,及析构,20201217,def,变量
来源: https://blog.51cto.com/u_15149862/2714685