11月7日内容总结——派生方法实例、面向对象三大特性之封装、多态和反射

一、派生方法实战

这里的例子用到了dumps方法举例子，当我们使用dumps转换数据值的时候如果遇到变量名就会报错。通过ctrl+数据包左键点进去的方式查看内部的代码结构，我们发现dumps的注释中提到只有部分数据类型是可以转换的，像变量名那样的数据值并不在内。

之后我们看到代码中的cls关键字参数就是主动报错的代码。因此我们想到可以麻溜的用上派生方法，在发现当前数据类型不能直接转换的时候，我们获取这个变量名的数据值，然后给他送进去转换，就圆满达成目标了。当然，我们简单粗暴一点，把获得结果外面套个str()也可以达成目标

import json
import datetime

d = {
    't1': datetime.date.today(),
    't2': datetime.datetime.today(),
    't3': 'jason'
}
# res = json.dumps(d)
# print(res)
"""
序列化报错
raise TypeError(f'Object of type {o.__class__.__name__} '
TypeError: Object of type date is not JSON serializable
"""
"""
能够被序列化的数据是有限的>>>:里里外外都必须是下列左边的类型
    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+
"""
# 1.转换方式1:手动转类型(简单粗暴)
d = {
    't1': str(datetime.date.today()),
    't2': str(datetime.datetime.today())
}
res = json.dumps(d)
print(res)
# 2.转换方式2:派生方法(儒雅高端)
"""
查看dumps源码 注意cls参数 默认传JsonEncoder
查看该类的源码 发现default方法是报错的发起者
编写类继承JsonEncoder并重写default方法 之后调用dumps手动传cls=我们自己写的类
"""


class MyJsonEncoder(json.JSONEncoder):
    def default(self, o):
        """
        :param o: 接收无法被序列化的数据
        :return: 返回可以被序列化的数据
        """
        if isinstance(o, datetime.datetime):  # 判断是否是datetime类型 如果是则处理成可以被序列化的类型
            return o.strftime('%Y-%m-%d %X')
        elif isinstance(o, datetime.date):
            return o.strftime('%Y-%m-%d')
        return super().default(o)  # 最后还是调用原来的方法 防止有一些额外操作没有做


res = json.dumps(d, cls=MyJsonEncoder)
print(res)

二、面向对象三大特性之封装

隐藏属性

Python的Class机制采用双下划线开头的方式将属性隐藏起来（设置成私有的），但其实这仅仅只是一种变形操作，类中所有双下滑线开头的属性都会在类定义阶段、检测语法时自动变成“_类名__属性名”的形式：

class Foo:
    __N=0 # 变形为_Foo__N
    
    def __init__(self): # 定义函数时，会检测函数语法，所以__开头的属性也会变形
        self.__x=10 # 变形为self._Foo__x
        
    def __f1(self): # 变形为_Foo__f1
        print('__f1 run')
    
    def f2(self):  # 定义函数时，会检测函数语法，所以__开头的属性也会变形
        self.__f1() #变形为self._Foo__f1()
 
print(Foo.__N) # 报错AttributeError:类Foo没有属性__N
 
obj = Foo()
print(obbj.__x) # 报错AttributeError:对象obj没有属性__x

虽然我们发现这些类中定义的名字不能直接用了，但是我们需要知道这些类中的双下开头的名字只是变了个形式，如果我们知道了这些名字的格式和种类名称，就可以使用全程访问类中的隐藏起来的名字。

同时，我们在类中定义别的函数调用这些隐藏起来的函数的话，是不需要写上隐藏后的名字的，直接调用函数即可。

注：python中没有绝对的隐藏，因此要不要直接用这些隐藏函数也是一种君子规定。

如何调用隐藏属性

class MyClass:
    school_name = '老女孩大学'
    _ = '嘿嘿嘿'
    _name = 'tony'
    '''类在定义阶段 名字前面有两个下划线 那么该名字会被隐藏起来 无法直接访问'''
    __age = 18
    """在python中其实没有真正意义上的隐藏 仅仅是换了个名字而已 _类名__名字"""
    def __choice_course(self):
        print('老北鼻正在选课')


print(MyClass.school_name)
# 老女孩大学
obj = MyClass()
print(obj.school_name)
# 老女孩大学
print(MyClass._)
# 嘿嘿嘿
print(MyClass._name)
# tony
MyClass.__hobby = 'JDB'  # 无法隐藏
print(MyClass.__hobby)
# JDB
obj = MyClass()
obj.__addr = '派出所'
print(obj.__addr)
# 派出所
print(MyClass.__dict__)
# {'__module__': '__main__', 'school_name': '老女孩大学', '_': '嘿嘿嘿', '_name': 'tony', '_MyClass__age': 18, '_MyClass__choice_course': <function MyClass.__choice_course at 0x00000222BC04A4C0>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None, '__hobby': 'JDB'}
print(MyClass._MyClass__age)
# 18

• 通过上面的代码进行尝试后，我们发现在python中其实没有真正意义上的隐藏，仅仅是换了个名字而已，_类名__名字。

