目录
- 派生的实际应用
- 面向对象三大特性之封装
- 封装的含义
- 如何封装名字？
- property伪装
- 面向对象三大特性之多态
- 多态的含义
- 强制多态性
- 衍生多态性
- 面向对象之反射
- 反射的含义
- 反射需要掌握的四个方法
- 四个方法的使用
- 反射实际案例
派生的实际应用
当前需要序列化一个字典，如下代码：
d1 = {'t1': datetime.datetime.today(), 't2': datetime.date.today()}
res = json.dumps(d1)
print(res)
# 报错
'''
TypeError: Object of type 'datetime' is not JSON serializable
json不能序列化python所有的数据类型 只能是一些基本数据类型
'''解决方法：
方法1 - 手动将不能序列化的类型先转字符串
d1={'t1': str(datetime.datetime.today()), 't2': str(datetime.date.today())}
res = json.dumps(d1)
print(res) # {"t1": "2022-04-08 20:45:06.122407", "t2": "2022-04-08"}方法2 - 研究json源码并重写序列化方法
'''
研究源码发现报错的方法叫default
raise TypeError("Object of type '%s' is not JSON serializable" % o.__class__.__name__)
我们可以写一个类继承JSONEncoder然后重写default方法
'''
class MyJsonEncoder(json.JSONEncoder):
def default(self, o):
# 形参o就是即将要被序列化的数据对象
print('重写了', o)
'''将o处理成json能够序列化的类型即可'''
if isinstance(o, datetime.datetime):
return o.strftime('%Y-%m-%d %X')
elif isinstance(o, datetime.date):
return o.strftime('%Y-%m-%d')
return super().default(o) # 调用父类的default(让父类的default方法继续执行 防止有其他额外操作)
d1 = {'t1': datetime.datetime.today(), 't2': datetime.date.today()}
res = json.dumps(d1,cls=MyJsonEncoder)
print(res) # {"t1": "2022-04-08 20:51:41", "t2": "2022-04-08"}面向对象三大特性之封装
封装的含义
将类中的某些名字'隐藏'起来，不让外界直接调用。
隐藏的目的是为了提供专门的通道去访问，在通道内可以添加额外的功能。
如何封装名字？
1. 在变量名的前面加上两个下划线__,封装的功能只在类定义阶段才能生效!!!
2.在类中封装其实也不是绝对的,仅仅是做了语法上的变形而已,'__变量名'变成了'_类名__变量名'。
3.虽然指定了封装的内部变形语法，但是也不能直接去访问看到了就表示这个属性需要通过特定的通道(接口)去访问。封装名字演示：
class Student(object):
school = '清华大学'
__label = '隐藏项！！' # 由于python崇尚自由 所以并没有真正的隐藏 而是自动转换成了特定的语法
def __init__(self, name, age):
self.name = name
self.age = age
def choose_course(self):
print('%s正在选课'%self.name)
stu1 = Student('jason', 18)
print(stu1.school) # 清华大学
print(stu1.name) # jason
print(stu1.age) # 18
# print(stu1.__label) # 报错，'Student' object has no attribute '__label' 因为隐藏了__label
print(Student.__dict__) # '_Student__label': '隐藏项！！'
print(Student._Student__label) # 隐藏项！！ 可以通过_类名__变量名 取到值，但是也不能直接去访问
print(stu1._Student__label) # 隐藏项！！ 表示这个属性需要通过特定的通道(接口)去访问将数据隐藏起来就限制了外币对数据的直接操作，让后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格的控制，目的是为了隔离复杂度，例如ATM程序的取款功能，该功能有很多其他功能组成， 比如插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来。
class Student(object):
__school = '清华大学'
def __init__(self, name, age):
self.__name = name
self.__age = age
# 专门开设一个访问学生数据的通道(接口)
def check_info(self):
print("""
学生姓名:%s
学生年龄:%s
""" % (self.__name, self.__age))
# 专门开设一个修改学生数据的通道(接口)
def set_info(self,name,age):
if len(name) == 0:
print('用户名不能为空')
return
if not isinstance(age,int):
print('年龄必须是数字')
return
self.__name = name
self.__age = age
stu1 = Student('jason', 18)
stu1.check_info()
stu1.set_info('jasonNB',28)
stu1.check_info()
stu1.set_info('','11')
stu1.check_info()property伪装
property就是将方法伪装成数据。
很多时候有些数据需要通过计算才能获取，但这些数据给我们的感觉应该是属于数据而不是功能，这个时候我们就可以用到property来把功能伪装成数据。
# BMI指数>>>:应该属于人的数据而不是人的功能
class Person(object):
def __init__(self, name, height, weight):
self.__name = name
self.height = height
self.weight = weight
@property
def BMI(self):
# print('%s的BMI指数是:%s' % (self.name, self.weight / (self.height ** 2)))
return '%s的BMI指数是:%s' % (self.__name, self.weight / (self.height ** 2))
p1 = Person('jason', 1.74, 80)
# p1.BMI() 报错 'str' object is not callable 已伪装成数据，不能通过()调用。
print(p1.BMI)面向对象三大特性之多态
多态的含义
什么是多态？多态指的是一种食物的多种形态，像水有固态，也太和气态等。
多态性代码展示
class Animal(object):
def speak(self):
pass
class Cat(Animal):
def speak(self):
print('喵喵喵')
class Dog(Animal):
def speak(self):
print('汪汪汪')
class Pig(Animal):
def speak(self):
print('哼哼哼')
c1 = Cat()
d1 = Dog()
p1 = Pig()
c1.speak() # 喵喵喵
d1.speak() # 汪汪汪
p1.speak() # 哼哼哼上述场景下虽然体现了事物的多态性 ，但是并没有完整的体现出来。因为现在不同的形态去叫，需要调用不同的方法，不够一致。只要你是动物，那么你想要说话，就应该调用一个相同的方法 这样便于管理。
面向对象里的多态性：len方法
s1 = 'hello world'
l1 = [1, 2, 3, 4]
d1 = {'name': 'jason', 'pwd': 123}
print(len(s1))
print(len(l1))
print(len(d1))多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，实例化得到的对象obj，可以使用相同的方式使用obj.speak()。狗，猫，猪都可以调用speak()发出自己的叫声。
强制多态性
虽然python推崇的是自由，但是也提供了强制性的措施来实现多态性，使用了abc模块，不推荐使用性多态。
import abc
# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Animal(metaclass=abc.ABCMeta):
@abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
def talk(self): # 抽象方法中无需实现具体的功能
pass
class Person(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
def talk(self):
pass
p1=Person() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化衍生多态性
由多态性衍生出一个鸭子类型理论，只要你看着像鸭子，走路像鸭子，说话像鸭子，那么你就是鸭子!!!
class Memory(object):
def read(self):
pass
def write(self):
pass
class Disk(object):
def read(self):
pass
def write(self):
pass
# 得到内存或者硬盘对象之后 只要想读取数据就调用read 想写入数据就调用write 都当文件使用，不需要考虑具体的对象是谁。面向对象之反射
反射的含义
指程序可以访问、检测和修改本身状态或者行为的一种能力。其实就是通过字符串来操作对象的数据和功能。
反射需要掌握的四个方法
- hasattr():判断对象是否含有字符串对应的数据或者功能
- getattr():根据字符串获取对应的变量名或者函数名
- setattr():根据字符串给对象设置键值对(名称空间中的名字)
- delattr():根据字符串删除对象对应的键值对(名称空间中的名字)
四个方法的使用
class Student(object):
school = '清华大学'
def get(self):
passhasattr():判断对象是否含有字符串对应的数据或者功能
print(asattr(Student, 'school')) # True
print(hasattr(Student, 'get')) # True
print(hasattr(Student, 'post')) # Falsegetattr():根据字符串获取对应的变量名或者函数名
print(getattr(Student, 'school')) # 清华大学
print(getattr(Student, 'get')) # <function Student.get at 0x0000022EFDCDCC80>setattr():根据字符串给对象设置键值对(名称空间中的名字)
setattr(Student,'隶属','211和985')
print(Student.__dict__) # '隶属': '211和985'
obj1=Student()
setattr(obj1,'地里位置','北京市海淀区清华园')
print(obj1.__dict__) # {'地里位置': '北京市海淀区清华园'}delattr():根据字符串删除对象对应的键值对(名称空间中的名字)
delattr(obj1,'地里位置')
print(obj1.__dict__) # {}反射实际案例
class FtpServer:
def serve_forever(self):
while True:
inp=input('input your cmd>>: ').strip()
cmd,file=inp.split()
if hasattr(self,cmd): # 根据用户输入的cmd，判断对象self有无对应的方法属性
func=getattr(self,cmd) # 根据字符串cmd，获取对象self对应的方法属性
func(file)
def get(self,file):
print('Downloading %s...' %file)
def put(self,file):
print('Uploading %s...' %file)
obj = FtpServer()
obj.serve_forever()
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
