python面向对象（3）

python面向对象（3）

继承下的派生实际应用

import datetime
import json

class MyJsonEncoder(json.JSONEncoder):
    def default(self, o):
        # 形参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方法
"""

---

面向对象三大特征之封装

# 封装的含义
将类中的某些名字'隐藏'起来 不让外界直接调用
隐藏的目的是为了提供专门的通道去访问 在通道内可以添加额外的功能

# 封装的概念
在python中用双下划线，开头的方式将属性隐藏起来（设置成私有的）
但其实这只是一种变形操作，而且仅仅在类定义阶段会发生变形
类中所有双下划线开头的如__x都会在类定义的时候自动形成：_类名__x的形式

# 代码示例：
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(Student.__dict__)  
"""
如何封装名字
    在变量名的前面加上两个下划线__
封装的功能只在类定义阶段才能生效!!!
    在类中封装其实也不是绝对的 仅仅是做了语法上的变形而已
        __变量名       >>>     _类名__变量名
我们虽然指定了封装的内部变形语法 但是也不能直接去访问
    看到了就表示这个属性需要通过特定的通道(接口)去访问
"""

通过接口调用

# 封装的真谛在于明确地区分内外，封装的属性可以直接在内部使用，而不能在外部直接使用，然而定义
# 属性的目的终归是要用，外部想要用类隐藏的属性，需要我们为其开辟接口

 1，封装数据
    将数据隐藏起来不是目的，隐藏起来然后提供操作该数据的接口，然后我们可以在
   '''接口上附加对返数据操作的限制，以此完成对数据属性的严格控制
      类比于电脑上的各种配件，就是被封装的数据，我们可以通过操作来改变电脑硬件的配置，
       例如我们要加一块内存条，只需要知道接口，频率等参数，而不用知道内存条是什么材质的，
       也不用知道内存条内部颗粒的构成'''
class Teacher:
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
        self.set_info(name,age)
    def tell_info(self):
        print('name:%s,age:%s' %(self.__name,self.__age))
    def set_info(self,name,age):
        if not isinstance(name,str):
            raise TypeError("姓名必须是字符串类型")
        if not isinstance(age,int):
            raise TypeError("年龄必须是整数类型")
        self.__name = name
        self.__age = age
t = Teacher('jason',18)
t.tell_info()
t.set_info('kevin',28)
t.tell_info()
2，封装方法：目的是隔离复杂度
   就像我们玩电脑一样，我们不需要知道电脑的工作原理，只需要知道他是怎么用的就可以了
    
"""
将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，
    接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
    
目的的是为了隔离复杂度，例如ATM程序的取款功能,该功能有很多其他功能组成
    比如插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来
""" 

property

# property 的定义
Property 是 Python 类的一个内置的 装饰器. @property 的作用是 将一个方法, 变为属性来调用

# 访问类的私有属性
class Foo:
    def __init__(self, score):
        self.__score = score

    @property  # 将方法装饰为属性
    def show_score(self):
        return self.__score


    s = Foo(66)
    # 在写法上更加优雅, 不用多写 "方法()" 没用的括号
    print(s.show_score)

property扩展

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)

---

property示例

'''封装一个Book的类, 主要用来描述书籍的名称, 价格和评论.  要求能用 property 装饰器实现对 Book 的实例属性 set 和 get 方法进行定义. 即让实例对象可以用属性的方式来操作方法/属性'''

class Book:
    def __init__(self, name, price, comment=None):
        self.__name = name
        self.__price = price
        self.__comment = comment

    # 传统方法对price属性进行 设置和访问
    def get_price(self):
        return self.__price

    def set_price(self, value):
        self.__price = value

    # price = property(get_price, set_price)

    # @property 装饰器对 comment 属性进行 设置和访问
    @property
    def my_comment(self):
        # 默认是 getter, 需要return 或 yeild
        return self.__comment

    @my_comment.setter
    def my_comment(self, value):
        # 检验
        if not isinstance(value, float):
            raise ValueError("must be a decimal number")

        if value < 0 or value > 1000:
            raise ValueError("0 ~ 1000")

        self.__comment = value

    @my_comment.deleter
    def my_comment(self):
        print("delete this atrr...")
        

面向对象三大特性之多态

# 什么是多态
	一种事物的多种形态
  	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('哼哼哼')
"""
上述场景下 虽然体现了事物的多态性 但是并没有完整的体现出来
因为现在不同的形态去叫 需要调用不同的方法 不够一致
    
    只要你是动物 那么你想要说话 就应该调用一个相同的方法 这样便于管理
"""

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


虽然python推崇的是自由 但是也提供了强制性的措施来实现多态性
    不推荐使用

多态的鸭子类型

# python推崇的是鸭子类型
# linux 一切皆是文件（对于文件操作一个读，一个写）
# 通过多态统一的思想格式把cpu 内存 txt文件做的像文件，对其进行操作
class Cpu:
    def read(self):
        print('cpu read')
    def write(self):
        print('cpu write')

class Mem: # 内存
    def read(self):
        print('mem read')
    def write(self):
        print('mem write')

class Txt:
    def read(self):
        print('txt read')
    def write(self):
        print('txt write')

# 统一使用
obj1 = Cpu()
obj2 = Mem()
obj3 = Txt()

obj1.read()
obj1.write()
obj2.read()
obj2.write()
obj3.read()
obj3.write()

'''得到内存或者硬盘对象之后 只要想读取数据就调用read 想写入数据就调用write 不需要考虑具体的对象是谁'''

---

面向对象之反射

# 什么是反射
专业解释:指程序可以访问、检测和修改本身状态或者行为的一种能力
    
  大白话:其实就是通过字符串来操作对象的数据和功能
    
# 反射需要掌握的四个方法
  hasattr():判断对象是否含有字符串对应的数据或者功能
        
  getattr():根据字符串获取对应的变量名或者函数名
    
  setattr():根据字符串给对象设置键值对(名称空间中的名字)
    
  delattr():根据字符串删除对象对应的键值对(名称空间中的名字)
    
# 哪些对象可以使用反射

python中一切都是对象，所以都可以使用反射来进行自省

类可以对类的共有属性，方法（绑定方法，非绑定方法）进行反射

当前模块也可以进行反射 如：判定导入的模块是否有某个方法，有的化就进行调用。

反射的实际应用

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>

反射的好处

#反射的好处
实现可插拔机制 
就是可先判定某个对象（模块对象，类对象，对象等）是否有某个属性（是否插入），有则调用处理
没有（拔出）则走另一条逻辑
这样可以实现团队开发中 实现预定好接口 就算调用的接口没有具体完成，调用方也可以完成自己的逻辑

动态模块导入

#动态模块导入：a.import(模块名)函数 b. 使用importlib模块，使用importlib的import_module('模块名')

#动态导入模块使用场景：
1. 动态引用模块的变量，可以利用反射，切换其引用的模块，并使用模块中的属性。
2. 使用反射判断是否有对应属性，有则干嘛，没有则干嘛。 两种场景都是利用对象的反射来处理。核心就是利用字符串来驱动不同的事件，比如导入模块，调用函数等。

这是一种编程方法，设计模式的提现，凝聚了高内聚、松耦合的编程思想，不能简单的用执行字符串来代替。反射和exec()和eval（）不同。

反射的案例

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