python面向对象之反射

#!/usr/bin/env python
# coding:utf-8

# 反射
# 对象的自省
# python中四种方法 hasattr  getattr  setattr  delattr 都可用于类和对象, 因为python中一切皆对象, 类也是对象。
# python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

class black_intro:
    feture = ‘Ugly‘

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

    def sell_house(self):
        print(‘%s 正在卖房子，SB才买呢。‘ % self.name)

    def rent_house(self):
        print(‘%s 正在租房子，SB才租。‘ % self.name)


b1 = black_intro(‘众家地产‘, ‘苏州‘)

print(hasattr(b1, ‘name‘))
print(hasattr(b1, ‘rent_house‘))
print(hasattr(b1, ‘sale_house‘))  # False

print(getattr(b1, ‘name‘))
r = getattr(b1, ‘rent_house‘)
r()
print(getattr(b1, ‘age‘, ‘没找到它.‘))

setattr(b1, ‘group‘, ‘二货‘)
setattr(b1, ‘age‘, ‘11‘)
print(b1.__dict__)
setattr(b1, ‘agea‘, lambda x: x + 3)
setattr(b1, ‘func‘, lambda self: self.name + ‘SB公司‘)
print(b1.func(b1))
print(b1.agea(12))

delattr(b1, ‘name‘)
delattr(b1, ‘age‘)
print(b1.__dict__)

### 反射的应用场景  可插拨设计
# 可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用

from ftp_client import FtpClient

f1 = FtpClient(‘1.1.1.1‘)
# f1.put()

### hasattr 和 getattr 通常是配合使用，如果有xx方法，才去执行xx方法。
if hasattr(f1, ‘put‘):
    func_get = getattr(f1, ‘put‘)
    func_get()
else:
    print(‘其他的逻辑‘)


import sys

obj = sys.modules[__name__] # 当前模块  即自己所在模块

print(‘--------->‘,hasattr(obj,‘black_intro‘))  # 判断当前模块是否有属性

class FtpClient:
    ‘ftp客户端,但是还么有实现具体的功能‘
    def __init__(self,addr):
        print(‘正在连接服务器[%s]‘ %addr)
        self.addr=addr
    # def put(self):
    #     print(‘正在上传文件‘)

#!/usr/bin/env python
# coding:utf-8

# 类中内置的 __getattr__   __delattr__   __setattr__
# 只有 __getattr__ 最常用

class Foo:
    x = 1
    def __init__(self,y):
        self.y = y

    def __getattr__(self, item):  # 调用不存在的属性的时候会被执行
        print("---------------------")

    def __delattr__(self, item): # 删除的时候会调用
        print("执行了删除操作__delattr__")
        self.__dict__.pop(item)

    # def __setattr__(self, key, value):
    #     print("执行了__setattr__")
    #     # self.key=value # 这样会无限递归, 溢出
    #     self.__dict__[key] = value  # 直接操作字典，才是正确方式


f1 = Foo(9) # 当设置了__setattr__ 时，实例化的同时会自动执行它
print(f1.x)
f1.xxx # 触发 __getattr__

del f1.y # 删除时触发 __delattr__

f1.y1 = 33 # 设置时触发 __setattr__
print(f1.__dict__)

#!/usr/bin/env python
# coding:utf-8

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

    # def __getattr__(self, item):  # 调用不存在的属性的时候会被执行
    #     print("---------------------")
    #
    # def __delattr__(self, item): # 删除的时候会调用
    #     print("执行了删除操作__delattr__")
    #     self.__dict__.pop(item)

    def __setattr__(self, k, v):
        print(‘设置操作 __setattr__ ‘)
        # self.key=value # 这样会无限递归, 溢出
        # self.__dict__[k] = v  # 直接操作字典 是正确方式 
        if type(v) is str:
            print(‘可以设置‘)
            self.__dict__[k] = v.lower() # 且可以加上可控制的方法
        else:
            print(‘值 必须是字符串‘)


f2 = Foo(‘Alex‘)
f2.age =18
f2.gender =‘Male‘
print(f2.__dict__)

