python_06 类的继承、多态、异常

56、继承

# 继承：实现代码的重用，相同的代码不需要重复的编写

class Animal:
    def sleep(self):
        print("睡觉")
    def eat(self):
        print("吃饭")

# 定义了一个dog类，让它继承自Animal类，dog就拥有了，动物类Animal 的所有的属性和方法
class Dog(Animal):
    def chi_shi(self):
        print("吃shi")


class Fish(Animal):
    def swim(self):
        print("游泳")

dog1 = Dog()
dog1.chi_shi()
dog1.eat()
dog1.sleep()

# 鱼类和狗类没有直接关系，无法使用狗类里面的方法 但可以使用Animal中的属性和方法
fish1 = Fish()
fish1.swim()
fish1.eat()

57、继承的传递性

class Animal:
    def sleep(self):
        print("睡觉")
    def eat(self):
        print("吃饭")

class Dog(Animal):
    def jiao(self):
        print("汪汪~~~")

class ErHa(Dog):
    def char_jia(self):
        print("拆家")

erha1 = ErHa()
erha1.eat()     # 继承是有传递性的，二哈继承自狗，狗又继承自动物，二哈也有动物类的属性和方法
erha1.sleep()
erha1.jiao()
erha1.char_jia()

58、继承的覆盖性

class Animal:
    def sleep(self):
        print("睡觉")
    def eat(self):
        print("吃饭")

# 子类继承自父类，相同的函数名，会被覆盖
class Dog(Animal):
    def eat(self):
        print("吃骨头")

dog1 = Dog()
dog1.eat()

59、继承的扩展性

class Animal:
    def sleep(self):
        print("睡觉")
    def eat(self):
        print("吃饭")

# 子类继承自父类，相同的函数名，会被覆盖
class Dog(Animal):
    def eat(self):
        super().eat()   # 给父类的同名函数eat进行了扩展、追加
        print("吃骨头")


dog1 = Dog()
dog1.eat()      # 打印了父类和子类的eat方法

60、继承和父类的私有属性和私有方法

class Animal(object):  # object,是基类，就算什么都不需要继承，也要写上
    def sleep(self):
        print("睡觉")
        self.__eat()    # 自己可以调用自己的私有内容
    def __eat(self):    # 私有的方法
        print("吃饭")

# 子类继承自父类，相同的函数名，会被覆盖
class Dog(Animal):
    def eat(self):
       pass

dog1 = Dog()
# dog1.__eat()   # 哪怕继承了父类，也无法使用父类中的私有属性和私有方法
dog1.sleep()     # 可以通过 父类的公有函数 调用 父类的私有内容，然后子类再调用 父类的这个公有函数 即可获得 父类的私有内容

61、多态

# 不同的子类对象调用相同的父类方法，产生不同的执行结果
# 多态可以增加代码的灵活度

class Dog(object):  # 不继承任何类，也要写object基类，为了让代码兼容性更好
    def __init__(self,name):
        self.name = name

    def game(self):
        print(f"{self.name}傻玩")

class XiaoTianQuan(object):
    def __init__(self,name):
        self.name = name
    def game(self):
        print(f"{self.name}飞天玩")

class maxi_dog(object):
    def __init__(self,name):
        self.name = name
    def game(self):
        print(f"{self.name}踩钢丝玩")

class Person(object):
    def __init__(self,name):
        self.name = name
    def game_with_dog(self,dog):
        print(f"{self.name}和{dog.name}")
        dog.game()


dog1 = Dog("大白")
xtq = XiaoTianQuan("哮天犬")
xtq.game()
hong = Person("红红")
maxi = maxi_dog("马戏")
hong.game_with_dog(dog1)  # 传入的参数是一个实例化的对象 dog1
hong.game_with_dog(xtq)
hong.game_with_dog(maxi)

62、类属性

class Wolf(object):
    # 没有写在__init__中的，而是直接写在类中的属性，叫做类属性，记录的东西是属于整个类的特征，而不是具体实例化对象的特征
    area = "大草原"   # Wolf类的特征，而不是某个对象的属性
    def __init__(self,name):
        self.name = name   # 普通的属性 某个实例化对象的属性
#
lang1 = Wolf("小白")
# print(lang1.name)   # 普通属性
# print(lang1.area)   # 类属性，是类独有有的
#
lang2 = Wolf("小灰")
# print(lang2.name)
# print(lang2.area)
#
# # 普通属性更改，只影响这个类实例化出来的对象
# lang1.name = "哈哈哈"  # 获取普通属性，进行更改  普通属性跟着实例化对象走的，和lang2无关
# print(lang1.name)

# 给lang1新赋值了一个area属性，设置为了 大山  和 lang2 无光，lang2依然是大草原
lang1.area = "大山"   
print(lang1.area)

# lang2 是根据狼对象实例化出来的，area类属性并没有被改变，所以还是打印大草原
print(lang2.area)   

# 类名.属性名   就是在修改类属性的值，一旦类属性被修改，后续实例化出来的对象，这个属性值就都被改了
Wolf.area = "北极"    
print(lang1.area)
print(lang2.area)

63、类方法

class Wolf(object):
    area = "大草原"
    def __init__(self):
        self.age = 18
    def demo(self):
        print("哈哈")

    @classmethod    # 装饰器 告诉程序，后面紧接着的一个函数，属于 类函数
    def set_area(cls,area):  # 类函数 中小括号变为cls, cls代表这个类 相当于 self
        cls.area = area     # 在类方法内部 获取类属性的值，进行修改
        # cls.demo()    # 类方法中无法使用普通方法！！！
        print("---------")


print(Wolf.area)    # 打印出大草原（类属性的值）
Wolf.area = "大山"
print(Wolf.area)

