第四章面向对象

　　1. 基本格式

　　　　定义：当函数(业务功能)比较多，可以使用面向对象来进行归类，如果有一个凡事使用的公共值，也可以放到对象中

#格式&关键字
class 类名:def __inti__(self,x)self.x = xdef 方法名(self,name):print(self.name)
v1 = 类(666)
v1.方法('Parallel')#存储一些值，方便之后使用
clas Foo:def __intit__(self,n,a,g):self.name = nself.age = aself.gender = gdef show(self):temp = '我是%s，年龄%s，性别%s'%(self.name,self.age,self.gender,)print(temp)
p = Person('Parallrl',18,'男')    #类()实例化对象，自动执行此类中的__init__方法
p.show()

　　2. 三大特性

　　　　2.1 封装

　　　　　　定义：将同一类的函数或重复使用的公共值封装佛奥同一个类中，方便以后使用

　　　　2.2 继承

　　　　　　定义：创建一个子类的对象，执行对象.方法时，优先在自己的类中找，如果没有就在父类中找，多个类中如果有公共的方法，可以放在基类中

　　　　　　注：继承关系的查找顺序，要注意self到底是哪个类创建的，就从此类开始找

#继承
class Base:    父类(基类)def f1(self):pass
class Foo(Base):    子类(派生类)def f2(self):pass
obj = Foo()

　　3. 类成员

　　　　方法(绑定方法/普通方法)：至少有一个self参数，先创建对象，由对象.方法()执行

　　　　类方法：@classmethod，至少有一个参数cls，类.类方法()执行

　　　　静态方法：@staticmethod，参数无限制可以不传参，可以不创建对象类.静态方法名()执行

　　　　类变量：写在类的下一级，和方法同级，类/对象.类变量名称调用

　　　　属性：@property，把方法编程属性，出去了self不能有其他参数，用对象.属性名调用，不需要加()

　　4. 成员修饰符

　　　　定义：公有&私有

#公有变量和私有变量    
class Foo:def __init__(self,name):self.name = name    #公共的self._name = name    #私有的def func(self):print(self,name)
obj = Foo('alex')
print(obj.name)
print(obj.__name)    #外部访问不到#访问私有变量
class Foo:def __init__(self,name):self.__x = name
obj = Foo('alex')
print(obj._Foo__x)    #强制访问私有实例变量

　　5. 特殊成员

#__init__：初始化方法，用于给对象赋值(默认执行)#__new__：构造空对象，比__inti__优先执行#__call__：可以用类()()直接执行call方法#__getitem__/__setitem__/__delitem__
class Foo:def __setitem__(self,key,value):print(key,value)def __getitem__(self,item):print(item)###xxxdef __delitem__(self,key):print(key)###ttt
obj1 = Foo()
obj1['k1'] = 123#内部会自动调用__setitem__方法
val = obj1['xxx']    #内部会自动调用__getitem__方法
print(val)
del obj1['ttt']#内部会自动调用__delitem__方法#__str__：打印一个对象，当__str__返回什么，对象就打印什么
class Foo(object):def __str__(self):return 'sdsdsa'
obj = Foo()
print(obj)    #打印的是对象，类型也是对象，但答应出来的是sdsdsa#__dict__：将要找的元素编程字典格式
class Foo(object):def __init__(self,name,age,email):self.name = nameswf.age = ageself.email = email
obj = Foo('alex',19,'xxx@qq.com')
val = obj.__dice__#去对象中找到所有变量转换为字典
print(val)    #{'name':'alex','age':19}#__enter__/__exit__：文件上下文管理
class Foo(object):def __enter__(self):self.x = open('a.txt',mode='a',encoding='utf-8')return self.xdef __exit__(self,exc_type,exc_val,exc_tb):self.x.close()
with Foo() as ff:ff.write('alex')#对象互相加减乘除    
class Foo(object):def __add__(self,other):pass
obj1 = Foo()
obj2 = Foo()
val = obj1 +obj2###触发add，前面触发，前面为self，后面为other

　　6. 嵌套

　　　　定义：面向对象可以当参数嵌套到函数中，类(Foo)可以为key对象(obj)可以做key

class Dream(object):def __init__(self,title,addr):self.title = titleself.address = addrclass House(object):def __init__(self,name,dream_object):self.name = nameself.dream =dream_objects1 = Dream('北京','沙河')
s2 = Dream('上海','浦东')
s3 = Dream('深圳','南山')c1 = House('Parallel',s1)
c1.name
c1.dream.title
c1.dream.address

　　7. 反射

#根据字符串的形式去某个对象中操作他的成员
class Foo:def login(self):pass
obj = Foo()
func_name = input('请输入方法名:')
getattr(obj,func_name)()    #找到方法并执行#根据字符串的形式去某个对象中判断是否有该成员
class View(object):def login(self):return '登陆'def logout(self):return '登出'def index(self):return '首页'
obj = View()
func_name = input('请输入方法名:')
if not hasattr(obj,func_name):print('输入错误')
getattr(obj,func_name)()#根据字符串的形式去某个对象中设置成员
class Foo:pass
obj = Foo()
setattr(obj,'k1','123')    #obj.k1 = '123'    #设置对象成员
print(obj.k1)#根据字符串的形式去某个对象中删除成员
class Foo:k1 = 999
obj = Foo()
delattr(obj,'k1')

　　8. 内置函数

　　　　issubclass：判断某个类是否是某个类的子类　　print(issubclass(子类,父类))　　返回布尔值

　　　　isinstance：判断对象是否是某个类或该类基类的实例　　print(isinstance(obj,Foo))　　判断obj是否是Foo或Foo基类的实例　　返回布尔值

　　　　super：根据self对象所属类的继承关系，按顺序挨个找并执行，默认找到第一个就不找了　　v = super().xx()

　　9. 单例模式

　　　　定义：无论实例化多少次，都是用第一次创建的那个对象

class Foo(Object):instance = Nonedef __new__(cls,*args,**kwargs):if not instance:cls.instance = object.supper().__new__(cls)return cls.instance
obj1 = Foo()
obj2 = Foo()    #不管启动多少个Foo内存地址都指向obj1