一、1类与对象
2.类的数据属性与函数属性
3.属性的查找顺
二、面向对象的三大特征
1.继承
2.多态
3.封装
三、类中的装饰器
1.property
2.classmathod
3.staticmethod
四、面向对象高级
1.反射
2.内置方法
3.元类
day 25今日内容
0.复习
1.接口思想和抽象思想（*）
2.多态（*****）
2.1继承关系的多态（*****）
2.2鸭子类型的多态（*****）
3..内置方法（***）
3.1格式化
·· 3.2析构方法
4.反射：（***）
5.异常处理：*****使用超级简单，在哪里使用，怎么使用思想复杂
0.复习
1.继承
1.父类：在类后()中写父类们 class A:pass#父类1 class B:pass#父类2 class C(A, B):pass#子类中继承A,B括号内传入A，B父类的属性
2.属性查找顺序：自己=》（）左侧的父类=》依次往右推
3.抽离：先定子类，由子类的共性抽离出父类-
派生：父类已经创建，通过父类再去派生子类
4.继承关系：
-- 1）父类的所有非封装的属性和方法均能被继承 -- 2）父类的所有封装的属性和方法不能被继承 -- 3）在子类中要去使用父类的方法
4.1子类的继承父类方法：子类不需要去实现父类的方法，子类对象可以直接调用父类方法
4.2重写父类的方法：方法名与父类相同，实现体与父类不同，子类对象调用的是自身方法
4.3重用父类的方法：方法名与父类相同，实现体中有自己的逻辑也调用了父类的方法(super().__init__()既父类的有用自己，返回的是自己 ++>-- super():在子类中获取可以调用父类方法的对象，且在父类中体现的调用者子类或子类对象
5.复杂继承：一个类可以继承多个类，查找顺序是根据继承父类从左往右的顺序，并且在查找第一个父类时，将父类的父类也进行查找(一个父类分支全部查找完毕才去查找下一个父类分支)
6.菱形继承：
6.1经典类：py2中类不默认继承object，所以没有明确继承的类就没有继承任何类，这样的类称之为经典类
6.2形式类：所有直接或间接继承object的类，py2中主动继承object的类及py3中所有的类
查找顺序：前提==>>父类中有共有属性或方法，子类没有自己去定义这些属性和方法，必须从父类中获取，到底从哪个父类中获取
经典类：深度查找：a-->b-->d-->c
新式类：广度查找：a-->b-->c-->d
d
b c（父类）
a（子类）
1.接口思想和抽象思想（*）
接口：建立关联的桥梁，方便管理代码 1.python中没有接口语法
# 清晰知道操作的功能，但不明确操作的具体对象
print(len('123'))
# 清晰最大操作的对象，但不明确具体的操作方法,（这就是接口的理解）
print('123'.__len__())
# 接口类：作用==》是功能的类，为继承他的子类提供功能的
# 该类的功能方法一般不需要有实现体，实现体由继承它的子类自己去实现
def eat():
pass
def drink():
pass
def jiao():
pass
class PetInterface:
def guanxin_zhuren(self):
pass
class WatchInterface:
def watch_door(self): pass
class Dod(PetInterface, WatchInterface):
def eat(self): pass
def drink(self): pass
def jiao(self): pass
# 一定要重写接口的方法
class Cat(PetInterface, WatchInterface):
def eat(self): pass
def drink(self): pass
def jiao(self): pass
# 一定要重写接口的方法
import abc
class Quanke(metaclass=abc.ABCMeta):
def __init__(self, name):
self.name = name
def run(self):
print(self.name+"runing")
# 抽象父类中的抽象方法，在继承它的子类中必须有自己的实现体
@abc.abstractclassmethod
def chi(self):
# print(self.name+"肉肉")
pass
@abc.abstractclassmethod
def jiao(self):
# print("旺旺")
pass
@classmethod
@abc.abstractclassmethod
def fn(cls):
pass
class Dog(Quanke):
@classmethod
def fn(self):
pass
def kanmen(self):
print("%skanmen"%self.name)
def chi(self):
super().chi()
print(self.name+"吃狗粮")
def jiao(self):
print("wangwangwang")
class Wolf(Quanke):
@classmethod
def fn(self):
pass
def chi(self):
super().chi()
print("%s再吃肉肉"%self.name)
def jiao(self):
print("ououou")
def pulei(self):
print("%s在捕猎"%self.name)
wolf=Wolf("大狼1") 实例化必须传参
wolf.chi()
wolf.jiao()
dog1=Dog("二哈") 实例化必须传参
dog1.chi()
dog1.jiao()
dog1.run()
dog1.kanmen()
wolf.pulei()
大狼1再吃肉肉
ououou
二哈吃狗粮
wangwangwang
二哈runing
二哈kanmen
大狼1在捕猎2.多态（*****）
# 抽象父类：拥有抽象方法(子类共有的方法，但是父类不能有具体的实现体)的父类
# 抽象方法：方法名是具体的，但是实现体是抽象的(在子类中重写来具象化)
# 需要借助python中abc来实现抽象父类
2.1继承关系的多态（*****）
# 多态：对象的多种状态—父类对象的多种（子类对象）状态
import abc
class People:
def __init__(self, name):
self.name = name
@abc.abstractclassmethod
def speak(cls):
pass
class Chinese(People):
def speak(self):
print("说汉语")
class France(People):
def speak(self):
print("说法语")
if __name__ == '__main__':#以后写文件的接口 必须引入if 判断才能执行下面的内容
# 多态的功能体现：功能或需求，需要父类的对象，可以传入父类对象或任意子类对象
# ---注意：一般都是规定父类对象，传入子类对象
def ask_someone(obj): # 定义函数实现功能函数
print("让%s上台演讲" % obj.name) # 父类提供，自己直接继承
obj.speak() # 父类提供，只不过子类重写了
china1 = Chinese("王铁锤") # 实例化一个人物
france1 = France("rose") # 实例化一个人物
ask_someone(china1)#传入函数
ask_someone(france1)
让王铁锤上台演讲
说汉语
让rose上台演讲
说法语
2.2鸭子类型的多态（*****）
# 鸭子类型：
# 1.规定有什么属性及什么方法的类的类型叫鸭子类型
# 2.能提供出规定的属性与方法的对象就是鸭子
mport abc
class People(metaclass=abc.ABCMeta):
def __init__(self, name):
self.name = name
@abc.abstractmethod
def speak(cls):
pass
class Chinese():
def speack(self):
print("说汉语")
class France():
def speack(self):
print("说法语")
class Test:
def __init__(self, name):
self.name = name
def speak(self):
print("说鸭语")
if __name__ == '__main__':
def ask_someone(obj):
print("让%s上台演讲" % obj.name)
obj.speak()
test1 = Test("老唐")
ask_someone(test1)
3..内置方法（***）
3.1格式化
3.2析构方法
class A:
def __init__(self, name, age):
self.name = name
self.age = age
# 格式化方法：在外界打印该类对象是背调用
# 格式化外界直接打印该类对象的字符串表示结果
def __str__(self):
return "[ame:%s age:%s]" % (self.name, self.age)
# 构析方法：在对象被消耗的那一刹那，在被消耗那一刹那可以做一些事
def __del__(self):
# del会在self代表的对象被消耗的时候被调用
# 我们可以在析构函数中释放该对象持有的其他资源，
# 或者将一些持有资源持久化(保存到文件或数据库中)
del self.name #也可以将name存起来
a=A("隔壁老林",20)
print(a,type(a))
import time
time.sleep(2)
print("文件马上执行完毕，a就会被销毁")
print("====
4.反射：（***）
# 反射：通过字符串与类及类的对象的属性(方法)建立关联
class A:
def __init__(self,name):
self.name=name
def t1(self):
print(self.name+"t1 挣钱了")
def t2(self):
print(self.name+"t1 挣钱了")
def t3(self):
print(self.name+"t3 挣钱了")
a=A("小马哥")
# a.t1()
map_dic={"t1":a.t1}
while True:
cmd=input("输入：")#用户如果输入他就用对象走a走t1功能
# # if cmd in map_dic:
# # map_dic[cmd]()
fn=getattr(A,cmd,"没有该方法")
print(fn)
fn(a)
输入：t1
<function A.t1 at 0x000001D241B89268>
小马哥t1 挣钱了
输入：
class B:
num=10
def __init__(self,name):
self.name=name
#对象自己的属性操作只能用对象，不能用类
b=B("QQQ")
print(hasattr(B,"name"))
print(hasattr(b,"name"))
print(getattr(B,"name",'对象的属性类不能获取'))
print(getattr(b,"name",'对象的属性类不能获取,只能自己获取'))
print(setattr(b,"age",18))
print(b.age)
False
True
对象的属性类不能获取
QQQ
None
18
class C:
def fn(self):
print("fn")
@classmethod
def func(cls):
print("func")
fn=getattr(C,"fn")
c=C()
fn(c)
func=getattr(C,"func")
func()
#fn
#fu
# 总结：
# 类的属性用类来操作
# 对象的属性用对象来操作
# 方法建议使用类来操作，得到的方法调用时
# -- 对象的方法要传入具体的对象
# -- 类的方法不需要传入参数
5.异常处理：*****使用超级简单，在哪里使用，怎么使用思想复杂
impoet time