内容概要
- 面向对象之反射
- 反射实际案例
- 面向对象的双下方法
- 笔试题讲解
- 元类
- 元类简介
- 产生类的两种表现形式
- 元类的基本使用
- 元类进阶操作
- 双下new方法
内容详情
# 什么是反射
专业解释:指程序可以访问、检测和修改本身状态或者行为的一种能力
大白话:其实就是通过字符串来操作对象的数据和功能
# 反射需要掌握的四个方法
hasattr():判断对象是否含有字符串对应的数据或者功能
getattr():根据字符串获取对应的变量名或者函数名
setattr():根据字符串给对象设置键值对(名称空间中的名字)
delattr():根据字符串删除对象对应的键值对(名称空间中的名字)
# 反射实际应用
class Student(object):
school = '清华大学'
def get(self):
pass
# 编写一个小程序 判断Student名称空间中是否含有用户指定的名字 如果有则取出展示
# print(Student.__dict__)
'''字符串的school 跟 变量名school差距大不大? 本质区别'''
guess_name = input('请输入你想要查找的名字>>>:').strip() # 不使用反射不太容易实现
1.hasattr()
print(hasattr(Student, 'school')) # True
print(hasattr(Student, 'get')) # True
print(hasattr(Student, 'post')) # False
2.getattr()
print(getattr(Student, 'school')) # 清华大学
print(getattr(Student, 'get')) # <function Student.get at 0x10527a8c8>
'''
guess_name = input('请输入你想要查找的名字>>>:').strip()
if hasattr(Student, guess_name):
target_name = getattr(Student, guess_name)
if callable(target_name):
print('类中有一个功能名字是%s'%guess_name,target_name)
else:
print('类中有一个数据名字是%s'%guess_name,target_name)
else:
print('类中没有该名字')
'''
3.setattr()、delattr()
setattr(Student,'level','贵族学校') # print(Student.__dict__)
def index():
pass
obj = Student()
setattr(obj, '血量', 10000)
setattr(obj, '功能', index)
# print(obj.__dict__)
delattr(obj, '功能')
print(obj.__dict__)
"""
什么时候使用反射 可以记固定的口诀
以后只要在业务中看到关键字 对象 和 字符串(用户输入、自定义、指定) 那么肯定用反射
"""
# 利用反射获取配置文件中的配置信息
"""一切皆对象 文件也是对象"""
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()
# 利用面向对象编写系统终端功能
class WinCmd(object):
def ls(self):
print('windows系统正在执行ls命令')
def dir(self):
print('windows系统正在执行dir命令')
def cd(self):
print('windows系统正在执行cd命令')
class LinuxCmd(object):
def ls(self):
print('Linux系统正在执行ls命令')
def dir(self):
print('Linux系统正在执行dir命令')
def cd(self):
print('Linux系统正在执行cd命令')
obj = WinCmd()
obj1 = LinuxCmd()
"""反射提供了一种不需要考虑代码的前提下 操作数据和功能"""
def run(obj):
while True:
cmd = input('请输入您的指令>>>:')
if hasattr(obj, cmd):
func_name = getattr(obj, cmd)
func_name()
else:
print('cmd command not found')
run(obj1)
run(obj)
"""
面向对象中的双下方法也有一些人称之为是魔法方法
有些双下方法不需要刻意调用 到达某个条件会自动触发
__init__ 对象实例化的时候自动触发
"""
class MyClass(object):
def __init__(self, name):
self.name = name
def __str__(self):
# print('我到底什么时候触发')
# return '对象:%s'%self.name
pass
def __del__(self):
# print("del啥时候执行")
pass
def __getattr__(self, item):
# print('__getattr__方法', item)
# return '不好意思 没有%s这个名字'%item
pass
def __setattr__(self, key, value):
# print('__setattr__方法')
# print(key, value)
# if key == 'gender':
# raise Exception('你没有资格拥有gender')
# if not key.islower():
# raise Exception('名字只能小写')
super().__setattr__(key, value)
def __call__(self, *args, **kwargs):
print('__call__方法',args,kwargs)
return '嘿嘿嘿'
def __enter__(self):
print('__enter__方法')
def __exit__(self, exc_type, exc_val, exc_tb):
print('__exit__方法')
def __getattribute__(self, item):
print('__getattribute__方法', item)
obj = MyClass('jason')
1.__str__
对象被执行打印(print、前端展示)操作的时候自动触发
该方法必须返回字符串类型的数据
很多时候用来更加精准的描述对象
print(obj) # 没有__str__方法 <__main__.MyClass object at 0x102f39240>
print(obj) # 返回__str__方法的返回值 对象:jason
2.__del__
对象被执行(被动、主动)删除操作之后自动执行
print('哈哈哈') # 程序正常运行结束 被动删除
'''
哈哈哈
del啥时候执行
'''
del obj # 使用del关键字主动删除
'''
del啥时候执行
哈哈哈
'''
3.__getattr__
对象查找不存在名字的时候自动触发
返回值 return '不好意思 没有%s这个名字'%item
print(obj.name) # jason
obj.age # __getattr__方法 item (type（item）>>><class 'str'>）
print(obj.age) # 不好意思 没有age这个名字
没有__getattr__方法对象查找不存在报错
4.__setattr__
对象在执行添加属性操作的时候自动触发 >>> obj.变量名=变量值
obj.AGE = 18 # 报错（key>>>AGE,value>>>18）
5.__call__
对象被加括号调用的时候自动触发
没有__call__方法对象加括号调用报错
obj(123) # __call__方法 (123) {}
print(obj()) # 嘿嘿嘿
6.__enter__
对象被执行with上下文管理语法开始自动触发
该方法返回什么as后面的变量名就会得到什么
__exit__
对象被执行with上下文管理语法结束之后自动触发
with语法
with obj as f:
__enter__()
pass
__exit__()
7.__getattribute__(与__getattr__相似)
只要对象查找名字无论名字是否存在都会执行该方法
如果类中有__getattribute__方法 那么就不会去执行__getattr__方法
1.让字典具备句点符查找值的功能
# 1.定义一个类继承字典
class MyDict(dict):
def __getattr__(self, item):
return self.get(item)
def __setattr__(self, key, value):
self[key] = value
'''要区别是名称空间的名字还是数据k:v键值对'''
obj = MyDict({'name':'jason','age':18})
1.具备句点符取v
print(obj.name)
print(obj.age)
2.具备句点符设k:v
obj['gender'] = 'male'
obj.pwd = 123 # 给字典名称空间添加名字 不是数据k:v
print(obj)
2.补全下列代码 使其运行不报错
"""
class Context:
pass
with Context() as ctx:
ctx.do_something()
"""
class Context:
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
def do_something(self):
pass
with Context() as ctx:
ctx.do_something()
# 元类 即产生类的类
print(type(123))
print(type([12, 33, 44]))
print(type({'name':'jason','pwd':123}))
# type查看的其实是当前对象所属的类名称
class MyClass(object):
pass
obj = MyClass()
print(type(obj))
print(type(MyClass)) # <class 'type'>
class Student:
pass
print(type(Student)) # <class 'type'>
class Teacher(MyClass):
pass
print(type(Teacher)) # <class 'type'>
'''type就是所有类默认的元类!!!'''
1.class关键字
class C1(object):
pass
print(C1) # <class '__main__.C1'>
2.type元类
type(类名,父类,类的名称空间)
res = type('C1', (), {})
print(res) # <class '__main__.C1'>
"""
学习元类的目的
元类能够控制类的创建 也就意味着我们可以高度定制类的行为
eg:掌握了物品的生产过程 就可以在过程中做任何的额外操作
比如:要求类的名字必须首字母大写
思考在哪里编写定制化代码
类的产生过程目前还比较懵 元类里面的__init__方法
对象的产生过程呢 类里面的__init__方法
方法:由已知推未知
"""
"""元类是不能通过继承的方式直接指定的"""
需要通过关键字参数的形式修改
class C1(metaclass=MyTypeClass):
pass
class MyTypeClass(type):
def __init__(cls, cls_name, cls_bases, cls_dict):
# print(cls, cls_name, cls_bases, cls_dict)
if not cls_name.istitle():
raise Exception("类名的首字母必须大写 你个SD")
super().__init__(cls_name, cls_bases, cls_dict)
class C1(metaclass=MyTypeClass):
school = '清华大学'
class a(metaclass=MyTypeClass):
school = '清华大学'
回想__call__方法
对象加括号会自动执行产生该对象的类里面的__call__,并且该方法返回什么对象加括号就会得到什么
推导:类加括号会执行元类的里面的__call__该方法返回什么其实类加括号就会得到什么
"""类里面的__init__方法和元类里面的__call__方法执行的先后顺序"""
class MyTypeClass(type):
def __call__(self, *args, **kwargs):
print('__call__ run')
super().__call__(*args, **kwargs)
class MyClass(metaclass=MyTypeClass):
def __init__(self, name):
print('__init__ run')
self.name = name
obj = MyClass('jason')
__call__ run
__init__ run
# 定制对象的产生过程
class MyTypeClass(type):
def __call__(self, *args, **kwargs):
# print('__call__ run')
# print(args,kwargs)
if args:
raise Exception('必须全部采用关键字参数')
super().__call__(*args, **kwargs)
class MyClass(metaclass=MyTypeClass):
def __init__(self, name):
# print('__init__ run')
self.name = name
"""强制规定:类在实例化产生对象的时候 对象的独有数据必须采用关键字参数"""
obj1 = MyClass('jason') # 报错
obj2 = MyClass(name='jason')
"""
如果你想高度定制类的产生过程
那么编写元类里面的__init__方法
如果你想高度定制对象的产生过程
那么编写元类里面的__call__方法
"""
__new__用于产生空对象(类) 骨架
__init__用于实例化对象(类) 血肉
class MyTypeClass(type):
# def __new__(cls, *args, **kwargs):
# print('__new__ run')
# return super().__new__(cls, *args, **kwargs)
#
# def __init__(cls,cls_name, cls_bases, cls_dict):
# print('__init__ run')
# super().__init__(cls_name, cls_bases, cls_dict)
def __call__(self, *args, **kwargs):
# 1.产生一个空对象
obj = object.__new__(self,*args, **kwargs)
# 2.调用init方法实例化
return obj
class MyClass(metaclass=MyTypeClass):
def __init__(self, name):
self.name = name
obj = MyClass('jason')
print(obj)
"""
注意:并不是所有的地方都可以直接调用__new__ 该方法过于底层
如果是在元类的__new__里面 可以直接调用
class Meta(type):
def __new__(cls, *args, **kwargs):
obj = type.__new__(cls,*args,**kwargs)
return obj
如果是在元类的__call__里面 需要间接调用
class Mate(type):
def __call__(self, *args, **kwargs):
obj = object.__new__(self) # 创建一个空对象
self.__init__(obj,*args,**kwargs) # 让对象去初始化
return obj
"""
浙公网安备 33010602011771号