实例变量的作用是描述每个具体对象特定的属性
每个人都属于人这个类
但是可以分清，因为有共同点也有不同点，不同点就是通过实例变量存储的
类变量的用途是什么？
大家共用的属性，节省开销
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())
私有方法和私有属性，前面加两个下划线