面向对象，多态：
有时一个对象会有多种表现形式，比如网站页面有个按钮， 这个按钮的设计可以不一样(单选框、多选框、圆角的点击按钮、直角的点击按钮等)，尽管长的不一样，但它们都有一个共同调用方式，就是onClick()【鼠标单击】方法。我们直要在页面上一点击就会触发这个方法。点完后有的按钮会变成选中状态、有的会提交表单、有的甚至会弹窗。这种多个对象共用同一个接口，又表现的形态不一样的现象，就叫做多态( Polymorphism )。
例如：人会吃，猪也会吃，牛也会吃，那都是吃，这吃就是一个接口，但是，每个吃的方式又不一样。多个对象共用一个接口就是多态
#我们定义一个车类，他们都有共同的方法，启动和刹车。
#但是不同的车的启动方法不一样，比如说，卡车可能用钥匙启动，跑车电子启动。
#刹车的时候，跑车直接刹车就好了，但是卡车有时候就不敢直接刹车需要点刹 class Car:#定义一个车类
def __init__(self, name):
self.name = name
def drive(self):
raise NotImplementedError("子类必须实现抽象方法")#异常处理后面说
#意义就是，你可以调用我得方法，但是子类必须自行实现自己得方法，不然就报错
def stop(self):
raise NotImplementedError("子类必须实现抽象方法")
class SportsCar(Car):#跑车类继承车类
#继承父类的init方法
def drive(self):
return '开动'
def stop(self):
return '点刹'
class Truck(Car):#卡车继承车类
#继承父类的init方法
def drive(self):
return '卡车开得慢是因为负载过重.'
def stop(self):
return '装有钢管，不敢直接刹车，不然车头不见啦!' # cars = [Truck('东风重卡'),
# Truck('三一重工'),
# SportsCar('法拉利')] cars = Truck('东风卡车')
cars1 = SportsCar('法拉利')
print(cars.stop())#装有钢管，不敢直接刹车，不然车头不见啦!
print(cars1.stop())#点刹
#这2个实例都使用的共同的方法
# for car in cars:
# print(car.name + ': ' + car.drive())
封装：
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了代码数据的安全性。
优点：
1. 良好的封装能够减少耦合。
2. 类内部的结构可以*修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。
在参数里面 加上__ 双下划线 ，就是实现了封装属性
#如果你定义一个类之后，有的参数不想让人直接调用，或者修改的话，就需要封装了
class Room:#定义个房子类
def __init__(self,name,owner,width,length,high):
self.name=name
self.owner=owner
self.__width=width# 在变量前面 加__ 2个下划线就把数据属性封装了。再实例中就不可以直接调用了也不能修改了
self.__length=length
self.__high=high def tell_area(self): #此时我们想求的是面积
return self.__width * self.__length *self.__high def tell_width(self):#这样函数外面就可以调用了
return self.__width r1=Room('卫生间','alex',100,100,10000)
print(r1.name)#这个参数没有封装，所以可以直接调用
r1.name = '卧室'
print(r1.name)#也可以修改
# r1.width# 这样就不能调用，报错哦
r1.tell_width() #这个实际上在调用函数的方法调用到了width的值
#在python的一个约定，一般单下滑线的变量，一般不希望调用。但是不限制你调用，你想调用也行。
#使用者碰到定义者用_线写得变量，经量还时不要调用
类的反射：主要指陈旭可以访问、检测和修改他本身状态或者行为的一种能力
下列方法适用于类和对象
hasattr（OBJ，name）: 判断一个对象里面有没有这个属性name(字符串)
#判断OBJ中有没有一个name字符串对应的方法或者属性
getattr，
#获取一个类的的属性
setattr：设置实例属性
delattr: 删除
class Person:#定义一个人类
def __init__(self,name,age):
self.name = name
self.age = age
def say_hi(self):
print("hi,honey , my name is " ,self.name)
obj=Person('SJC',26)
#检测是否含有某属性
print(hasattr(obj,'name'))#检查有没有这个变量
print(hasattr(obj,'say_hi'))#检查有没有这个字符串
#获取属性
n=getattr(obj,'name')
print(n)
func=getattr(obj,'say_hi')
func()
print(getattr(obj,'aaaaaaaa','不存在啊')) #后面可以加参数，如果不存在就报错
#设置属性
setattr(obj,'XFD',"girl")#设置实例属性
setattr(obj,'show_name',lambda self:self.name+'--%s' % self.age)#设置函数属性
print(obj.__dict__)
print(obj.show_name(obj))#必须添加一个参数
# #删除属性
delattr(obj,'age')
delattr(obj,'show_name')
#delattr(obj,'show_name111') # 不存在,则报错
print(obj.__dict__)
Hasattr/getattr/delattr/setattr
动态导入模块：__import__# 如果是多目录导入，导入的要写路径
m = __import__('test1111')#模块路径 m.sun()#执行函数
#如果一个函数名以单下划线开头 那导入模块的时候，默认不会导入，使用的时候也要加上_单下划线
动态导入模块1：importlib
import importlib m = importlib.import_module("test1111")
#这个方式是导入的*模块，直接m.就可以运行
内置：__setattr__、__deklattr__、__getattr__,定义到类中
class Person:#定义一个人类
gender = "man"
def __init__(self,name,age):
self.name = name
self.age = age
def __getattr__(self, item):
print("执行__getattr__")
def __delattr__(self, item):
# self.__dict__.pop(item)系统应该是这么操作的
print("执行__delattr__")
def __setattr__(self, key, value):
# self.key = value#RecursionError: maximum recursion depth exceeded
#进入递归
self.__dict__[key] = value
#所有的设置属性，都是在调用属性字典
print("执行__setattr__")
def say_hi(self):
print("hi,honey , my name is " ,self.name)
obj=Person('SJC',26)
# print(obj.name)#SJC
# print(obj.alkf)#执行__getattr__
#__getattr__调用不存在的属性时触发
# del obj.age #执行__delattr__
# del obj.gender#执行__delattr__
#删除时，执行__delattr__
obj.NB = "XFD" #设置成功
print(obj.__dict__)
#这些都是内置的，如果你自己在自己得类中定义了，然就使用你自己定义的。如果没定义，那就使用系统内置的
#__delattr__setattr__ 不经常用
__getattr__的用法
class Person:#定义一个人类
gender = "man"
def __init__(self,name,age):
self.name = name
self.age = age
# def __getattr__(self, item):
# return "你找的属性【%s】不存在" % item
# def __delattr__(self, item):
# print("执行__delattr__")
def __setattr__(self, key, value):
# self.__dict__[key] = value
print("执行__setattr__")
def say_hi(self):
print("hi,honey , my name is " ,self.name)
obj=Person('SJC',26)
# print(obj.name)#SJC
# print(obj.ada)#你找的属性【ada】不存在 #触发getattr
__getattr__用法
__setattr__用法:
需求：设置的值都为字符串。
class Person:#定义一个人类
gender = "man"
def __init__(self,name):
self.name = name
def __setattr__(self, key, value):
if type(value) is str:
self.__dict__[key] = value
return "设置成功"
else:
print('设置失败') obj=Person(123)#
# print(obj.name)
_setattr__
__delattr__ 就不用演示啦
包装内置方法：使用继承
备注：我们可以用用继承的方式来修改自定义 的一些方法。
例如：你想修改内置的list方法 ，你可以定义一个LIST 类，然后设置各类函数，比如定义一个,append 的类方法append只能添加字符串类型，然后再用上__setattr__ 就可以自己定义功能了。【继承方法】
#class List(list):
授权：也是包装的一个特性。但是使用的是__getattr__。不用继承
例:定制自己文件操作时的写 方法，写入文本的时候，加入时间 别的方法不变。
import time
class FileHandle:
def __init__(self,filename,mode='r',encoding='utf-8'):
#默认参数，不填使用默认的。
# self.filename=filename
self.file=open(filename,mode,encoding=encoding)
self.mode = mode
self.encoding = encoding
def write(self,line): #line 就是你调用write写入的值
t=time.strftime('%Y-%m-%d %X')#定义时间格式
self.file.write('%s %s' %(t,line))#T时间,line写入的内容
#在写入时自动加上时间
def __getattr__(self, item):
# print(item,type(item))
# self.file.read
return getattr(self.file,item)
#因为item传进来，是个字符串，getattr的功能就是获取字符串功能参数是字符串
#你在实例化的时候，传入的时候，没有那个值，就是触发getattr.
#出入getattr之后，我们返回file.那就启动了init的方法 f1=FileHandle('a.txt','w+')
print(f1.file)
print(f1.__dict__)
print('==>',f1.read) #触发__getattr__
print(f1.write)
#f1.read执行后，然后系统会寻找init，init没有，去找类，类也没有，就出发_getattr_然后使用系统内置的open
#f1.write执行后，系统寻找init，没有，找类，类有write方法，write方法，返回
f1.write('cpu负载过高\n')
f1.write('内存剩余不足\n')
f1.write('硬盘剩余不足\n')
定制文件写操作