面向对象之多态/反射

派生方法的更多应用

派生方法的更多应用
面向对象三大特性之封装
面向对象伪装
面向对象之反射
反射实战案例


import json
import datetime


a = {'t1':datetime.date.today(),
     't2':datetime.datetime.today(),
     't3':'moon'}

res = json.dumps(a)
print(res)


方式1:手动转类型


import json
import datetime

o = datetime.datetime.today()
o = o.strftime('%Y %m %d')
# 手动在外面直接转
a = {'t1':str(datetime.date.today()),
     #在里面直接转
     't2':o,
     't3':'moon'}

res = json.dumps(a)
print(res)



方式2：派生方法

'''
报错信息：
raise TypeError(f'Object of type {o.__class__.__name__} '
TypeError: Object of type date is not JSON serializable
'''

"""
查看dumps源码 注意cls参数 默认传JsonEncoder
查看该类的源码 发现default方法是报错的发起者，default的报错信息和我们获得的报错信息一直
编写类继承JsonEncoder并重写default方法 之后调用dumps手动传cls=我们自己写的类
"""

class Mydumps(json.JSONEncoder):
    def default(self,o):
         # 重新编写该方法
        if isinstance(o,datetime.datetime):
             # 判断是不是datetime.datetime类型，如果是则返回字符串格式时间
            return o.strftime('%Y %m %d %X')
        if isinstance(o,datetime.date):
             # 判断是不是datetime.date类型，如果是则返回字符串格式时间
            return o.strftime('%Y-%m-%d')
        return super().default(o)
        # 如果不是，那还是调用原来的方法不变
#
res = json.dumps(a,cls=Mydumps)
print(res)

面向对象三大特性之封装

封装：就是将数据和功能 封装 起来
隐藏：将数据和功能隐藏起来，用户不可以直接调用，而是开发一些接口间接调用，从而我们可以在接口内添加额外的操作

class MyClass:
    school_name = '倚天屠龙记'
    _ = '嘿嘿嘿'
    __name = '张无忌'
    '''
    类在定义阶段 名字前面有2个下划线 那么该名字就会被隐藏起来，
    无法直接访问
    '''
    def __choice_course(self):
         print('正在选课')

# obj = MyClass()
# print(obj.school_name)
# obj.__hobby = '九阳神功'
# #只有在定义阶段双下划线才会隐藏
# print(obj.__hobby)
# obj.__choice_course
# # 被隐藏的无法直接调用


class Person:
     def __init__(self,name,age):
          self.__name = name
          self.__age = age

     def get_info(self):
          # 在类体代码中是可以直接使用隐藏的名字
          print(f'''
          姓名：{self.__name}
          年龄：{self.__age}            
          ''')

     # 隐藏的属性开发修改的接口，可以自定义很多功能
     # 可以在执行命令前后添加更多操作
     def set_name(self,new_name):
          if len(new_name) == 0:
               raise ValueError('名字不能为空')
          if new_name.isdigit():
               raise ValueError('名字不可以是数字')
          self.__name = new_name


ojb = Person('张无忌',18)
ojb.get_info()
# 通过调用方法来查看对象内 隐藏的数据
ojb.set_name('张三丰')
# 通过调用方法来修改名字，
ojb.get_info()
ojb.set_name('')

'''
以后我们在编辑类的定义时，也会看到很多下划线开头的名字，表达的意思通常
都是不能直接访问，而是需要查找一下与之相关的方法接口
'''

面向对象伪装

举例说明：
BMI指数：衡量一个人的体重与身高对健康的影响
        计算公式  体重/身高**2
 class Person:
    def __init__(self, name, height, weight):
        self.name = name
         self.height = height
        self.weight = weight

    @property
    def BMI(self):
        return self.weight / (self.height ** 2)


 p1 = Person('张无忌', 1.70, 70)
 print(p1.BMI)

class Foo:
    def __init__(self, val):
        self.__NAME = val

    @property
    def name(self):
        return self.__NAME

    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            # 设置值之前进行类型检查
            raise TypeError(f'{value} must be str')
        self.__NAME = value
        # 将通过类型检查后，将值value存放到真实的位置
        
    @name.deleter
    def name(self):
        raise PermissionError('can not delete')

f1 = Foo('moon')
print(f1.name)
f1.name = 'jason'
# 其实这里是调用了@name.setter对应的函数，
print(f1.name)
f1.name = 123
# 这里是调用了@name.setter对应的函数.函数内设置非字符串类型数据就会报错
print(f1.name)

三大特性之多态

 class Animal:
     def spark(self):
         pass

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

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

# 例如动物的叫声，每个动物都有独特的叫声，但是这也可以称之为动物的
# 统一动作，都可以命名为叫声。
# 正确写法：
class Animal:
    def spark(self):
        pass


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


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

