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

类变量的用途是什么？
大家共用的属性，节省开销

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())

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