DAY 24、25 面向对象、异常处理、反射、单例模式
一、定义
函数：
def+函数名（参数）
面向对象：
class Bar: 名字叫bar的类
def+函数名（第一个参数必须为self，xxx，xxx） 名字叫函数名的方法
二、执行
函数：
函数名（参数）
面向对象：
中间变量=Bar（） #创建中间人aka对象或实例
中间变量.方法名（添加self后面的参数）
***********************************************************************************************
self是什么？
class Bar：
def foo(self,argl):
print(self,self.name,self.age,self.gender,argl)
z=Bar()
z.name='alex'
z.age=90
z.gender='boy'
z.foo(666)
z1=Bar()
z1.name='yyb'
z1.age=26
z1.gender='boy'
z1.foo(777)
z和z1为self，并且可以进行传内容
*************************************************************************
#构造方法 (类名（）自动执行构造方法）
特殊作用：
在
obj=类名（）
#创建对象
#通过对象执行类中的一个特殊方法（__init__，即构造方法）
class Bar:
def __init__(self)
print(1)
z=Bar() 则会输出1
面向对象三大特性之一：封装
class Bar:
def __init__(self，name，age)
self.n=name
self .a=age
self.xue='o'
print(1)
def show(self):
print('%s-%s',%(self.n,self.a))
通常这样初始化
z=Bar('alex','age')
何时用面向对象，何时用结构式编程？
如果多个函数中有相同参数时，转换成面向对象
***************************************************************************************************************
三大特性之二：继承：
class Father： #父类；基类
def 篮球(self):
pass
def 足球(self):
pass
class Son(Father): #子类；派生类
def喝酒(self):
pass
def篮球(self): #不继承父类，默认执行自己（重写）
pass
def篮球(self): #执行父类中的篮球方法1（推荐）
super(Son,self).篮球（可加参数，不加self）
pass
def篮球(self): #执行父类中的篮球方法2
Father.篮球(self)
pass
s = Son()
s.喝酒() #self是s，喝酒中的self是形参，代指obj
s.篮球() #self还是s，永远指调用方法的调用者
多继承：
class F1:
def a(self):
print(F1.a)
class F2:
def a(self):
print(F2.a)
class s(F1,F2) #继承左边的F1
pass
------------------
class F0:
def a(self):
print(F0.a)
class F1:
def a1(self):
print(F1.a)
class F2:
def a(self):
print(F2.a)
class s(F1,F2) #继承默认左边的一条线走到头，如果两条线有共同的根，则先找另一条线，再找共同的根
pass
a.左侧优先
b.一条道走到黑
c.同一个根时，根最后执行
------------------
class baserequest():
def__init__(self):
pass 3
class requesthandler(baserequest):
def__init__(self):
pass 2
baserequest.__init__(self)
def serve_forever(self):
pass 5
self.proces_request()
def process_request(self):
pass
class minx:
def process_request(self):
pass 6
calss son(minx,requesthandler)
obj=Son（） 1
obj.serve_forever 4
obj=requesthandler()
obj.serve_forever() #执行requesthandler里的process_request
********************************************************************************************************
三大特性之三：多态 Python中忽略
*****************************************面向对象中高级**********************************************
类成员：
# 字段
-普通字段（保存在对象，执行时只能通过对象访问）
-静态字段（保存在类，执行时可以通过对象访问，也可以通过类）
class Province:
country = '中国' #静态字段，属于类
def __init__(self,name)
#普通字段，属于对象
self.name=name
Province.country 访问
hebei.country 也可以访问
------------------------------------------------
# 方法
-普通方法（保存在类，由对象来调用，self=调用者对象）
-静态方法（保存在类，由类直接调用，不用self）
-类方法 （保存在类中，由类直接调用，cls=当前类）
应用场景：
1.如果对象中需要保存一些值，执行某功能时，需要使用对象中的值
2.不需要任何对象中的值，用静态方法或类方法
class Foo:
def bar(self):
#self是对象
pass
@staticmethod 静态方法
def sta(): #self非必须
pass
@classmethod 类方法
def classmd(cls): 形参写成cls，是潜规则
#cls是类名,把类名传进去
pass
obj=Foo()
Foo.bar(obj) #通过类来调用方法，一般不用
Foo.sta() #调用静态方法
Foo.classmd()
--------------------------------------------------
#属性（为了去括号，显得规整，不伦不类）
class Foo:
#用于执行obj.per 获取值
@property 属性、特性
def per(self):
pass
#obj.per=123 修改值
@per.setter
def per(self,val)
pass
#删除值
@per.delter
def per(self)
pass
obj=Foo()
obj.per 通过字段的形式访问
obj.per=123
del obj.per
class Foo:
#等同于property的方法
def f1(self):
pass
per=property(fget=f1)/property(f1) #最多三个函数
***********************************************成员修饰符*******************************
公有成员、私有成员
class FOO:
__V='123'
def __init__(self,name,age)
self.name = name 公有
self.__age = age 私有（两个下滑线）
def show(self)
return self.__age 写上另一个方法可以间接访问，但无法访问父类私有字段
def __f1(self) 方法也有公有和私有
return 123
obj=FOO(‘Alex’，19)
obj.name 可以访问
obj.__age 不能直接访问
obj.show() 间接访问
*******************************************特殊成员*****************************************************
__init__ 类（）自动执行
__call__ 对象（）/类（）（）自动执行
__int__ int(对象)
__str__ str()
__del__ 析构对象，对象被销毁时，自动执行
__dict__ 将对象中封装的所有内容通过字典的形式返回
__getitem__ 切片（slice类型）或者索引
__setitem__
__delitem__
__iter__ 如果类中有iter方法，对象为可迭代对象
对象.__iter__()的返回值：迭代器
for循环如果是迭代器，则执行next方法；如果是可迭代对象，则执行对象.iter 方法获取迭代器，再执行next方法。
class Foo
def__init__(self)
pass
def__call__()
pass
def__int__(self):
return 1111
def__str__(self):
return 'alex'
def__add__(self,other)
return 'xxoo'
obj=FOO()
obj() #对象加括号执行call方法
r=int(obj) #int,对象，自动执行__int__方法，并将返回值赋值给int对象
i=str(obj) #同理
print（obj）#自动执行str方法
obj1+obj2 #自动执行第一个对象的add方法，并且将第二个对象作为参数传进去
***************************************metaclass，类的祖宗*************************************
a.Python中一切事物都是对象
b.obj是对象，Foo类也是一个对象，是type的对象
c.类都是type类的对象，一般的“对象”都是类的对象
class Mytype（type）
pass
class FOO（object,metacalss=Mytype）#指定type的子类创建Foo
pass
------------恢复内容开始------------
*************************************************异常处理***************************************
try:
#代码块，逻辑
pass
raise exception ('xxxxx') #主动触发异常
except Exception as e: #捕捉所有错误
#try部分代码块如果出错了，自动执行当前块的内容
#e是Exception类的对象，对象中封装了错误信息
except IndexError as e: #捕捉迭代错误，是Exception的子类
else：
#如果不出错，则执行else
finally：
#不管出不出错，肯定要执行
**自定义异常
class Error(Exception):
def__init__(self,msg):
self.message=msg
def__str__(self):
return self.message
try:
raise Error('xxx')
except Error as e
print(e)
**断言 ，用于强制用户服从，不服从就报错，可以捕获，但一般不捕获
assert 条件 如果成立，则通过，不成立则报错
*******************************************************反射**************************************************
getattr（obj, '字段或方法'）#获取
getattr(类名，'静态字段')
getattr(模块名,'全局变量名/函数名/类名')
hasattr(obj,'字段'） #判断是否存在
setattr(obj,'k1','v1') #设置
delarrt(obj,'字段'） #删除
通过字符串的形式操作对象中的成员
***********************************************单例模式***************************************************
单例，永远使用同一份实例（对象）
class Foo:
__V = None
@classmethod
def get_instance(cls):
if cls.__v:
return cls.__v
else:
return cls.__v
