1-1class Role:
    比如 n = 123，这个变量就叫 类变量
    n = 123# Role 为类名， class Role 整个是一个类def __init__(self, name, role, weapon, life_value=100, money=15000):# __init__ 为构造函数# 构造函数负责在实例化时做一些类的初始化的工作        比如，给实例赋名字，那么 self.name 赋给了谁？ name 还是实例？一定是具体的实例
        有实例变量，就一定有类变量
        self.name = name       # 实例变量（静态属性），作用域就是实例本身        这个实例变量，r1 的实例变量在 r1 中， r2 的实例变量在 r2 中，他们不能共享
        实例变量的作用域，就是实例本身
        实例变量同时又叫属性，或者静态属性，静态属性其实就是一个变量def shot(self):    # 类的方法，功能（动态属性）        这是角色的功能，专业术语叫做 类的方法，其实就是功能
        也可以被称为一个属性，但是和上面属性的区别，更像是一个执行过程，所以一般称为动态属性
        动态属性就是方法，静态属性就是变量

1-1-1r2 = Role('Jack', 'terrorist', 'B22')  # 生成一个角色这就是实例化
实例化后得到一个对象 r2，这个对象又叫做 Role 这个类的实例

1-1-2 类变量和实例变量的区别class Role:
    n = 123   # 类变量print(Role.n)--->
123先不做任何实例化，直接打印 n
没有实例化就可以打印，所以类这个变量在类的内存里

1-1-3现在将它实例化class Role(object):
    n = 123def __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 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))print(Role.n)

r1 = Role('Alex','police','AK47')print(r1.n,r1.name)

r2 = Role('Jack', 'terrorist', 'B22')print(r2.n,r2.name)--->
123
123 Alex123 Jack

不实例化可以调用这个变量，实例化通过实例也可以调用这个变量

1-1-4现在类中有一个变量叫 n
实例变量有一个变量叫 name
这时能不能在写一个类变量 name？
这时打印的结果是一样的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 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))print(Role.n)

r1 = Role('Alex','police','AK47')print(r1.n,r1.name)

r2 = Role('Jack', 'terrorist', 'B22')print(r2.n,r2.name)

先找实例变量，如果实例变量没有，就去类里面找

1-1-5如果现在不想叫 Alex 想改名字
可以重新赋值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 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))print(Role.n)

r1 = Role('Alex','police','AK47')
r1.name = "chenronghua"print(r1.n,r1.name)

r2 = Role('Jack', 'terrorist', 'B22')
r2.name = "xuliangwei"print(r2.n,r2.name)--->
123
123 chenronghua123 xuliangwei

1-1-6# 加一个新的属性，防弹衣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 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))print(Role.n)

r1 = Role('Alex','police','AK47')
r1.name = "chenronghua"r1.bullet_prove = Trueprint(r1.n,r1.name,r1.bullet_prove)# 类里面没有这个属性，实例化后添加了一个属性，这样是否可以呢？--->
123
123 chenronghua True# 结果是可行的# r1 = Role('Alex','police','AK47')# 这句话相当于 Role(r1, 'Alex','police','AK47') 把 r1 传给它，r1.name = name r1.role = role# 实例化相当于做了这件事# 实例化时忘记了，实例化后，加上了，是完全可以的# r1.bullet_prove = True 和 self.name 效果是完全一样的# 新加了一个之后，r2 有没有这个属性？# r2 不会有这个属性

1-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
        self.money = money# 这个是给每个实例的# 下面这些是给类*有的，是在类的内存中存着的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))print(Role.n)

r1 = Role('Alex','police','AK47')
r1.name = "chenronghua"r1.bullet_prove = Trueprint(r1.weapon)del r1.weapon   # 武器就卸掉了print(r1.n,r1.name,r1.bullet_prove,r1.weapon)

1-2-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 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('Alex','police','AK47')
r1.name = "chenronghua"r1.bullet_prove = True
r1.n = "改类变量"print("r1:",r1.weapon,r1.n)# r2 会一起更改吗？r2 = Role('Jack', 'terrorist', 'B22')
r2.name = "xuliangwei"print("r2:",r2.name,r2.n)print(Role.n)--->r1: AK47 改类变量
r2: xuliangwei 123
123# 类变量 r1 改了， r2 没有更改# r1 改类变量，其实是在 r1 的内存中，加了一个 n = 改类变量# 类里面有一个 n = 123# 两个 n 没有关系# 所以，改类变量，其实没有改类变量，而是相当于在内存中 创建了一个新的变量# r2 调用时，发现本地没有 n 所以还是到类变量里面去找

1-2-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 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('Alex','police','AK47')
r1.name = "chenronghua"r1.bullet_prove = True
r1.n = "改类变量"print("r1:",r1.weapon,r1.n)# r2 会一起更改吗？r2 = Role('Jack', 'terrorist', 'B22')
r2.name = "xuliangwei"print("r2:",r2.name,r2.n)

Role.n = "ABC"# 这时，会影响的范围是谁？# 会影响 r2print(r1.n, r2.n)--->r1: AK47 改类变量
r2: xuliangwei 123改类变量 ABC# r1 永远是自己的实例变量# r2 自己没有 n 所以，会跟着改

1-2-3# 如果有一个列表class Role:
    n = 123n_list = []
    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 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('Alex','police','AK47')
r1.name = "chenronghua"r1.n_list.append("from r1")
r1.bullet_prove = True
r1.n = "改类变量"print("r1:",r1.weapon,r1.n)# r2 会一起更改吗？r2 = Role('Jack', 'terrorist', 'B22')
r2.name = "xuliangwei"r2.n_list.append("from r2")print("r2:",r2.name,r2.n,r2.n_list)

Role.n = "ABC"print(Role.n_list)

 

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# 这样是没有必要的，一份就可以了所以，类变量的作用是节省开销