【Python基础】第十六篇 | 面向对象之高级篇

继承

1.继承描述的是类与类之间的关系
2.继承的好处：减少代码的冗余(相同的代码不需要多次重复书写)，可以直接使用

语法：

class A():# 没有写父类，但也有父类，object,，object类是python中最顶级(原始)的类pass
class B(A): #类B，继承类Apass

1.A 类，称之为父类(基类)
2.B 类，称之为子类(派生类)
单继承：一个类只继承一个父类，称为单继承
继承之后的特点：
> 子类(B)继承父类(A)之后，子类的对象可以直接使用父类中定义的公有属性和方法。
案例：
1.定义一个动物类，吃
2.定义一个狗类，继承动物类，吃，叫
3.定义一个哮天犬类，继承狗类

class Animal:def eat(self):print("要吃东西")class Gog(Animal):def bark(self):print("汪汪汪")class XTQ(Gog):pass# 创建 动物类的对象
# ani = Animal()
# ani.eat()
# 创建狗类对象
dog = Dog()
dog.eat() # 调用父类中的方法
dog.bark() # 调用自己类中的方法
# xtq = XTQ()
xtq.bark() # 调用父类Dog类的方法
xtq.eat() # 可以条用父类的父类中的方法

结论
Python中对象.方法() 调用方法
1.先在自己的类中去找有没有这个方法，如果有直接调用
2.如果没有去父类中查询，如果有直接调用
3.如果没有去父类的父类中查找，如果有直接调用
4…
5.如果object类中有，直接调用，如果没有，代码报错

重写

重写：在子类中定义和父类中名字相同的方法，就是重写
重写的原因：父类中的方法，不能满足子类对象的需求，所以重写
重写之后的特点：调用子类字节的方法，不再调用弗雷中的方法
重写的方式：
1.覆盖(父类中功能完全抛弃，不用，重新书写)
2.扩展(父类中功能还调用，知识调价一些新的功能)(使用较多)

覆盖

1.直接在子类中定义和父类中名字相同的方法
2.直接在方法中书写新的代码

class  Dog:def bark(self):print('汪汪叫....')
class XTQ(Dog):# XTQ 类 bark方法不再汪汪汪叫，改为嗷嗷叫def bark(self):print('嗷嗷叫...')
xtq =XTQ()
xtq.bark()

扩展父类中的功能

1.直接在子类中，定义和弗雷中名字相同的方法
2.在合适的地方调用父类中方法super().方法()
3.书写添加新功能

class  Dog:def bark(self):print('汪汪叫....')
class XTQ(Dog):# XTQ 类 bark方法不再汪汪汪叫# 1. 先嗷嗷叫(新功能)# 2. 汪汪叫(父类中功能)# 3. 嗷嗷叫(新功能)def bark(self):print('嗷嗷叫...')super().bark()print('嗷嗷叫...')
xtq = XTQ()
xtq.bark()

多态

1.是一种写代码，调用的一种技巧
2.同一个方法，传入不同的对象，执行得到不同的结果，这种现象称为是多态
3.多态可以增加代码的灵活读
哪个对象调用方法，就去自己的类中去查找这个方法，找不到去父类中找

属性和方法

python中一切且对象，即使用class定义的类也是一个对象

对象的划分：

实例对象(实例)

1.通过类名() 创建的对象，我们称为实例对象，简称实例
2.创建对象的过程称为是类的实例化
3.我们平时所说的对象就是指实例对象(实例)
4.每个实例对象，都有自己的内存空间，在自己的内存空间中保存自己的属性(实例属性)

类对象(类)
类对象就是类，货值可以认为是类名
类对象是Python解释器在执行代码的过程中创建的
3.类对象的作用： > 使用类对象创建实例类名()
> 类对象也有自己的内存空间，可以保存一些属性值信息(类属性)
4.在一个代码中，一个类只有一份内存空间

属性的划分

实例属性：

概念：是实例对象具有的属性
定义和使用
在init方法中，使用self.属性名 = 属性值 (定义)
在方法中是使用self.属性名类获取(调用)
内存
实例属性，在每个实例中，都存在一份
使用时机
1.基本上99% 都是实例属性，即通过self去定义
2.找多个对象，老判断这个值是不是一样的，如果都是一样的，同时变化，则一般定义为类属性，否则定义为实例属性
类属性：

