特征 = 属性 行为 = 方法
class 类名:
def 方法名(self[, 参数列表]):
pass
对象名 = 类名()对象 = 实例 创建对象 = 实例化对象
class Washer:
def wash(self):
print(self)
print("洗衣服")
haier = Washer()
print(haier)
haier.wash()
"""
<__main__.Washer object at 0x00000202A0817430>
<__main__.Washer object at 0x00000202A0817430>
洗衣服
"""
对象名.属性名 = 值
self.属性名 = 值
对象名.属性名
self.属性名
# 定义类
class Washer:
def print_info(self):
# 类⾥⾯获取实例属性
print(f"{self.name}洗⾐机的宽度是{self.width}")
print(f"{self.name}洗⾐机的⾼度是{self.height}")
# 创建对象
haier = Washer()
# 添加实例属性
haier.name = "海尔"
haier.width = 500
haier.height = 800
# 调用实例方法
haier.print_info()
__init__：初始化对象类名()创建对象时，为对象分配完空间后，自动调用__init__方法；__str__ ：输出对象信息__str__⽅法，则会打印从该方法中return的数据；__del__ ：删除对象时调用__del__方法；class Washer:
def __init__(self, name):
self.name = name
print(f"{self.name}洗⾐机来了")
def __str__(self):
return f"---{self.name}洗衣机---"
def __del__(self):
print(f"{self.name}洗⾐机去了")
haier = Washer("海尔")
print(haier)
# 删除一个对象
del haier
print("---我在哪执行？---")
"""
海尔洗⾐机来了
---海尔洗衣机---
海尔洗⾐机去了
---我在哪执行？---
"""
类名()创建，生命周期开始__del__方法一旦被调用，生命周期结束两个下划线，私有属性和私有方法不能在外界直接访问；伪私有；_类名 => _类名__名称，使得外界无法访问到；对象名._类名__属性名/方法名，访问对象的私有属性或私有方法；class Women:
def __init__(self, name):
self.name = name
self.__age = 18
def __secret(self):
# 在对象的方法内部，是可以访问对象的私有属性的
print("%s 的年龄是 %d" % (self.name, self.__age))
xiaofang = Women("小芳")
# 私有属性，外部不能直接访问
print(xiaofang.__age)
# 私有方法，外部不能直接调用
xiaofang.__secret()
#
# 伪私有属性
print(xiaofang._Women__age)
# 伪私有方法
xiaofang._Women__secret()
封装根据职责将属性和方法封装到一个抽象的类中继承实现代码的重用，相同的代码不需要重复的编写多态不同的对象调用相同的方法，产生不同的执行结果需求分析：
1、房子（House）有 户型、总面积 和 家具名称列表：新房子没有任何的家具
2、家具（HouseItem）有 名称 和 占地面积，其中：
① 席梦思（bed）占地 4 平米，② 衣柜（chest）占地 2 平米，③ 餐桌（table）占地 1.5 平米
3、将以上三件家具 添加 到 房子 中
4、打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表
代码实现：
# 1、创建家具类（HouseItem）
class HouseItem:
def __init__(self, name, area):
# 家具名称
self.name = name
# 家具占地面积
self.area = area
def __str__(self):
return "【%s 占地 %.2f】" % (self.name, self.area)
# 2、创建房子类（House）
class House:
def __init__(self, house_type, area):
# 房子户型
self.house_type = house_type
# 房子总面积
self.area = area
# 房子剩余面积
self.free_area = area
# 家具名称列表
self.item_list = []
def __str__(self):
return ("户型：%s\t总面积：%.2f\n剩余面积：%.2f\t家具：%s"
% (self.house_type, self.area,
self.free_area, self.item_list))
def add_item(self, item):
print("准备添加 %s" % item)
# ①判断家具的面积
if item.area <= self.free_area:
# ②将家具的名称添加到列表中
self.item_list.append(item.name)
print(f"{item.name}已经成功摆放到房子中了")
# ③计算剩余面积
self.free_area -= item.area
else:
print(f"{item.name}面积太大，剩余面积不足，无法容纳")
# 3、创建对象
bed = HouseItem("席梦思", 40)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 20)
my_home = House("两室一厅", 60)
# 4、调用实例方法
print(my_home)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)
运行结果：
户型：两室一厅 总面积：60.00
剩余面积：60.00 家具：[]
准备添加 【席梦思 占地 40.00】
席梦思已经成功摆放到房子中了
准备添加 【衣柜 占地 2.00】
衣柜已经成功摆放到房子中了
准备添加 【餐桌 占地 20.00】
餐桌面积太大，剩余面积不足，无法容纳
户型：两室一厅 总面积：60.00
剩余面积：18.00 家具：['席梦思', '衣柜']
子类拥有父类的所有方法和属性
class 子类名(父类名):
pass
子类拥有父类的所有方法和属性
子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
Dog类 是 Animal类 的子类，Animal类 是 Dog类 的父类，Dog类 从 Animal类继承
Dog类 是 Animal类 的派生类，Animal类 是 Dog类 的基类，Dog类 从 Animal类派生
当父类的方法实现不能满足子类需求时，可对方法进行
重写
重写父类方法有两种情况：
super().父类方法来调用父类方法的执行，在其他的位置针对子类的需求，编写子类特有的代码实现；
B 的对象不能直接访问 __num2 属性
B 的对象不能在 demo 方法内访问 __num2 属性
B 的对象可以在 demo 方法内，调用父类的 test 方法
父类的 test 方法内部，能够访问 __num2 属性和 __test 方法
子类拥有多个父类且具有所有父类的属性和方法
class 子类名(父类名1, 父类名2):
pass
使用多继承时若不同父类中存在同名的方法，子类对象在调用方法时，会调用哪一个父类中的方法呢？
MRO方法搜索顺序 主要用于在多继承时判断方法、属性的调用路径
Python中针对类提供了一个内置属性__mro__可以查看方法搜索顺序；在搜索方法时，是按照__mro__的输出结果从左至右的顺序查找的；如果在当前类中找到方法，就直接执行不再搜索；如果没有找到，就查找下一个类中是否有，找到就直接执行不再搜索；如果找到最后一个类，还没有找到方法，程序报错；
注意：如果父类之间存在同名的属性或者方法，应该尽量避免使用多继承！
object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看；新式类：以object为基类的类，推荐使用；经典类：不以object为基类的类，不推荐使用；Python 3.x中定义类时，如果没有指定父类，会默认使用object作为该类的基类；Python 2.x中定义类时，如果没有指定父类，则不会以object作为该类的基类；object；不同的子类对象调用相同的父类方法，产生不同的执行结果
以继承和重写父类方法为前提需求分析：
1、在Dog类中封装game方法，普通狗只是简单的玩耍
2、定义XiaoTianDog类继承自Dog类，并重写game方法，哮天犬需要在天上玩耍
3、定义Person类，并封装一个和狗玩的方法game_with_dog
在game_with_dog方法内部，直接让狗对象调用game方法
Person类中只需要让狗对象调用game方法，而不关心具体是什么狗
game方法是在Dog父类中定义的
在程序执行时，传入不同的狗对象实参，就会产生不同的执行效果
代码实现：
class Dog(object):
def __init__(self, name):
self.name = name
def game(self):
print("%s 蹦蹦跳跳的玩耍" % self.name)
class XiaoTianDog(Dog):
def game(self):
print("%s 飞到天上去玩耍" % self.name)
class Person(object):
def __init__(self, name):
self.name = name
def game_with_dog(self, dog):
print("%s 和 %s 一起快乐的玩耍" % (self.name, dog.name))
dog.game()
erha = XiaoTianDog("飞天二哈")
xiaoming = Person("小明")
xiaoming.game_with_dog(erha)
'''
小明 和 飞天二哈 一起快乐的玩耍
飞天二哈 飞到天上去玩耍
'''
类名()__init__方法为对象初始化实例创建出来的对象 = 类的实例创建对象的动作 = 实例化对象的属性 = 实例属性对象调用的方法 = 实例方法
在程序执行时，通过self.访问自己的属性或调用自己的方法
每一个对象都有自己独立的内存空间，保存各自不同的属性
多个对象的方法在内存中只有一份，在调用方法时，需将对象的引用传递到方法内部
class 类名: 定义的类属于类对象
对象名 = 类名() 创建的对象属于实例对象
在程序运行时，通过类名.访问类的属性或调用类的方法
类对象在内存中只有一份，使用一个类可以创建出很多个对象实例
除了封装实例的属性和方法外，类对象也可以拥有自己的属性和方法
class下方使用赋值语句定义；类名.类属性 和 对象名.类属性（不推荐）对象.类属性 = 值 设置值，只会给对象添加一个属性，而不会影响到类属性的值；@classmethod来标识；cls就是哪一个类的引用；类名.调用类方法，调用方法时，不需要传递cls参数；cls.访问类属性或调用其他的类方法；@classmethod
def 类方法名(cls):
pass
@staticmethod 来标识类名.调用静态方法@staticmethod
def 静态方法名():
pass
需求分析：
1.设计一个Game类
2.属性：
① 类属性 top_score 记录游戏的历史最高分，② 实例属性 player_name 记录当前游戏的玩家姓名
3.方法：
① 静态方法 show_help 显示游戏帮助信息，② 类方法 show_top_score 显示历史最高分，③ 实例方法 start_game 开始当前玩家的游戏
4.主程序步骤
① 查看帮助信息，② 查看历史最高分，③ 创建游戏对象，开始游戏
代码实现：
class Game(object):
# 游戏最高分，类属性
top_score = 0
@staticmethod
def show_help():
print("帮助信息：让僵尸走进房间")
@classmethod
def show_top_score(cls):
print("游戏最高分是 %d" % cls.top_score)
def __init__(self, player_name):
self.player_name = player_name
def start_game(self):
print("[%s] 开始游戏..." % self.player_name)
# 使用类名.修改历史最高分
Game.top_score = 999
# 1. 查看游戏帮助
Game.show_help()
# 2. 查看游戏最高分
Game.show_top_score()
# 3. 创建游戏对象，开始游戏
game = Game("小明")
game.start_game()
# 4. 游戏结束，查看游戏最高分
Game.show_top_score()