面向对象基础与实例
一、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