一. 反射

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）
在Python中反射的表现形式是：
通过字符串的形式操作对象相关的属性
在Python中通过四个函数实现反射：

class People:
    country = 'China'

    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def eat(self):
        print('%s is eating' % self.name)

    def sleep(self):
        print('% is sleeping' % self.name)

p1=People('Jack', 'male')

#检测是否含有某属性
print(hasattr(p1, 'name'))
print(hasattr(p1, 'eat'))

>>True
>>True

#获取属性
n = getattr(p1, 'name')
print(n)
func = getattr(p1, 'eat')
func()
getattr(p1, 'aaaaaaaa') #报错
print(getattr(p1, 'aaaaaaaa', 'not exist'))
>>Jack
>>Jack is eating
>>not exist

#设置属性
setattr(p1, 'Joe', 'female')
setattr(p1, 'run', lambda self: self.name+' is running')
print(p1.__dict__)
print(p1.run(p1))
>>{'name': 'Jack', 'gender': 'male', 'Joe': 'female', 'run': <function <lambda> at 0x0000021D2B3E3E18>}
>>Jack is running

#删除属性
print(p1.__dict__)
delattr(p1, 'name')
print(p1.__dict__)
>>  {'name': 'Jack', 'gender': 'male'}
>>{'gender': 'male'}
#只能删除对象的属性，如果是类那么只能删类的方法，如果是类实例化的对象只能删实例化对象的属性不能删类的，比如说执行delattr(p1, 'eat')会报错，如果删除的属性不存在也报错

反射当前模块成员

import sys


def s1():
    print('s1')


def s2():
    print('s2')


this_module = sys.modules[__name__]

print(hasattr(this_module, 's1'))
print(getattr(this_module, 's2'))

使用反射的用途

可插拔

可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用
建立``ftpClient.py`模块

class FtpClient:    # 仅定义，不实现具体方法
    def __init__(self, addr):
        print('正在连接服务器[%s]' % addr)
        self.addr = addr

建立ftpServer.py模块

from ftpClient import FtpClient

f1=FtpClient('192.168.1.1')
if hasattr(f1,'get'):
    func_get=getattr(f1,'get')
    func_get()
else:
    print('not exist')

>>正在连接服务器[192.168.1.1]
not exist

动态导入模块

通过字符串名称导入模块

import importlib
t = importlib.import_module('time')
print(t.time())

二. attr内置函数

__setattr__， __delattr__，__getattr__

class Foo:
    def __init__(self, name):
        self.name = name

    def __setattr__(self, key, value):
        print('running __setattr__')
        self.__dict__[key] = value

    def __getattr__(self, item):
        print('running __getattr__')
        pass

    def __delattr__(self, item):
        print('running __delattr__')
        self.__dict__.pop(item)

f = Foo('Jack')
print(f.__dict__)

f.name = 'Jax'
print(f.__dict__)

del f.name

print(f.__dict__)

f.xxx    #调用不存在的属性时才会触发__getattr__

>>running __setattr__
>>{'name': 'Jack'}
>>running __setattr__
>>{'name': 'Jax'}
>>running __delattr__
>>{}
>>running __getattr__ 

三. 定制自己的数据类型

包装

对已有的类型具有的功能进行扩展

class List(list):
    def append(self, p_object):
        if not isinstance(p_object, str):
            raise TypeError('must be str')
        super().append(p_object)

    @property
    def mid(self):  # 增加属性
        index = len(self) // 2
        return self[index]


l = List()
l.append('oo')
l.append('jj')
l.insert(0, 'ii')
print(l)
print(l.mid)

授权

授权：授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。

实现授权的关键点就是覆盖getattr方法

import time

class FileHandle:
    def __init__(self, filename, mode='r', encoding='utf-8'):
        self.file = open(filename, mode, encoding=encoding)
        self.mode = mode
        self.encoding = encoding

    def write(self, line):
        print('running write operation')
        t = time.strftime('%Y-%m-%d %X')
        self.file.write('[%s] %s' % (t, line))

    def __getattr__(self, item):
        return getattr(self.file, item)

f = FileHandle('a.txt', 'w+')

f.write('777')    # 通过授权实现执行write函数时，为所写内容添加时间
f.seek(0)
print(f.read())