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