day24——面向对象三大特性、鸭子类型、类的约束、super的深度解析

day24

面向对象的三大特性

继承、封装、多态

封装：把一堆东西（代码，数据）放到一个地方（空间），并且可以使用

class Student:
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
liye = Student("李业", "laddy_boy")
print(liye.sex)

多态：一个事物可以呈现多种形态

水：固态、液态、气态

python默认支持多态，比如变量可以是不同类型，函数的参数也可以传多种类型

鸭子类型

python崇尚鸭子类型（编程思路）看起来像鸭子，它就是鸭子

# class A:
#
#     def login(self):
#         print('登录')
#
#     def register(self):
#         print('注册')
#
#     def func1(self):
#         pass
#
#     def func2(self):
#         pass
#
#
# class B:
#
#     def login(self):
#         print('登录')
#
#     def register(self):
#         print('注册')
#
#     def func3(self):
#         pass

# A B互为鸭子.
# 赵嘎:  1. 好记.
# 虽然A,B两个类没有关系,但是我统一两个类中相似方法的方法名,在某种意义上统一的标准.

# index ,index, index,

类的约束

版本1
# class QQpay:
#     def pay(self, money):
#         print(f"使用qq支付了{money}")
#
#
# class Alipay:
#     def pay(self, money):
#         print(f"使用阿里支付了{money}")
#
#
# obj1 = QQpay()
# obj1.pay(100)
#
# obj2 = Alipay()
# obj2.pay(200)

版本2：要做到统一接口
# class QQpay:
#     def pay(self, money):
#         print(f"使用qq支付了{money}")
#
#
# class Alipay:
#     def pay(self, money):
#         print(f"使用阿里支付了{money}")
#
#
# def pay(obj, money):
#     obj.pay(money)
#
#
# obj1 = QQpay()
# obj2 = Alipay()
#
# pay(obj1, 100)
# pay(obj2, 200)

版本3： 完善支付功能
# class QQpay:
#     def pay(self, money):
#         print(f"使用qq支付了{money}")
#
#
# class Alipay:
#     def pay(self,money):
#         print(f"使用阿里支付了{money}")
#
#
# class Wechat:
#     def fuqian(self, money):
#         print(f"使用微信支付了{money}")
#
#
# def pay(obj, money):
#     obj.pay(money)
#
#
# obj1 = QQpay()
# obj2 = Alipay()
#
# pay(obj1, 100)
# pay(obj2, 200)
#
# obj3 = Wechat()
# obj3.fuqian(300)

版本4：定制约束，约定俗称，没有做到完全强制
# class Payment:
#     def pay(self, money):
#         pass
#
#
# class QQpay(Payment):
#     def pay(self, money):
#         print(f"使用qq支付了{money}")
#
#
# class Alipay(Payment):
#     def pay(self, money):
#         print(f"使用阿里支付了{money}")
#
#
# class Wechat(Payment):
#     def fuqian(self, money):
#         print(f"使用微信支付了{money}")
#
#
# def pay(obj, money):
#     obj.pay(money)
#
# obj1 = QQpay()
# obj2 = Alipay()
# obj3 = Wechat()
#
# pay(obj1, 100)
# pay(obj2, 200)
# pay(obj3, 300)

版本5：做到强制约束
# 方法一：python语言惯于使用的一种约束方法，在父类主动抛出错误
# 方法二：借鉴于java语言，定义抽象类的概念，做到真正的强制约束

# 方法一
# 前提，你的项目已经上线了，之前完成的QQpay，Alipay 以及 pay函数这个接口都成型
# 如果此时新添加一个微信支付，其他的py文件引用支付功能时还是直接引用pay

# class Payment:
#     def pay(self, money):
#         raise Exception("你的子类需要定义pay方法")
#
#
# class QQpay(Payment):
#     def pay(self, money):
#         print(f"使用qq支付了{money}")
#
#
# class Alipay(Payment):
#     def pay(self, money):
#         print(f"使用阿里支付了{money}")
#
#
# class Wechat(Payment):
#     def fuqian(self, money):
#         print(f"使用微信支付了{money}")
#
#     # def pay(self, money):
#     #     print(f"使用微信支付了{money}")
#
# def pay(self, money):
#     self.pay(money)
#
# qq = QQpay()
# aa = Alipay()
# ww = Wechat()
#
# pay(qq, 100)
# pay(aa, 100)
# pay(ww, 100)