概念：是类对象具有的属性
在类内部，方法外部，直接定义的变量，就是类属性
使用：类对象.属性名= 属性值或类名.属性名=属性值
类对象.属性名 or 类名.属性名
内存：
只有类对象中存在一份

案例：
定义一个Dog类，定义一个类属性count，用来记录创建改类对象的个数，(即每创建一个对象，count的值就要加1)实例属性name

class Dog:# 定义类属性count = 0# 定义实例属性，init方法中def __init__(self,name):self.name = name #实例属性# 因为没创建一个对象，就会调用init方法，就将个数加1的操作，卸载init方法中Dog.count += 1
# 在类外部
# 打印输出目前创建几个对象
print(Dog.count) #0
# 创建一个对象
dog1 = Dog("小狗")
# 打印输出目前创建几个对象
print(Dog.count)
dog2=Dog # 不是创建对象，个数不变的
dog3= dog1 # 不是创建对象，个数不变的
print(Dog.count) #1
dog4 =Dog('大黄') # 创建一个对象，个数+1
print(Dog.count) #2
dog5 = Dog('大白')
print(Dog.count) # 3# 补充，可以使用实例对象，类属性名，来获取类属性的值
# 没有找到会去类属性中找，找到了可以使用，没有找到报错
print(dog1.count)
print(dog4.count)
print(dog5.count)

方法的划分

方法，使用def关键字定义在雷总的函数就是方法

实例方法(最常用)

定义：在雷总直接定义的方法，就是实例方法

class Demo:def func(self): # 参数一般写作self，表示的是实例对象pass

定义时机(什么时候用)
如果在方法中需要使用实例属性(即需要使用slef)，则这个方法必须定义为实例方法
调用：

对象.方法名() # 不需要给self传参

类方法(会用)

定义：在方法名字的上方书写@classmethod装饰器(使用 @classmethod装饰的方法)

class Demo:@classmethoddef func(cls): # 参数一般写作cls，表示的是类对象(即类名) classpass

定义时机(什么时候用)
1.前提，方法中不需要使用实例属性(即self)
2.用到了类属性，可以将这个方法定义为类方法，也可以定义为实例方法
调用
1.通过类对象调用
类名.方法名() # 也不需要给cls传参，python解释器自动传递
2.通过实例对象调用
实例.方法名() # 也不需要给cls传参，python解释器自动传递

静态方法(基本不用)

定义：在方法名字的上方书写@staticmethod装饰器(使用@staticmethod装饰的方法)

class Demo:@staticmethoddef func():pass

定义时间(什么时候用)
1.前提，方法中不需要使用实例属性(即self)
2.也不使用类属性，可以将这个方法定义为静态方法

调用
1.通过类对象调用

类名.方法名()

2.通过实例对象调用

实例.方法名()

案例
定义一个游戏里Game，包含实例属性玩家名字(name)
1.要求记录邮寄的最高分(top_score类属性)
2.定义方法：show_help 显示游戏的帮助信息,输出"这是游戏的帮助信息"
3.定义方法：show_top_score，打印输出游戏最高分
4.定义方法：start_game，开始游戏，规则如下
1.使用水机数获取本次游戏得分范围(10-100)之间
2.判断本次得分和最高分之间的关系
如果本次得分比最高分高
修改最高分
如果分数小于等于最高分，则不操作
3.输出本次游戏得分
3.主程序步骤
1).创建一个Game对象，小王
2).小碗玩一次游戏
3).查看历史最高分
4).小王再完一次游戏
5).查看历史最高分
6).查看游戏的帮助信息

import random
class Game:# 类属性，游戏的最高分top_score =0def __init__(self,name) :# 定义实例属性 nameself.name=name@staticmethoddef show_help():print("这是游戏的帮助信息")@classmethoddef show_top_score(cls):print(f"游戏的最高分 {cls.top_score}")def start_game(self):print(f'{self.name}开始一局游戏，游戏中...',end='')tmp_score = random.randint(10,100)print(f"本次游戏得分{tmp_score}")if tmp_score >Game.top_score:Game.top_score = tmp_scorexw = Game("小王")
xw.start_game()
xw.show_top_score()
xw.start_game()
xw.show_top_score()
xw.show_help()

补充
哈希(hash)：是一个算法，可以对数据产生一个唯一的值(指纹)
is 可以用来判断两个对象是不是同一个对象，即两个对象的引用是否相等
a is b ===> id(a)==id(b)

a = [1,2,3]
b = [1,2,3]
a == b #True
a is b #False