• 同时只有在类的定义阶段，名字前面有两个下划线的名称才会被隐藏起来，无法直接访问。如果在对象中使用两个下划线+名称的方式，得到的只是一个普通的变量名，并没有隐藏的效果。

隐藏属性的作用和使用方式

将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格地控制

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

class Person:
    def __init__(self, name, age, hobby):
        self.__name = name  # 对象也可以拥有隐藏的属性
        self.__age = age
        self.__hobby = hobby

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

    # 隐藏的属性开放修改的接口 可以自定义很多功能
    def set_name(self, new_name):
        if len(new_name) == 0:
            raise ValueError('你好歹写点东西')
        if new_name.isdigit():
            raise ValueError('名字不能是数字')
        self.__name = new_name


obj = Person('jason', 18, 'read')
obj.get_info()
# obj.set_name('tony老师')
# obj.get_info()
obj.set_name('')

这里我们把人这个类创建时候的属性变成隐藏的，同时定义查看函数查案和修改这些隐藏的值（也就是创建接口进行控制）

以后我们在编写面向对象代码类的定义时，也会看到很多单下划线开头的名字，表达的意思通常是提示不要直接访问，而是让我们查找一下，下面可能了定义了接口。

三、伪装

伪装的操作

可以将类中的函数“伪装成”对象的数据属性，对象在访问该特殊属性时会触发功能的执行，然后将返回值作为本次访问的结果（将类里面的方法伪装成类里面的数据）

这里我们使用BMI的计算来引入伪装的装饰器和语法糖：

# BMI指数:衡量一个人的体重与身高对健康影响的一个指标
#     体质指数（BMI）=体重（kg）÷身高^2（m）
# 	 EX：70kg÷（1.75×1.75）=22.86

class Person(object):
    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('jason', 1.83, 78)


# p1.BMI()  # BMI应该作为人的基本数据而不是方法
# print(p1.BMI)  # 利用装饰器伪装成数据

这里介绍了property装饰器，它的功能很简单，就是实现伪装的功能，让我们节省掉用时候的小括号，并且把函数运行的结果输出。

两个小功能：删除和修改

@name.setter

这个是修改值

@name.deleter

这个是删除值

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('%s must be str' % value)
        self.__NAME = value  # 通过类型检查后,将值value存放到真实的位置self.__NAME

    @name.deleter
    def name(self):
        raise PermissionError('Can not delete')


f = Foo('jason')
print(f.name)
f.name = 'jason123'
print(f.name)
del f.name
# f.name = 'jason'  # 触发name.setter装饰器对应的函数name(f,’jason')
# f.name = 123  # 触发name.setter对应的的函数name(f,123),抛出异常TypeError
# del f.name  # 触发name.deleter对应的函数name(f),抛出异常PermissionError

四、面向对象三大特性之多态

概念讲解

多态更像是一种概念，一种墨守成规的约定，当我们在创建类的时候，如果出现几个功能相似的类，那我们在定义他们内部方法的时候需要把类似的功能名称设置成一样，这样的话当我们调用的时候不用刻意记忆方法名称，统一使用即可。

举例说明：

现实中水有很多形态，固态液态和气态。这里我们拿气态举例，不是只有水才能是气态，其他的很多物质也可以在特定条件下变成气态，但是当我们描述气态的东西时，使用的语言和探究的方向都是相同的。这些相同的东西就跟多态要求的作用是一样的。

这里我们引入python崇尚的‘鸭子类型’（duck typing）：“如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子”。

class Animal:
    def spark(self):
        '''叫的方法'''
        pass


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


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


class Pig(Animal):
    # def heng(self):
    #     print('哼哼哼')
    def spark(self):
        print('哼哼哼')

面向对象中多态意思：

一种事物可以有多种形态，但是针对相同的功能应该定义相同的方法。这样无论我们拿到的是哪个具体的事物，都可以通过相同的方法调用功能。

s1 = 'hello world'
l1 = [11, 22, 33, 44]
d = {'name': 'jason', 'pwd': 123}
print(s1.__len__())
print(l1.__len__())
print(d.__len__())

比如这里的双下len方法，不同数据类型调用的时候都是使用相同的函数名调用功能。

文件 能够读取数据也能够保存数据
内存 能够读取数据也能够保存数据
硬盘 能够读取数据也能够保存数据
......

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中一切皆对象）

多态中的约束方法

虽然python永远提倡自由简介大方，不约束程序员行为，但是多态提供了约束的方法。

导入abc模块后使用装饰器@abc.abstractmethod，我们可以发现必须要有一个名为talk的方法，这里就相当于强制要求了，内部功能可以自定义。

import abc


# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod  # 该装饰器限制子类必须定义有一个名为talk的方法
    def talk(self):  # 抽象方法中无需实现具体的功能
        pass


class Cat(Animal):  # 但凡继承Animal的子类都必须遵循Animal规定的标准
    def talk(self):
        pass


cat = Cat()  # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化