# 方法二
# from abc import ABCMeta,abstractclassmethod
#
#
# class Payment(metaclass=ABCMeta):
#     # def pay(self, money):
#     #     raise Exception("出错")
#
#     @abstractclassmethod
#     def pay(self, money):
#         pass
#
#
# class QQpay(Payment):
#     def pay(self, money):
#         print(f"使用qq支付了{money}")
#
#
# class Alipay(Payment):
#     def pay(self, money):
#         print(f"使用阿里支付了{money}")
#
#
# class Wechat(Payment):
#     def fuqian(self, money):
#         print(f"使用微信支付了{money}")
#
#     # def pay(self, money):
#     #     print(f"使用微信支付了{money}")
#
#
# def pay(self, money):
#     self.pay(money)
#
#
# qq = QQpay()
# aa = Alipay()
# ww = Wechat()
#
# pay(qq, 100)
# pay(aa, 100)
# pay(ww, 100)

super的深度剖析

super（类,self）严格按照对象从属于类的mro的顺序，执行下一个类

题一
# class A:
#     def f1(self):
#         print("in A f1")
#
#     def f2(self):
#         print("in A f2")
#
#
# class Foo(A):
#     def f1(self):
#         # 按照self对象从属于类的mro的顺序，执行Foo类的下一个类
#         super(Foo, self).f2()
#         print("in A Foo")
#
#
# obj = Foo()
# obj.f1()
# in A f2
# in A Foo

题二
# class A:
#     def f1(self):
#         print("in A")
#
# class Foo(A):
#     def f1(self):
#         super(Foo, self).f1()
#         print("in Foo")
#
#
# class Bar(A):
#     def f1(self):
#         print("in Bar")
#
#
# class Info(Foo, Bar):
#     def f1(self):
#         super(Info, self).f1()
#         print("in Info f1")
#
#
# print(Info.mro())
# # Info Foo Bar A
# obj = Info()
# obj.f1()
# in Bar
# in Foo
# in Info f1

题三
class A:
    def f1(self):
        print("in A")

class Foo(A):
    def f1(self):
        super().f1()
        print("in Foo")

class Bar(A):
    def f1(self):
        print("in Bar")

class Info(Foo, Bar):
    def f1(self):
        super(Foo, self).f1()
        print("in Info f1")

obj = Info()
obj.f1()
# in Bar
# in Info f1

带颜色的print

固定的头尾: \033[ \033[0m

1;35;0m 具体调节的参数

显示方式: 0（默认值）、1（高亮）、22（非粗体）、4（下划线）、24（非下划线）、 5（闪烁）、25（非闪烁）、7（反显）、27（非反显）

前景色: 30（黑色）、31（红色）、32（绿色）、 33（黄色）、34（蓝色）、35（洋 红）、36（青色）、37（白色）

背景色: 40（黑色）、41（红色）、42（绿色）、 43（黄色）、44（蓝色）、45（洋 红）、46（青色）、47（白色）

有些功能无效

# print('字体变色，但无背景色')
# 固定的头尾: \033[         \033[0m

# 1;35;0m 具体调节的参数
# print('\033[1;32;0m字体变色，但无背景色 \033[0m')  # 有高亮 或者 print('\033[1;35m字体有色，但无背景色 \033[0m')
# print('\033[1;33;0m字体变色，但无背景色 \033[0m')  # 有高亮 或者 print('\033[1;35m字体有色，但无背景色 \033[0m')
# print('\033[1;45m 字体不变色，有背景色 \033[0m')  # 有高亮
# print('\033[1;35;46m 字体有色，且有背景色 \033[0m')  # 有高亮
print('\033[0;35;0m 字体有色，且有背景色 \033[0m')
print('\033[1;35;0m 字体有色，且有背景色 \033[0m')
print('\033[4;35;0m 字体有色，且有背景色 \033[0m')
# print('\033[5;35;0m 字体有色，且有背景色 \033[0m')  # 无高亮

今日总结

多态、封装、鸭子类型 面试题

类的约束：写代码遵循的一种开发思路

抽象类、接口类：面试题

super：开发，面试都可能涉及