20201207-1 实例变量与类变量

1-1
class 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-1
r2 = 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 = 123
    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)

--->
123
123 Alex
123 Jack

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

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

1-1-6
# 加一个新的属性，防弹衣
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 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 = True

print(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 = 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 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 = True
print(r1.weapon)
del r1.weapon   # 武器就卸掉了
print(r1.n,r1.name,r1.bullet_prove,r1.weapon)

1-2-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 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-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 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"
# 这时，会影响的范围是谁？
# 会影响 r2

print(r1.n, r2.n)
--->
r1: AK47 改类变量
r2: xuliangwei 123
改类变量 ABC

# r1 永远是自己的实例变量
# r2 自己没有 n 所以，会跟着改

1-2-3
# 如果有一个列表
class Role:
    n = 123
    n_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-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
# 这样是没有必要的，一份就可以了
所以，类变量的作用是节省开销