继承下的派生实际应用、面向对象三大特性之封装、面向对象三大特性之多态、面向对象之反射

继承下的派生实际应用

import datetime
import json
class MyJasonEncoder(json.JSONEncoder):
    def defaule(self,o):
        # 形参o就是即将要被序列化的数据对象
        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.date.today(),'t2':datetime.date.today()}
res = json.dumps(d1,cls=MyJasonEncoder)
print(res)

说明：

方法一：手动将不能序列化的类型先转化为字符串
{'t1': str(datetime.datetime.today()), 't2': str(datetime.date.today())}
方法二：研究json源码并重写序列化方法
研究源码发现报错的方法叫default
raise TypeError("Object of type '%s' is not JSON serializable" % o.__class__.__name__)
方法原理就是写一个类继承JSONEncoder然后重写default

面向对象三大特性之封装

封装的含义

"""
将类中的某些名字'隐藏'起来，不让外界直接调用
隐藏的目的为了提供专门的通道去访问，在通道内可以添加额外的功能
"""
实际上，是把该隐藏的隐藏起来，该暴露的暴露出来；Python只需要将类的成员名为以双下划线开头，就可以隐藏类中的成员。

# 如何封装名字：
在变量名的前面加上两个下划线__
封装的功能只在类定义阶段才能生效
在类中封装其实也不是绝对的，仅仅是做了语法上的变形状
__变量名    >>>>    _类名__变量名
#我们虽然指定了封装的内部变形语法，但是也不能直接去访问,看到了就表示这个属性需要通过特定的通道(接口)去访问

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('tuzi',88)
stu1.check_info()
stu1.set_info('','qweqwe')

将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接的操作数据
接口之上可以附加额外的逻辑来对数据的操作进行严格的控制
目的是为了隔离复杂度，例如ATM程序的取款功能，该功能有很多其他功能组成

property

property就是将方法伪装成数据

property就是将方法伪装成数据

BMI实例：

有时候很多数据需要经过计算才可以获得
但是这些数据给我们的感觉应该属于数据而不是功能
BMI指数>>>:应该属于人的数据而不是人的功能
class Person(object):
    def __init__(self, name, height, weight):
        self.__name = name
        self.height = height
        self.weight = weight

    @property
    def BMI(self):
        return '%s的BMI指数是：%s' % (self.__name, self.weight / (self.height ** 2))


p1 = Person('tuzi', 1.79, 72)
print(p1.BMI)
# tuzi的BMI指数是：22.47120876377142

面向对象三大特性之多态

什么是多态？

一种事物的多种形态
eg：水  固态   液态    气态
	动物    猫、猪、狗

多态性

class Animal(object):
    def speak(self):
        pass

class Cat(Animal):
  def speak(self):
      print('喵喵喵')

class Dog(Animal):
  def speak(self):
      print('汪汪汪')

class chicken(Animal):
  def speak(self):
      print('咯咯哒咯咯哒')
上述场景下，不仅仅体现了事物的多态性，但是虽然形态不同，但是动作是一样的，所以可以调用相同的方法(speak)这一个相同的方法，这样便于管理
c1 = Cat()
d1 = Dog()
p1 = Pig()
c1.speak()
d1.speak()
p1.speak()

面向对象的多态性其实在很早之前就已经接触过了

eg：

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):
        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():根据字符串删除对象对应的键值对(名称空间中的名字)

反射实际的应用

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('请输入你的指令')
            cmd,file = inp.split()
            if hasattr(self,cmd):
                func = getattr(self,cmd)
                func(file)
    def get(self,file):
        print("正在下载%s"%file)

    def put(self,file):
        print('正在上传%s'%file)

obj = FtpServer()
obj.serve_forever()