#!/usr/bin/env python
# coding:utf-8

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

    # def __getattr__(self, item):  # 调用不存在的属性的时候会被执行
    #     print("---------------------")

    def __delattr__(self, item): # 删除的时候会调用
        # print("执行了删除操作__delattr__")
        # self.__dict__.pop(item)
        print(‘不允许删除%s‘% item) # 可以控制不允许删除

    def __setattr__(self, k, v):
        print(‘设置操作 __setattr__ ‘)
        # self.key=value # 这样会无限递归, 溢出
        # self.__dict__[k] = v  # 直接操作字典
        if type(v) is str:
            print(‘可以设置‘)
            self.__dict__[k] = v.lower() # 且可以加上可控制的方法
        else:
            print(‘值 必须是字符串‘)


f2 = Foo(‘Alex‘)
f2.age =18
f2.gender =‘Male‘
print(f2.__dict__)
del f2.name
print(f2.__dict__)

#!/usr/bin/env python
# coding:utf-8

# 包装，来自于继承和派生的概念，根源是基于继承的标准类型。用来定制自己的方法
class List(list):
    def show_middle(self):
        mid_index = int(len(self)/2)
        return self[mid_index]

    # 自定义的append
    def append(self, obj):
        if type(obj) is str:
            super().append(obj)
        else:
            print("只能添加字符串")


l2 = list("azkaban")
print(l2,type(l2))
l3 = List(l2)
print(l3.show_middle())

l3.append(‘232‘)
print(l3)

#!/usr/bin/env python
# coding:utf-8

# 二次加工标准类型(包装)

class Foo:
    x = 1
    def __init__(self,y):
        self.y = y

    def __getattr__(self, item):  # 调用不存在的属性的时候会被执行
        print("[%s]属性不存在" % item)

    def __getattribute__(self, item): # 不管是否找到属性都会执行。
        print("执行了getattribute")
        raise AttributeError(‘抛出异常了。‘)  # 而在使用抛出异常之后，才会去执行 __getattr__


f2 = Foo(9)
print(f2.y)
# print(f2.age)

#!/usr/bin/env python
# coding:utf-8

import time

## 类似于组合的方法
class FH:
    def __init__(self,na,mo,ec="utf-8"):
        self.file = open(na,mo,encoding=ec)
        self.mode = mo
        self.encoding = ec

    def write(self,line):
        t = time.strftime(‘%Y-%m-%d %X ‘)
        self.file.write(‘%s %s‘%(t,line))

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

f1 = FH(‘a.txt‘, ‘r+‘)
f1.write(‘aaaaaaaaaaaaaaa\n‘)
f1.write(‘CPU温度过高\n‘)
f1.write(‘内存不足\n‘)
f1.write(‘硬盘剩余空间警告\n‘)
f1.seek(0)  # 其实执行的是打开的文件对象的seek方法

print(f1.read())

#!/usr/bin/env python
# coding:utf-8

class Foo:
    pass

class bar(Foo):
    pass


f1 = Foo()

print(isinstance(f1,Foo)) # 实例是否属于类
print(issubclass(bar,Foo)) # 参数1 是否 参数2 的子类

b1 = bar()
print(isinstance(b1,Foo)) # 也是True

print(type(b1)) # 查看实例的类是谁

#!/usr/bin/env python
# coding:utf-8

# 动态导入的方法：

# mt = __import__(‘m1.t‘) # 只能导入最顶级模块 点后面的不会被导入
# print(mt)
# m1.t.test1()
#
# from m1.t import test1,_test2
#
# test1()
# _test2()

import importlib

m = importlib.import_module(‘m1.t‘) # 动态导入就是基于反射的

print(m)
m.test1()
m.test2()

‘‘‘
动态导入模块方法1： __import__ 

说明：

　　1. 函数功能用于动态的导入模块，主要用于反射或者延迟加载模块。

　　2. __import__(module)相当于import module

举例说明：

首先创建一个模块目录lib,然后在目录内创建一个模块为：aa.py

模块代码为：

class c(object):
    def __str__(self):
        return ‘C language‘
在lib目录平级新建一个测试的模块，使用 __import__ 动态以字符串形式导入lib下的aa模块。

lib = __import__(‘lib.aa‘) # 相当于import lib
c = lib.aa.c()
print(c)
动态导入模块方法2：import importlib

实例还是上面的lib.aa模块，这里使用importlib进行动态导入（这个方法好理解，也是官方建议使用的）

import importlib
aa = importlib.import_module(‘lib.aa‘)
c = aa.c()
print(c)
‘‘‘