面向对象的特征

面向对象三大特性

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

继承下的派生实际应用

import datetime
import json

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)

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方法
# 第二种方法的思想就是问题出现在中间，我们先在中间截住，我们直接通过先继承父类的功能，然后在类里面的子类重新添加一些我们的条件，从而会自动优先执行之前我们修改后的子类，而不是去执行父类的子类，最后在继承父类的方法继续执行即可，防止有其它额外的操作

封装

含义：封装，顾名思义，就是将要访问的数据保护起来，不让外界直接访问类的属性和字段，隐藏的目的是为了提供专门的通道去访问，在通道内可以添加额外的功能.所谓的隐藏其实就是一种变形操作，自动转换成了特定的语法

eg:
class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

操作方法：在变量名的前面加上双下划线（__)，封装的功能只在类定义阶段才能生效

这种自动变形的特点：

类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。

这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

这种变形需要注意的问题是：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

2.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形

注意：我们虽然知道了封装的内部变形语法，但是也不能直接去访问，看到了就表示这个属性需要通过特定的通道（接口）去访问。

在类中封装其实也不是绝对，仅仅是做了语法上的变形而已

# __变量名 >>>>>>> _类名__变量名

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

封装之property

property就是将方法伪装成数据，比方有些数据给我们的感觉应该属于数据而不是功能，像BMI指数它就是用来描述人的数据而不是人的功能

eg:
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)

面向对象之多态

多态：描述一种事物的多种形态，例如水有三种形态，动物里又有各种各样形态的动物

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)

 c1 = Cat()
 d1 = Dog()
 p1 = Pig()
 c1.speak()
 d1.speak()
 p1.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，无法实例化

多态性衍生出一个鸭子类型理论

理论：只要你看着像鸭子，走路像鸭子，叫声像鸭子，那么结论就是鸭子

用内存，硬盘，文件举例：
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 User:
    def login(self):
        print('欢迎来到登录页面')
    
    def register(self):
        print('欢迎来到注册页面')
    
    def save(self):
        print('欢迎来到存储页面')

user = User()
while 1:
    choose = input('>>>').strip()
    if hasattr(user,choose):
        func = getattr(user,choose)
        func()
    else:
        print('输入错误。。。。')