面向对象之封装和多态

面向对象

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

继承下的派生实际应用

应用案例

import datetime
import json
d1 = {'t1':datetime.datetime.today(),'t2':datetime.date.today()}
print(d1)
print(json.dumps(d1))  # 不能正常打印，会报错

解决办法

注意：可以先查看json可以序列化的对象 eg:

1.转字符串，暴力直接

d2 = {'t1':str(datetime.datetime.today()),'t2':str(datetime.date.today())}
print(json.dumps(d2))

2.研究json方法，重写序列化方法

import datetime
import json
class MyJsonEncoder(json.JSONEncoder):
    # 重写default方法
    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方法继续执行 防止有其他额外操作)   

面向对象三大特性之封装

将类中的某些名字隐藏起来 不让外界直接调用

隐藏的目的是为了提供专门的通道去访问 在通道内可以添加额外的功能

代码示例如下：

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('tony', 18)
stu1.check_info()
stu1.set_info('kevin',28)
stu1.check_info()
stu1.set_info('','nb')
print(stu1.__dict__)
# 通过打印dict就可以看到stu1中的name已经更改

将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，
接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
目的的是为了隔离复杂度，例如ATM程序的取款功能,该功能有很多其他功能组成
比如插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说,只需要开发取款这个功能接口即可,其余功能都可以隐藏起来

property

property就是将方法伪装成数据

有时候很多数据需要经过计算才可以获得
但是有些数据给我们的感觉应该属于数据而不是功能
比如：BMI指数>>>:应该属于人的数据而不是人的功能

代码示例：

1.不伪装

class Person(object):
    def __init__(self, name, height, weight):
        self.__name = name
        self.height = height
        self.weight = weight
    def BMI(self):
        print('%s的BMI指数是:%s' % (self.__name, self.weight / (self.height ** 2)))
p1 = Person('jason', 1.8, 80)
p1.BMI()

2.伪装

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('jason', 1.8, 80)
print(p1.BMI)
p2 = Person('eason',1.9,85)
print(p2.BMI)

面向对象三大特性之多态

什么是多态: 一种事物的多种形态
eg:
水 固态 液态 气态
动物 猫、狗、猪

代码体现:

class Animal(object):
    def speak(self):
        pass
class Cat(Animal):
    def miao(self):
        print('喵喵喵')
class Dog(Animal):
    def wang(self):
        print('汪汪汪')
class Pig(Animal):
    def heng(self):
        print('哼哼哼')

上述场景下 虽然体现了事物的多态性 但是并没有完整的体现出来

因为现在不同的形态去叫 需要调用不同的方法 不够一致

只要你是动物 那么你想要说话 就应该调用一个相同的方法 这样便于管

理

代码体现如下：

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方法了

多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，实例化得到的对象obj，可以使用相同的方式使用 obj.speak()

虽然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 不需要考虑具体的对象是谁

反射

什么是反射

专业解释:指程序可以访问、检测和修改本身状态或者行为的一种能力

大白话:其实就是通过字符串来操作对象的数据和功能

这里要注意：在python中一切皆对象

反射需要掌握的四个方法

hasattr():判断对象是否含有字符串对应的数据或者功能

getattr():根据字符串获取对应的变量名或者函数名

setattr():根据字符串给对象设置键值对(名称空间中的名字)

delattr():根据字符串删除对象对应的键值对(名称空间中的名字)

反射实际应用

class Student(object):
    school = '清华大学'
    def get(self):
        pass
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):
  #         print('类中有一个功能名字是%s'%guess_name,target_name)
  #     else:
  #         print('类中有一个数据名字是%s'%guess_name,target_name)
  # else:
  #     print('类中没有该名字')
  def index():
      pass
  obj = Student()
  setattr(obj, '血量', 10000)
  setattr(obj, '功能', index)
  print(obj.__dict__)
  delattr(obj, '功能')
  print(obj.__dict__)

setattr

  setattr(Student,'level','贵族学校')

  def index():
      pass
  setattr(Student, '功能', index)

什么时候使用反射 可以记固定的口诀
以后只要在业务中看到关键字
对象 和 字符串(用户输入、自定义、指定) 那么肯定用反射

反射案例

# 利用反射获取配置文件中的配置信息
"""一切皆对象 文件也是对象"""
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()
             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()