类与对象的命名空间、组合、继承
---恢复内容开始---
# 类与对象的名称空间 class Game_role: name = "LOL" year = 2012 def __init__(self, name, ad, hp): self.name = name self.ad = ad self.hp = hp def attack(self, obj2): Game_role.area = "德玛西亚" print("%s攻击了%s, %s掉了%s血，还剩%s血" % (self.name, obj2.name, obj2.name, self.ad, obj2.hp-self.ad)) p1 = Game_role("盖伦", 10, 100) p2 = Game_role("剑豪", 20, 80) print(p1.attack(p2)) p1.armor = 90 print(p1.__dict__) # 对象的属性不仅可以在 __init__ 添加，还能再其他地方添加 p2.attack(p1) print(Game_role.__dict__) # 类的属性，不仅在类内部添加，还可以在类的外部添加 Game_role.year = 6 print(Game_role.__dict__) p1 = Game_role("盖伦", 10, 100) print(p1.name) # 这里不是打印 LOL,而是 盖伦 # 实例化对象先从对象本身的空间找name,没有的话就找类里面的name # 因为对象空间中存在一个类对象指针，所以对象可以找到类中的变量以及方法 # 类名只能找到类中的变量及方法，或者父类中找，不能找对象中的属性 # 对象与对象之间原则上是不能相互访问的 print(p1.year) # 6 p3 = Game_role("提莫", 30, 60)
# 一. 类名称空间与对象的名称空间 # 类一创建在内存中就会创建该类的名称空间，用来存储类中定义的所有名字，这些名字都是类的属性 # 类的属性有两种： # 1. 静态属性——直接在类中定义的变量 # 2. 动态属性就是定义在类中的方法 # 类的数据属性对于所有对象来说是共享的 class Person: language = "人类语言" age = 18 def __init__(self): pass def attack(self, a): pass p1 = Person() p2 = Person() print(id(p1.language), id(p2.language)) # 2645986525440 2645986525440 print(id(p1.age), id(p2.age)) # 1700162848 1700162848 # 注意这里并不是p1改变了类的静态属性，对象只能查看 # 因此相当于在该对象的内存中开辟了一个空间，存放对象的age属性与值20的对应关系 p1.age = 20 print(p1.age) # 20 print(p2.age) # 18 print(id(p1.age), id(p2.age)) # 1700162912 1700162848 # 而类的动态属性是绑定到所有对象的 # 因此这里对象p1调用 attack 方法时可以把自己传进去 # p1.attack(p1) 不会报错 # 总结： # 创建一个对象\实例就会创建一个该对象\实例的名称空间 # 存放对象\实例的名字，称为对象\实例的属性 # obj.name 会从 obj 的名称空间找name, 找不到就去类中找，再找不到就找父类...最后找不到抛出异常
# 组合 # 计算有多少对象调用一个类 class A: count = 0 def __init__(self): A.count += 1 obj = A() obj1 = A() print(A.count) # 组合：将一个对象封装到另一个对象的属性中 class Game_role: def __init__(self, name, ad, hp): self.name = name self.ad = ad self.hp = hp def attack(self, obj2): print("%s攻击了%s, %s掉了%s血，还剩%s血" % (self.name, obj2.name, obj2.name, self.ad, obj2.hp-self.ad)) class Weapen: def __init__(self, name, ad): self.name = name self.ad = ad def weapen_attack(self, p1, p2): p2.hp -= self.ad + p1.ad # 这里会受到人和枕头的伤害 print("%s利用%s攻击了%s，%s还剩%s血" % (p1.name, self.name, p2.name, p2.name, p2.hp)) p1 = Game_role("盖伦", 10, 100) p2 = Game_role("剑豪", 20, 80) # p1.attack(p2) pillow = Weapen("枕头", 2) pillow.weapen_attack(p1, p2) # 这里有个奇怪的地方，即武器是发起者，应该是人作为发起者才合理
# 为了让程序看起来合理，即要人来作为发起者，可以这样： class Game_role: def __init__(self, name, ad, hp): self.name = name self.ad = ad self.hp = hp def attack(self, obj2): print("%s攻击了%s, %s掉了%s血，还剩%s血" % (self.name, obj2.name, obj2.name, self.ad, obj2.hp-self.ad)) def equip_weapen(self, w): self.w = w # 封装属性，给一个对象封装一个属性，该属性是另一个类的对象 class Weapen: def __init__(self, name, ad): self.name = name self.ad = ad def weapen_attack(self, p1, p2): p2.hp -= self.ad + p1.ad # 这里会受到人和枕头的伤害 print("%s利用%s攻击了%s，%s还剩%s血" % (p1.name, self.name, p2.name, p2.name, p2.hp)) p1 = Game_role("盖伦", 10, 100) p2 = Game_role("剑豪", 20, 80) # p1.attack(p2) pillow = Weapen("枕头", 2) pillow.weapen_attack(p1, p2) print(p1.__dict__) # {'name': '盖伦', 'ad': 10, 'hp': 100} p1.equip_weapon(666) print(p1.w) # 666 print(p1.__dict__) # {'name': '盖伦', 'ad': 10, 'hp': 100, 'weapen': 666} # 给人物装备武器 p1.equip_weapen(pillow) # 对象p1调用类 Game_role 的方法 equip_weapen
# 而 equip_weapen 返回的是一个形参 w # p1调用它的时候，相当于给p1增加了一个属性w，而这里这个属性接收的实参是pillow
print(p1.__dict__)
# {'name': 'a', 'ad': 20, 'hp': 100, 'w': <__main__.Weapen_1 object at 0x00000166EB9D8D68>}
# 也就是说，p1.w = pillow p1.w.weapen_attack(p1, p2) # 盖伦利用枕头攻击了剑豪，剑豪还剩68血 # 这样看起来就是p1发起的攻击，这样就具备了合理性 # 组合的好处 # 1. 使代码更合理 # 2. 类与类之间的耦合性增强(耦合性也不是越强越好)
# 二. 面向对象的三大特性： # 继承 # 多态 # 封装 # 继承 # 继承是一种创建新类的方式，新建的类可以继承一个或多个父类 # 父类又称为基类或超类，新建的类称为子类或派生类 class Animal: def __init__(self, name, sex, age): self.name = name self.sex = sex self.age = age class Person: def __init__(self, name, sex, age): self.name = name self.sex = sex self.age = age class Cat: def __init__(self, name, sex, age): self.name = name self.sex = sex self.age = age class Dog: def __init__(self, name, sex, age): self.name = name self.sex = sex self.age = age # 可以看出上面每个类中有很多相同的属性
class Animal: type_name = "动物类" def __init__(self, name, sex, age): self.name = name self.sex = sex self.age = age def eat(self): print("吃东西") # Animal: 父类 # Person, Cat, Dog: 子类 class Person(Animal): # type_name = "人类" def __init__(self, name, sex, age): self.name = name self.sex = sex self.age = age class Cat(Animal): pass class Dog(Animal): pass # 子类可以调用父类的属性和方法 Person.eat(111) print(Person.type_name) # 动物类 # 如果子类中也有 type_name 这个变量，则只调用它自己的属性 print(Person.type_name) # 人类
# 对象：
# 实例化对象
p1 = Person("小春", "男", 28)
# 这里Person类并没有 __init__ 但p1会调用父类的 __init__
print(p1.__dict__) # {'name': '小春', 'sex': '男', 'age': 28}
p1.type_name = 666
# 对象不能更改的属性,所以这里其实是对象给自己封装了一个属性
print(p1) # <__main__.Person object at 0x0000025E6C038C88>
p1.eat() # 吃东西
# p1.eat() 会从 p1 的名称空间找eat(), 找不到就去类中找，再找不到就找父类...最后找不到抛出异常
# 继承又分为单继承和多继承 # 定义父类1 class Parent_Class1: pass # 定义父类2 class Parent_Class2: pass # 单继承，基类是Parent_Class1，派生类是 Sub_Class1 class Sub_Class1(Parent_Class1): pass # 多继承 class Sub_Class2(Parent_Class1, Parent_Class2): pass # 继承查看方法： # __base__只查到从左到右继承的第一个父类 print(Sub_Class1.__bases__) # <class '__main__.Parent_Class1'> print(Sub_Class2.__bases__) # (<class '__main__.Parent_Class1'>, <class '__main__.Parent_Class2'>) # 如果没有指定基类, Python的类会默认继承 object 类，object是所有类的基类，它提供了一些常见方法(如__str__)的实现 print(Parent_Class1.__bases__) # (<class 'object'>,) print(Parent_Class2.__bases__) # (<class 'object'>,)
# 继承的重要性——减少代码重用 # 单继承 # 如果一个实例化对象既要执行子类方法，又要执行父类方法 # 方法一； class Animal: type_name = "动物类" def __init__(self, name, sex, age): self.name = name self.sex = sex self.age = age def eat(self): print("吃东西") class Person(Animal): # type_name = "人类" def __init__(self, name, sex, age, mind): Animal.__init__(self, name, sex, age) self.mind = mind class Cat(Animal): def __init__(self, name, sex, age, clmib): Animal.__init__(self, name, sex, age) self.clmib = clmib class Dog(Animal): def __init__(self, name, sex, age, look): Animal.__init__(self, name, sex, age) self.look = look p1 = Person("小春", "男", 28, "有思想") print(p1.__dict__) # {'name': '小春', 'sex': '男', 'age': 28, 'mind': '有思想'} c1 = Cat("土豆", "女", 2, "爬树") print(c1.__dict__) # {'name': '土豆', 'sex': '女', 'age': 2, 'clmib': '爬树'} d1 = Dog("大嘴", "女", 3, "看门") print(d1.__dict__) # {'name': '大嘴', 'sex': '女', 'age': 3, 'look': '看门'} # 方法二：super class Animal: type_name = "动物类" def __init__(self, name, sex, age): self.name = name self.sex = sex self.age = age def eat(self): print("吃东西") class Person(Animal): # type_name = "人类" def __init__(self, name, sex, age, mind): super().__init__(name, sex, age) self.mind = mind def eat(self): # 如果都有 eat()，则要先执行父类的话，应该这样写 super().eat() print("%s 吃饭" % self.name) class Cat(Animal): def __init__(self, name, sex, age, clmib): super().__init__(name, sex, age) self.clmib = clmib class Dog(Animal): def __init__(self, name, sex, age, look): super().__init__(name, sex, age) self.look = look p1 = Person("小春", "男", 28, "有思想") print(p1.__dict__) # {'name': '小春', 'sex': '男', 'age': 28, 'mind': '有思想'} c1 = Cat("土豆", "女", 2, "爬树") print(c1.__dict__) # {'name': '土豆', 'sex': '女', 'age': 2, 'clmib': '爬树'} d1 = Dog("大嘴", "女", 3, "看门") print(d1.__dict__) # {'name': '大嘴', 'sex': '女', 'age': 3, 'look': '看门'} p1.eat() # 吃东西 # 小春 吃饭
---恢复内容结束---
