28面向对象（派生/封装/反射）
继承下的派生应用
import datetime
import json
class MyJsonEncoder(json.JSONEncoder): #MyJsonEncoder继承原本的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) #由于d1中的datetime不符合jason里面的序列化要求，所以需要派生进行帮助，将日期转成字符串
print(res)
"""
TypeError: Object of type 'datetime' is not JSON serializable
json不能序列化python所有的数据类型 只能是一些基本数据类型
json.JSONEncoder
1.手动将不能序列化的类型先转字符串
{'t1': str(datetime.datetime.today()), 't2': str(datetime.date.today())}
2.研究json源码并重写序列化方法
研究源码发现报错的方法叫default
raise TypeError("Object of type '%s' is not JSON serializable" % o.__class__.__name__)
我们可以写一个类继承JSONEncoder然后重写default方法
"""
# 封装的含义
将类中的某些名字'隐藏'起来 不让外界直接调用
隐藏的目的是为了提供专门的通道去访问 在通道内可以添加额外的功能
# 代码实操
# 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) #打印不出来，因为被隐藏
# print(Student.__dict__) # '_Student_ _label': '逆来顺受' 其实实际上不是- -label没有，而是现在换了名字是— student- -label,所以并没有被隐藏，只是间接换了个名字
# print(Student._Student__label)
# print(stu1._Student__label)
"""
如何封装名字
在变量名的前面加上两个下划线_ _
封装的功能只在类定义阶段才能生效!!!
在类中封装其实也不是绝对的 仅仅是做了语法上的变形而已
_ _变量名 >>> _类名_ _变量名
我们虽然指定了封装的内部变形语法 但是也不能直接去访问 （要自己自觉，虽然知道是隐藏，知道它真正的名字，但是守着程序员的准则，用接口去调用）
看到了就表示这个属性需要通过特定的通道(接口)去访问
"""
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('','haha')
"""
将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，
接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
目的的是为了隔离复杂度，例如ATM程序的取款功能,该功能有很多其他功能组成
比如插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来
"""
property就是将方法伪装成数据
"""
可扩扩展:
体质指数（BMI）=体重（kg）÷身高^2（m）
"""
有时候很多数据需要经过计算才可以获得
但是这些数据给我们的感觉应该属于数据而不是功能
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.83, 77)
# # p1.BMI() # 22.9
# # print(p1.BMI)
# p2 = Person('eason',1.90,85)
# # p2.BMI() # 23.5
# # print(p2.BMI)
# p3 = Person('xd',1.85,100)
# # p3.BMI() # 29.2
# print(p3.BMI)
# p4 = Person('xd',1.5,34)
# # p4.BMI() # 15.1
# print(p4.BMI)
# 什么是多态
一种事物的多种形态
eg:
水 固态 液态 气态
动物 猫、狗、猪
# 多态性
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('哼哼哼')
"""
只要你是动物 那么你想要说话 就应该调用一个相同的方法speak 这样便于管理
"""
面向对象的多态性其实在很早之前就已经接触过了
"""
# 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()
面向对象的多态性也需要python程序员自己去遵守
（）
虽然python推崇的是自由 但是也提供了强制性的措施来实现多态性（了解即可）
不推荐使用
"""
# import abc
# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
# class Animal(metaclass=abc.ABCMeta):
# @abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
# def talk(self): # 抽象方法中无需实现具体的功能
# pass
# class Person(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
# def talk(self): #前面在父类的时候写了限制，这里如果不写talk是不可以的
# pass
# p1=Person() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化
"""
由多态性衍生出一个鸭子类型理论
只要你看着像鸭子 走路像鸭子 说话像鸭子 那么你就是鸭子!!!
"""
# 鸭子类型的实战案例
"""
在linux系统中有一句话>>>:一切皆文件!!!
内存可以存取数据
硬盘可以存取数据
...
那么多有人都是文件
"""
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):
pass
# 编写一个小程序 判断Student名称空间中是否含有用户指定的名字 如果有则取出展示
# print(Student.__dict__)
'''字符串的school 跟 变量名school差距大不大? 本质区别'''
# guess_name = input('请输入你想要查找的名字>>>:').strip()
# 不使用反射不太容易实现
# print(hasattr(Student, 'school')) # True
# print(hasattr(Student, 'get')) # True
# print(hasattr(Student, 'post')) # False
# print(getattr(Student, 'school')) # 清华大学
# print(getattr(Student, 'get')) # <function Student.get at 0x10527a8c8>
举例子
# guess_name = input('请输入你想要查找的名字>>>:').strip()
# if hasattr(Student, guess_name):
# target_name = getattr(Student, guess_name)
# if callable(target_name): #callable判断当前变量名能不能加括号调用！！！
# print('类中有一个功能名字是%s'%guess_name,target_name)
# else:
# print('类中有一个数据名字是%s'%guess_name,target_name)
# else:
# print('类中没有该名字')
setattr(Student,'level','贵族学校') #相当于增加键值对
print(Student.__dict__)
def index():
pass
obj = Student()
setattr(obj, '血量', 10000)
setattr(obj, '功能', index)
print(obj.__dict__)
delattr(obj, '功能') #相当于减少键值对
print(obj.__dict__)
"""
什么时候使用反射 可以记固定的口诀
以后只要在业务中看到关键字
对象 和 字符串(用户输入、自定义、指定) 那么肯定用反射
# 利用反射获取配置文件中的配置信息
"""一切皆对象 文件也是对象"""
import settings
dir(settings) # 获取对象中所有可以使用的名字 返回数据类型可以调用的内置方法！
getattr(settings, 'NAME')
class FtpServer: #该功能有点像手机小爱同学，说到关键字就会触发相应的功能
def serve_forever(self):
while True:
inp=input('input your cmd>>: ').strip() #字符串，这样可以让人想要什么输入什么
cmd,file=inp.split() #把输入的cmd进行分割
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()