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

一、类和对象命名空间

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

　　静态属性和动态属性

 class Course:
     language = 'Chinese'  # 静态属性
     def __init__(self, name, score, teacher):    # 动态属性
         self.name = name
         self.score = score
         self.teacher = teacher

     def take(self):
         '''
         被选修
         :return:
         '''
         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）如果类中的静态属性是可变数据类型，其值是可以被改变的，但是属性所对应的内存地址一直没变！

 lass Lamp:
     product_from = ['China']

 desk_lamp = Lamp()
 stree_light = Lamp()

 print(id(Lamp.product_from))
 desk_lamp.product_from[0] = 'Vietnam'
 print(Lamp.product_from)
 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：模拟人生

 class Person:
     money = 0
     def earn_salary(self):
         Person.money += 1000

 mother = Person()
 father = Person()
 mother.earn_salary()  # 这就是绑定方法
 father.earn_salary()  # 这也是绑定方法
 print(Person.money)
 print(Person.earn_salary)  # <function Person.earn_salary at 0x0000022B50B3E730>
 print(mother.earn_salary)  #  <bound method Person.earn_salary of <__main__.Person object at 0x000001775E0E3AC8>>

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

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

二、组合的用法

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

 class Person:
     def __init__(self, name, age, hp, aggr, ginder, money):
         self.name = name
         self.age = age
         self.hp = hp
         self.aggr = aggr
         self.ginder = ginder
         self.money = money

     def fight(self, dog):
         dog.hp -= self.aggr

     def get_weapon(self, weapon):
         self.weapon = weapon

 class Dog:
     def __init__(self, name, aggr, hp, kind):
         self.name = name
         self.aggr = aggr
         self.hp = hp
         self.kind = kind

     def bite(self, person):
         person.hp -= self.aggr

 class Weapon:
     def __init__(self, name, price, aggr):
         self.name = name
         self.price = price
         self.aggr = aggr

     def attack(self, dog):
         dog.hp -= self.aggr

 tom = Person('tom', 22, 500, 100, 'man', 2000)
 little_white = Dog('little_white', 150, 300, 'Labrador')
 print('被武器袭击前的狗的生命值：', little_white.hp)
 weapton = Weapon('Knife', 2000, 300)
 if tom.money >= weapton.price:
     tom.get_weapon(weapton)
     tom.weapon.attack(little_white)
     print('被武器袭击后的狗的生命值：', little_white.hp)
 else:
     print('余额不足，请充值！')

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