'''
面向对象中多态的意思是，一种事物可以有多种形态但是针对相同的功能应该定义
相同的方法，这也无论我们拿到的对象是什么，都可以通过同样的方法调用到该功能
'''

# linux系统
"""
文件      能够读取数据也能够保存数据
内存      能够读取数据也能够保存数据
硬盘      能够读取数据也能够保存数据
......
一切皆文件
"""
class File:
    def read(self): pass

    def write(self): pass


class Memory:
    def read(self): pass

    def write(self): pass


class Disk:
    def read(self): pass

    def write(self): pass

'''
例如这样：方法不同，但是里面的方法都是同样的操作，同一种意思，都是 读或者写
所以可以同样的命名，在python中我们要遵守这个规定 同样的方法尽力名称相同
'''

面向对象之反射

利用字符串操作对象的数据和方法
1.hasattr()
判断丢下是否含有某个字符串对应的属性名或方法名
2.getattr()
根据字符串获取对象对应的属性名或方法名
3.setattr()
根据字符串给对象设置或修改数据
4.delattr()
根据字符串删除对象里的名字

 class C1:
     name = '倚天屠龙记'

     def choice_course(self):
         print('张无忌牛逼')

 obj = C1()

 print(hasattr(obj,'name'))
 # 可以根据字符串类型来查询是否有这个 变量名
 print(getattr(obj,'name'))
 # 可以根据字符串类型来获取这个变量名
 print(getattr(obj,'choice_course'))

class C2:
    name = '倚天屠龙家'

    def choice(self):
        print('倚天一出谁与争锋')

obj = C1()
while True:
    target_name = input('请输入您想要操作的名字>>>:')
    if hasattr(obj, target_name):
        print('恭喜您 系统中有该名字')
        # 获取该名字对应的数据(值 函数)
        data_or_func = getattr(obj, target_name)
        if callable(data_or_func):
            print('您本次使用的是系统中的某个方法')
            data_or_func()
        else:
            print('您本次使用的是系统中的某个数据')
            print(data_or_func)
    else:
        print('很抱歉 系统中没有该名字')

反射实战案例

1.什么时候应该考虑使用反射 只要需求中出现了关键字
	对象....字符串....
 
# 模拟cmd终端

class Cmd:
    def tasklist(self):
        print('''
        1.学习python
        2.学习英语
        3.摆烂        
        ''')

    def ipconfig(self):
        print('''
        ip地址：120.2.1.0
        地址：伊拉克   
        ''')

    def get(self,target_file):
        print('获取指定文件',target_file)
    def put(self,target_file):
        print('上传指定文件',target_file)
    def server_run(self):
        print('欢迎来到cmd终端')
        while True:
            target_file = input('请输入您的指令')
            res = target_file.split(' ')
            if len(res) == 1:
                if hasattr(self,res[0]):
                  # 先判断用户输入的名称是否在类里面有
                    getattr(self,res[0])()
                    # 有就执行这个函数
                else:
                    print(f'{res[0]}不是内部或外部指令')
            elif len(res) == 2:
                if hasattr(self,res[0]):
                    getattr(self,res[0])(res[1])
                else:
                    print(f'{res[0]}不是内部或外部指令')

obj = Cmd()
obj.server_run()  



2. 一切皆对象
# # 模拟cmd终端
#
# class Cmd:
#     def tasklist(self):
#         print('''
#         1.学习python
#         2.学习英语
#         3.摆烂
#         ''')
#
#     def ipconfig(self):
#         print('''
#         ip地址：120.2.1.0
#         地址：伊拉克
#         ''')
#
#     def get(self,target_file):
#         print('获取指定文件',target_file)
#     def put(self,target_file):
#         print('上传指定文件',target_file)
#     def server_run(self):
#         print('欢迎来到cmd终端')
#         while True:
#             target_file = input('请输入您的指令')
#             res = target_file.split(' ')
#             if len(res) == 1:
#                 if hasattr(self,res[0]):
#                     getattr(self,res[0])()
#                 else:
#                     print(f'{res[0]}不是内部或外部指令')
#             elif len(res) == 2:
#                 if hasattr(self,res[0]):
#                     getattr(self,res[0])(res[1])
#                 else:
#                     print(f'{res[0]}不是内部或外部指令')
#
# obj = Cmd()
# obj.server_run()

import settings

可以直接把py文件也当作一个对象来处理

# 利用反射 保留某个py文件中所有的大写变量名和对应的数据值

print(dir(settings))
# dir 方法可以列举出该对象可以使用的所有名字

useful_dict = {}
for name in dir(settings):
    if name.isupper():
        useful_dict[name] = getattr(settings,name)
print(useful_dict)

while True:
    name = input('请输入某个名字')
    if hasattr(settings,name):
        print(getattr(settings,name))
    else:
        print('该模块中没有此名字')