类：是一个特殊的对象，class A：定义的类属于 类对象

类的实例：obj = A()属于 实例对象

实例属性：init定义实例属性

实例方法：（self），对象名.方法名

类属性：针对类对象定义的属性，访问类属性方法：类名.类属性/对象名.类属性

类方法：针对类对象定义的方法，内部可直接访问类属性和其他类方法；类名.方法名

静态方法：不需要访问实例属性、类属性，也不用调用实例方法、类方法

私有属性：对象不希望公开的属性,访问私有属性：对象名.类名._私有属性

私有方法：对象不希望公开的方法,访问私有方法（无法直接调用）：对象名.类名._私有方法

self是类（Class）实例化对象，cls就是类（或子类）本身，取决于调用的是那个类

1.封装实例应用

需求：
房子(House) 有 户型、总面积 和 家具名称列表
新房子没有任何的家具
家具(HouseItem) 有 名字 和 占地面积，其中
席梦思(bed) 占地 4 平米
衣柜(chest) 占地 2 平米
餐桌(table) 占地 1.5 平米
将以上三件 家具 添加 到 房子 中
打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表

  1. class Game:
  2.     #   定义一个类属性
  3.     top_score = 0
  5.     def __init__(self, player_name):
  6.         """
  7.         定义一个实例属性
  8.         :param player_name:
  9.         """
  10.         self.player_name = player_name
  12.     @staticmethod
  13.     def show_help():
  14.         """定义一个静态方法"""
  15.         print("游戏帮助信息")
  17.     @classmethod
  18.     def show_top_score(cls):
  19.         """
  20.         定义一个类方法
  21.         :return:
  22.         """
  23.         print("玩家最高分为{}".format(cls.top_score))
  25.     def start_game(self):
  26.         """
  27.         定义一个实例方法
  28.         :return:
  29.         """
  30.         print("{}开始游戏了~".format(self.player_name))
  31.         Game.top_score = 999
  34. Game.show_help()  # 类名.静态方法
  35. Game.show_top_score()  # 类名.类方法
  36. game = Game("小明")  # 创建对象，实例化
  37. game.start_game()  # 对象名.方法名()--实例方法
  38. Game.show_top_score()
  39. ----------------------------------------
  40. #游戏帮助信息
  41. #玩家最高分为0
  42. #小明开始游戏了~
  43. #玩家最高分为999

需求：
士兵 许三多 有一把 AK47
士兵 可以 开火
枪 能够 发射 子弹
枪 装填 装填子弹 —— 增加子弹数量

  1. class Gun:
  2.     def __init__(self, model):
  3.         # 枪型号
  4.         self.model = model
  5.         # 子弹数量
  6.         self.bullet_count = 0
  8.     def add_bullet(self, count):
  9.         # 填充子弹
  10.         self.bullet_count += count
  12.     def shoot(self):
  13.         if self.bullet_count <= 0:
  14.             print("没有子弹，等死吧。。。")
  15.             return
  16.         # 发射子弹
  17.         self.bullet_count -= 1
  18.         print("{}剩余子弹{}".format(self.model, self.bullet_count))
  21. class Soldier:
  22.     def __init__(self, name):
  23.         self.name = name
  24.         self.gun = None
  26.     def fire(self):
  27.         if self.gun is None:
  28.             print("没有枪，不敢上")
  29.             return
  30.         print("冲啊...{}".format(self.name))
  31.         self.gun.add_bullet(30)
  32.         self.gun.shoot()
  35. ak47 = Gun('ak47')
  36. soldier = Soldier("zaygee")
  37. soldier.gun = ak47  # 把枪分配给士兵
  38. soldier.fire()
  39. -------------------------
  40. #冲啊...zaygee
  41. #ak47剩余子弹29

2.继承与多态应用实例

需求：
1.在 Dog 类中封装方法 game
普通狗只是简单的玩耍
2.定义 XiaoTianDog 继承自 Dog，并且重写 game 方法
哮天犬需要在天上玩耍
3.定义 Person 类，并且封装一个 和狗玩 的方法
在方法内部，直接让 狗对象 调用 game 方法

  1. class Dog:
  2.     def __init__(self, name):
  3.         self.name = name
  5.     def game(self):
  6.         print("{}在街上溜达".format(self.name))
  9. class XiaoTianDog(Dog):
  10.     def game(self):
  11.         print("{}在天上飞".format(self.name))
  14. class Person:
  15.     def __init__(self, name):
  16.         self.name = name
  18.     def play_with_dog(self, dog):
  19.         print("{}和{}在快乐的玩耍".format(self.name, dog.name))
  20.         dog.game()
  23. wangcai = XiaoTianDog("哮天犬")  # 创建一个狗对象
  24. zaygee = Person("zaygee")  # 创建一个人对象
  25. zaygee.play_with_dog(wangcai)  # 人遛狗
  26. --------------------------
  27. #zaygee和哮天犬在快乐的玩耍
  28. #哮天犬在天上飞

3.私有属性&私有方法

  1. class Man:
  2.     def __init__(self, name):
  3.         self.name = name
  4.         self.__age = 18
  6.     def __secret(self):
  7.         return "我的年龄是{}".format(self.__age)
  10. zaygee = Man("zaygee")
  11. print(zaygee.name)
  12. #   访问私有属性：对象名._类名.__私有属性
  13. print(zaygee._Man__age)
  14. #   访问私有方法（无法直接调用）：对象名._类名.__私有方法
  15. print(zaygee._Man__secret())
  16. --------------------------
  17. #zaygee
  18. #18
  19. #我的年龄是18

4.super()方法

super函数是用于调用父类(超类)的一个方法
语法：

  1. super.xxx 或者 super(class, self).xxx
  1. class Base(object):
  2.     def __init__(self):
  3.         print("enter Base")
  4.         print("leave Base")
  7. class A(Base):
  8.     def __init__(self):
  9.         print("enter A")
  10.         # super(A, self).__init__() 首先找到A的父类Base，然后把类A的对象转化为类Base的对象
  11.         super(A, self).__init__()
  12.         print("leave A")
  15. class B(Base):
  16.     def __init__(self):
  17.         print("enter B")
  18.         super(B, self).__init__()
  19.         print("leave B")
  22. class C(A, B):
  23.     def __init__(self, name):
  24.         self.name = name
  25.         print("enter C")
  26.         super(C, self).__init__()
  27.         print("leave C")
  29.     def __str__(self):
  30.         return "我叫{}".format(self.name)
  32.     def __call__(self, *args, **kwargs):
  33.         print("我是call方法")
  36. c = C('zaygee')
  37. print(c)
  38. c()
  39. -----------------------------------------
  40. #enter C
  41. #enter A
  42. #enter B
  43. #enter Base
  44. #leave Base
  45. #leave B
  46. #leave A
  47. #leave C
  48. #我叫zaygee
  49. #我是call方法

5.mro()方法

mro(): 遍历类的所有基类，并将它们按优先级从高到低排序

  1. # [<class 'Exception'>, <class 'BaseException'>, <class 'object'>]
  2. print(Exception.mro())