Wolf.set_area("雪地") # 类方法、类函数，直接使用 类名.类函数名() 就可以实现调用，没必要实例化在运行
print(Wolf.area)

lang1 = Wolf()
print(lang1.age)
lang1.set_area("北极")
print(lang1.area)

64、静态方法

class Cat(object):
    @staticmethod       # 装饰器  下面的方法是静态方法、静态函数
    def help():         # （）里面不需要任何参数，什么都不写（self、cls）
        print("这是一个小猫咪")
Cat.help()

65、利用类属性，记录实例化次数

class Tool(object):
    count = 0   # 类属性，用做记录初始化次数（实例化次数） 是类的特性，而不是实例化的对象的特性

    def __init__(self,name):
        self.name = name
        Tool.count += 1     # count 不是普通变量，必须  类名.count  每次实例化的时候，count自增


print(Tool.count)

tool1 = Tool("剪刀")
tool2 = Tool("螺丝刀")
print(Tool.count)


print("---")


class Tool2(object):
    count = 0   # 类属性
    def __init__(self,name):
        self.name = name
        Tool2.count += 1

tool3 = Tool2("电钻")     # 实例化一个对象，并传参
tool4 = Tool2("锤子")
print(Tool2.count)

66、类的综合案例

class Game(object):
    # 有最高分属性，类属性
    top_score = 0   # 最开始每人玩，默认最高分为0

    @staticmethod   # 静态方法 提示性信息  与其他无关的 无需实例化 类名.静态函数 即可调用
    def show_help():
        print("提示信息：使用植物阻挡僵尸的进攻")

    # 需要展示最高分（类方法）
    @classmethod   # 类方法 也无需实例化  类名.类方法  即可调用
    def show_top_score(cls):
        # cls就是这个类Game
        print(f"当前最高分为{cls.top_score}")

    # 初始化时记录玩家姓名
    def __init__(self,name):
        self.name = name

    # 玩游戏的方法，设置最终得分（普通方法/普通函数）
    def start_game(self,score):
        print(f"{self.name}开始游戏了，最终得分是{score}")
        # 玩游戏后的分数如果大于最高分，当前分数就是最高分
        if score > Game.top_score:
            Game.top_score = score

# 1.查看你这个游戏怎么玩
Game.show_help()

# 2.查看当前最高分
print(Game.top_score)

# 3.实例化玩家
player1 = Game("小张") 
player1.start_game(98)
print(Game.top_score)

player2 = Game("小王")
player2.start_game(998)
print(Game.top_score)
Game.show_top_score()

67、异常处理

# 就把 try except 当成 if else 来使用

try: # 把有可能出问题的代码，放在try中
    num1 = int(input("请输入一个数字："))
except: # 当try中的代码出现异常，才会执行下列代码
    print("请输入数字才可以哟~~~")

# a = int(input("请输入数字1："))
# b = int(input("请输入数字2："))
# print(a / b)



try:
    a = int(input("请输入数字1："))
    b = int(input("请输入数字2："))
    print(a/b)
# 根据异常的类型，来提示对应的文字 （先故意试错，看看是什么错误）
# except ValueError:
#     print("请输入数字")
# except ZeroDivisionError:
#     print("除数不能为 0 哟")

# 不用像上述代码，把错误区分的那么清楚，直接打印报错信息，把报错信息都保存在res中
except Exception as res:    # 未知错误，直接写成这样   as是起别名   别名叫res  只把报错信息原样打出
    print(f"报错的信息是：{res}")
else:   # 程序无异常，才会执行这里的代码，否则这里的代码就不会执行
    print("程序没问题")

finally:    # 无论程序是否有异常，都会执行这里的代码
    print("无论如何我都会运行呀~~~")


# 练习：
try:
    a = int(input("请输入第一个数字a = : "))
    b = int(input("请输入第二个数字b = : "))
    print(a/b)
except Exception as res:
    print(f"报错的信息是:{res}")
else:
    print("---程序没有问题---")
finally:
    print("---无论程序是否异常，都会执行这里的代码---")

68、异常的传递

# 当方法执行出现异常，会将异常传递给调用一方，如果传递到主程序，仍然没有
# 异常处理，程序才会被终止
# 在开发中，可以在主函数（入口）中增加异常捕获，只要出现异常，都会传递到主函数的异常捕获中，
# 这样就不需要再代码中，增加大量的异常捕获，能够保证代码的整洁
def a():
    return int(input("请输入数字："))

def b():
    return a()

try:
    print(b())   # 就算a()里有一万个input(),这里也只需写一个b()即可 这样try中就不用写很多input(),保持整洁
except Exception as hehe:
    print(f"报错信息是:{hehe}")

69、主动抛出异常

# 请输入8个字以上的密码  不满足条件  就抛出异常
#
# 在开发中d
def input_pwd():
    pwd = input("请输入8个字以上的密码: ")
    if len(pwd) > 8:    # 判断长度是否大于8
        return pwd
    else:
        # 不符合我的业务需求，我要主动的抛出异常
        res = Exception("您输入的内容不够8个")
        raise res   # 抛出我刚刚写的异常报错信息

try:
    user_pwd = input_pwd()
    print(user_pwd)
except Exception as haha:       # 得到上面raise 的异常信息，保存到haha变量中
    print(f"自己写的报错信息是:{haha}")

70、

def sum(a,b):
    print(a + b)
def max(a,b):
    if a > b:
        print(a)
    else:
        print(b)

71、

import py70 as p70  # 导入py70文件并起别名叫p70  as 起别名

# 别名.sum  要用的函数属于py70里面的
# 如果起别名，就用别名，否则就用原名
p70.sum(1,3)

p70.max(6,9)