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

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

作者:互联网

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

类变量的用途是什么?
大家共用的属性,节省开销
1-1
class 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 = 123
    name = "我是类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-2
class Role:
    n = 123
    name = "我是类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
# 加上 r2
class Role:
    n = 123
    name = "我是类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 = 123
    name = "我是类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 = 123
    name = "我是类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 = 123
    name = "我是类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

    def 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:100
None
2-3-3
私有属性在内部可以改,可以在内部访问
class Role:
    n = 123
    name = "我是类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

    def 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 -= 50
        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")
# 这时,先 got_shot,然后在打印 life_val
r1.got_shot()
print(r1.show_status())
--->
坏人 just bought AK47
坏人:ah...I got shot...
name:坏人 weapon:B22 life_val:50
None
2-4
私有方法也是一样的,在前面加 __
class Role:
    n = 123
    name = "我是类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

    def 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 -= 50
        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")
# 这时,先 got_shot,然后在打印 life_val
r1.got_shot()
r1.__shot()     # 这样外面就无法访问了,这就是私有方法
print(r1.show_status())

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

 

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