五、面向对象之反射

推导思路

1、当我们用对象进行操作的时候，修改查看数据值都是用点的方式+名称

2、为了让这个代码简洁一点，我们想到使用input获取用户输入，然后用参数的形式来调用

3、但是这时候我们还是发现不行，因为input获取的是字符串，不是变量名那样的形式，导致报错。

4、虽然这里走到死胡同了，但是python做了反射这个东西来实现对象和用户的交互。

反射功能介绍

在Python中，反射指的是通过字符串来操作对象的属性，涉及到四个内置函数的使用：

1.hasattr() 重点

• 判断对象是否含有某个字符串对应的属性名或方法名

2.getattr() 重点

• 根据字符串获取对象对应的属性名(值)或方法名(函数体代码)

3.setattr()

• 根据字符串给对象设置或者修改数据

4.delattr()

• 根据字符串删除对象里面的名字

class Teacher:
    def __init__(self,full_name):
        self.full_name =full_name
 
t=Teacher('jason Lin')
 
# hasattr(object,'name')
hasattr(t,'full_name') # 按字符串'full_name'判断有无属性t.full_name
 
# getattr(object, 'name', default=None)
getattr(t,'full_name',None) # 等同于t.full_name,不存在该属性则返回默认值None
 
# setattr(x, 'y', v)
setattr(t,'age',18) # 等同于t.age=18
 
# delattr(x, 'y')
delattr(t,'age') # 等同于del t.age

六、反射案例

cmd终端（简易版）

这里我们用代码创建一个建议的cmd终端（当然了，内部数据弄简陋一点也没事）：

# 模拟cmd终端


class WinCmd:
    def tasklist(self):
        print("""
            1.学习编程
            2.学习python
            3.学习英语
            """)


    def ipconfig(self):
        print("""
                地址:127.0.0.1
                地址:上海浦东新区
                """)


    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_cmd = input('请输入您的指令>>>:')
            res = target_cmd.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 = WinCmd()
obj.server_run()

总体思路如下：

1、我们创个类当成小的cmd

2、类中定义各个函数充当执行命令时的功能

3、弄一个启动函数，内部需要具备相应的逻辑关系来调用其他功能函数。比如我们考虑到cmd中的命令是用一个空格隔开的，因此我们用split通过空格分开数据值，然后如果是一个的数据值，直接把他放到getatter中执行获取结果，如果长度不是一个的话就我们就把第二个的数据值当成参数传给第一个数据值代表的方法。如果还有别的更长的方法，那就要另外写代码设置了。

从文件中拿名字（简单证明一切皆对象）

import settings

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:
    target_name = input('请输入某个名字')
    if hasattr(settings, target_name):
        print(getattr(settings, target_name))
    else:
        print('该模块文件中没有该名字')

思路：

1、我们把一个文件当模块直接导入，并用dir方法查看内部有那些名字

2、根据名字的种类，分成方法名称和变量名称

3、根据当前打开的是settings文件，我们想到内部名称需要都是大写，因此我们用一个for循环筛选出大写的名称

4、我们跟第一个例子一样，用input获取输入然后使用hasatter判断有没有这玩意，然后有的话就打印结果，没得话就返回提示信息。

七、作业

尝试利用反射编写一个简易版本的用户增删改查功能

# 尝试利用反射编写一个简易版本的用户赠删改查功能
class userinfor:
    def __init__(self, name, age, job):
        self.name = name
        self.age = age
        self.job = job

    def check_infor(self):
        for i in self.__dict__:
            print(f'{i}:{getattr(self, i)}')
        return '信息查看完成'

    def change_infor(self):
        property_name = input('请输入需要修改的属性的名称：').strip()
        infor = input('请输入修改后的信息：').strip()
        if hasattr(self, property_name):
            setattr(self, property_name, infor)
            return f'{property_name}属性成功修改成{infor}'
        else:
            return '当前属性名称不存在'

    def add_infor(self):

        property_name = input('请输入需要添加的属性的名称：').strip()
        infor = input('请输入属性的信息：').strip()
        if hasattr(self, property_name):
            return '当前属性名称已存在'
        else:
            setattr(self, property_name, infor)
            return f'成功添加{property_name}属，值为{infor}'

    def del_infor(self):
        del_infor_name = input('请输入需要删除的属性的名称：')
        if hasattr(self, del_infor_name):
            delattr(self, del_infor_name)
            return f'{del_infor_name}属性删除成功'
        else:
            return '当前属性名称不存在'

    def run(self):
        while True:
            func_choice = input('''
功能如下：
1、查看用户信息（功能名称：check_infor）
2、修改用户信息（功能名称：change_infor）
3、删除用户信息（功能名称：del_infor）
4、增加用户信息（功能名称：add_infor）
请输入需要执行的功能名称：
            ''').strip()
            if hasattr(self, func_choice):
                print(getattr(self, func_choice)())
            else:
                print('功能名称错误')


zzh = userinfor('zzh', 18, 'student')
# print(zzh.check_infor())

zzh.run()