Python进阶-XV 类和对象的命名空间 组合

一、类和对象命名空间

　　1.类中可以定义两种属性

　　静态属性和动态属性

 1 class Course:
 2     language = 'Chinese'  # 静态属性
 3     def __init__(self, name, score, teacher):    # 动态属性
 4         self.name = name
 5         self.score = score
 6         self.teacher = teacher
 7 
 8     def take(self):
 9         '''
10         被选修
11         :return:
12         '''
13         pass

　　2）访问类中静态属性的两种方式：

print(Course.language)
print(Course.__dict__['language'])

python = Course('Python', 99, 'Mr Wang')
java = Course('JAVA', 97, 'Mrs Liu')

　　3）对象无法改变类中的静态属性，如果其为不可变类型的话！

python.language = 'English'
print(python.language)  # English
print(Course.language)  # Chinese
print(java.language)  # Chinese
# 查看一下python对象中的属性：新增加了一个language属性，将类中的静态属性覆盖了！但是无法改变类中的属性！
print(python.__dict__)  #{'teacher': 'Mr Wang', 'name': 'Python', 'score': 99, 'language': 'English'}

　　4）如果类中的静态属性是可变数据类型，其值是可以被改变的，但是属性所对应的内存地址一直没变！

 1 lass Lamp:
 2     product_from = ['China']
 3 
 4 desk_lamp = Lamp()
 5 stree_light = Lamp()
 6 
 7 print(id(Lamp.product_from))
 8 desk_lamp.product_from[0] = 'Vietnam'
 9 print(Lamp.product_from)
10 print(id(Lamp.product_from))

　　5）小结
　　# 类中的静态变量 可以被对象和类调用
　　# 对于不可变数据类型来说，类变量最好用类名操作
　　# 对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的

2、例子1：计算类被实例的次数

class Foo:
    count = 0
    def __init__(self):
        Foo.count += 1

f1 = Foo()
f2 = Foo()
print(Foo.count)

 3、绑定方法
# 已经了解到，类中的函数叫方法，绑定方法就是类中的方法，被对象调用时，
# 就绑定了该对象，能使用该对象的所有属性！

#   1）、例子2：模拟人生

 1 class Person:
 2     money = 0
 3     def earn_salary(self):
 4         Person.money += 1000
 5 
 6 mother = Person()
 7 father = Person()
 8 mother.earn_salary()  # 这就是绑定方法
 9 father.earn_salary()  # 这也是绑定方法
10 print(Person.money)
11 print(Person.earn_salary)  # 
12 print(mother.earn_salary)  #  >

　　2) 联想到每个包中都有一个__init__.py
　　# 每当import package 时，其实就是一个类的实例化的过程；
　　# 如：import time
　　#     time.time() time方法绑定了一个time对象

4、总结
# 类里的名字有 类变量（静态属性量）+ 方法名（动态属性）
# 对象里的名字 对象属性
# 对象 —— > 类
# 对象找名字 ： 先找自己的 找类的 再找不到就报错
# 对象修改静态属性的值
    #  对于不可变数据类型来说，类变量最好用类名操作
    #  对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的

二、组合的用法

# 还是从人狗大战引入组合的概念
# 人和狗大战了，如果人的攻击力太弱，怎么办？
# 可以增加一个武器啊！

 1 class Person:
 2     def __init__(self, name, age, hp, aggr, ginder, money):
 3         self.name = name
 4         self.age = age
 5         self.hp = hp
 6         self.aggr = aggr
 7         self.ginder = ginder
 8         self.money = money
 9 
10     def fight(self, dog):
11         dog.hp -= self.aggr
12 
13     def get_weapon(self, weapon):
14         self.weapon = weapon
15 
16 class Dog:
17     def __init__(self, name, aggr, hp, kind):
18         self.name = name
19         self.aggr = aggr
20         self.hp = hp
21         self.kind = kind
22 
23     def bite(self, person):
24         person.hp -= self.aggr
25 
26 class Weapon:
27     def __init__(self, name, price, aggr):
28         self.name = name
29         self.price = price
30         self.aggr = aggr
31 
32     def attack(self, dog):
33         dog.hp -= self.aggr
34 
35 tom = Person('tom', 22, 500, 100, 'man', 2000)
36 little_white = Dog('little_white', 150, 300, 'Labrador')
37 print('被武器袭击前的狗的生命值：', little_white.hp)
38 weapton = Weapon('Knife', 2000, 300)
39 if tom.money >= weapton.price:
40     tom.get_weapon(weapton)
41     tom.weapon.attack(little_white)
42     print('被武器袭击后的狗的生命值：', little_white.hp)
43 else:
44     print('余额不足，请充值！')

从上例子可以看到组合的使用，由此可以定义了：
组合 ：一个对象的属性值是另外一个类的对象
        alex.weapon 是 Weapon类的对象
 即一个对象有另外一个对象