标签：核心 def 另一个 __call dir 需求 设置 字符串 索引
一、反射
定义：通俗的理解其实反省，自省的意思
反射值的时一个对象具备在增 删 改 查 得的属性你能力
操作方法：通过操作字符串操作属性
反射：设计的四个函数：hasattr ,get attr, setattr , dleattr 者四个 函数就是普通内置函数，没有双下划线，就像print,sort,len() 区别于__getattr__ 函数操作
# 使用场景：
# 反射其实就是对属性增删改查，如果直接使用内置dict,太过于繁琐，不好理解
# 反射是框架的基石，为什么
1.1 实列一：
class Person: def __init__(self,name,age): self.name = name self.age = age p = Person("Sen", 18) if hasattr(p, ‘name‘): # print(getattr(p,‘name‘)) setattr(p, ‘id‘, 123) # 注意setattr 设置值的时候是有三个值的(对象，‘key’ ,value) print(p.id) # delattr(p, ‘id‘) # ttributeError: ‘Person‘ object has no attribute ‘id‘ # print(p.id) # 此时‘id’已被删除
print(p, ‘id‘) 此时是不会取到对象的值的
1.2 案例二：默认Djiang中间件 实现对象 的调用
前戏：
# 使用场景： # 反射其实就是对属性增删改查，如果直接使用内置dict,太过于繁琐，不好理解 # 反射是框架的基石，为什么因位框架设计者补课不可能提前知道你的对象到底是怎么 # 设计的所以你提供给框架的对象 必须通过判断验证之后才能正常使用 # 判断就是反射要做的事情，当然也可以通过__dict__也可以实现的，其实这些方法也就对__dict__的操作进行了封装 # 需求：要实现一个用于处理用户的终端指令的小框架 # 框架：已经实现了最基础的架构代码逻辑，就是所有项目都是一样的部分
# 框架 的根据配置 文件拿到所需的类
class WinCmd: def cd(self): print(‘windcmd 切换目录。。。‘ ) def delete(self): print(‘windcmd ..。删库‘) def dir(self): print(‘wind 列出当前的所有文件‘) class LinCmd: def cd(self): print(‘lindcmd 切换目录。。。‘ ) def rm(self): print(‘lindcmd ..。删库‘) def ls(self): print(‘lincmd 列出所有文件‘)
通过模块导入对象 实列化 调用
# 导入刚才的库 from day24.lib import my_work def run(my_work): while True: cmd = input(‘输入指令‘) if cmd == ‘exit‘: break if hasattr(my_work,cmd): func = getattr(my_work,cmd) func() # else: print(‘不支持‘) print(‘再见！！！‘) wind = my_work.WinCmd() run(wind)
很明显上述中我们的设计框架中写死必须用某个类，这是不合理的 以为我们无法提前预知对方的类在什么地方以及类名 所以我们应该为框架的使用者提供一个配置文件，要求对方将类写入文件 然后框架自己可以加载需要的模块
实现代码：
二、元类
"""该文件为框架的配置文件"""
# 作为框架的使用者，在配置文件中指定你配合框架的类是哪个
CLASS_PATH = ‘lib.my_work.WinCmd‘
# 导入刚才的库 import importlib from day24.lib import my_work from day24 import settings def run(my_work): while True: cmd = input(‘输入指令‘) if cmd == ‘exit‘: break if hasattr(my_work,cmd): func = getattr(my_work,cmd) func() # else: print(‘不支持‘) print(‘再见！！！‘)
# 创建一个插件对象 调用库框架来使用
# wind = my_work.WinCmd()
# run(wind)
# 很明显这种实现不是完全的合理
# 所以需要 根据文件拿到需要的类
path = settings.CLASS_PATH
# 从配中单独拿出来 模块路径 和 类名称
print(path.rsplit(‘.‘,1)) # [‘lib.my_work‘, ‘WinCmd‘] 者按照点切割的列表解压赋值
module_path, class_name = path.rsplit(‘.‘, 1)
# res = path.rsplit(‘.‘,1)
print(class_name)
# 拿到模块
mk = importlib.import_module(module_path)
print(mk) # <module ‘lib.my_work‘ from ‘D:\\datas\\day24\\lib\\my_work.py‘>
print(class_name)
# 拿到类
cls = getattr(mk,class_name)
print(cls)
obj = cls()
# 调用框架
run(obj) 实现代码 调
obj 也就是这个类的实列对象class WinCmd
""" 在框架设计中 我们不可能提前知道 框架的用户要提供类相关的信息 """ import importlib import abc # 拿到模块 根据模块的路径 pl = importlib.import_module("libs.plugins") print(pl) # 从模块中取出类 cls = getattr(pl,"WinCMD") print(cls) # 实例化产生对象 obj = cls() obj.cd()
二、元类
2.1 定义：什么元类：用于创建类的类，万物皆对象，类也是对象（类对象）对象是通过 类实列化产生，类对象也是另一个了实例化产生的
默认情况下所有类的元类都是type 类的类是type
# type 可以自定义类 拦截的类的产生 # 我们的需求是创建类对象做一些限制 # 实现方法一 既然是创建想到了初识化方法 我们只要找到类对象的类（元类） # 覆盖init 方法就能实现需求 # 只要继承type类 那么这个类就变成了一个元类 # 自定义类 first
实现代码：
lass MyClass(type): # 元类 # 拦截在父类产生Student 初始化走 的__init__ def __init__(self,class_name,bases,dict): # self Student 类对象、 print(self) # 类 对象 <class ‘__main__.Student‘> print(class_name) # 类名 print(bases) print(dict) super().__init__(class_name, bases, dict) # 重写父类放入方法 if not class_name.istitle(): # 限制类的产生过程 必需满足我们限制的条件 raise Exception(‘大哥不能呐必需是首字母大写‘) else: print(‘创建类成功‘)
我们要自定义的类
class Student(metaclass=MyClass): # 自定义这个类怎么 重新type def __init__(self,name,age,b): self.name = name self.age = age self.b = b a = Student(‘KOKO‘,(1,2),b=1) # 实列化 # __new__ print(a.__dict__) # {‘name‘: ‘KOKO‘, ‘age‘: (1, 2), ‘ui‘: {}}
方法二其实就是内部本质先走元类自己的__new__ 1.元类中构建类再 返回类对象
# 默认继承type 的类称为元类 # 类的创建第二种方法__new__ # __new__是帮我们创建类对象的初始化进行添加限制 class Myself(type): # 继承type >>>元类 def __new__(cls, *args, **kwargs): # cls 是Myself # 方法一 # return super().__new__(cls,*args,**kwargs) # 必需返回给__init 生成相应的类，并返回 # 方法二 obj = type.__new__(cls, *args, **kwargs) # 在元类中该函数用来构建类本身 return obj # 返回一个对象 给__init__ # 在类中，该函数用来构建类实例 def __init__(self, a, b, c): super().__init__(a, b, c) print(‘实列创建类‘) class Teacher(metaclass=Myself): # 限制老师类的产生 pass 属性 Teacher()
分为两个阶段：
1.类的生成：由元类生成；
2.实例的生成：由上述生成的类接着生成。
具体描述：
结合上一篇文章中，我们总结出生成一个类实例的全部过程：
1.类首先查找内部__metaclass__属性是否被自定义元类赋值，若赋值则准备用该自定义元类生成类，否则用type作为元类生成类；
2.解释器调用该元类的__new__函数（该函数为静态函数），并将要实例化的类中定义的各种属性传递给该函数固定的四个参数：其中cls是该元类本身，name是要被实例化的类的类名，bases是该类父类组成的元组，attrs则是该类{属性名：属性值，函数名：函数对象}组成的字典。
3.最终通过type类生成该类，并返回。
4.该类生成后，调用类中的__new__函数（该函数是静态函数）创建该类的实例，并返回该实例；
5.该实例接着调用它的__init__函数初始化实例，这样一个完整的实例就被生成出来了。
5，自定义元类的核心
由于是元类构建了类，因此若要更改某些固定类（str，int等）的用法，就必须在元类中做文章了。而元类的核心是__new__函数，自然在该函数内做文章。比如可以通过atrris字典为元类添加新的属性和函数，或改变以往的属性或函数等。这样的改变会传播到所有用该元类创建的类中。
总结：
__new__函数：
1.在元类中该函数用来构建类本身；
2.在类中，该函数用来构建类实例；
---------------------
元类中__call__
当你调用类对象时会自动触发元类中的__call__方法 ,并将这个类本身作为第一个参数传入,以及后面的一堆参数
覆盖元类中的call之后,这个类就无法产生对象,必须调用super().__call__来完成对象的创建
并返回其返回值
使用场景:
当你想要控制对象的创建过程时,就覆盖call方法 对象创建过程__call__
当你想要控制类的创建过程时,就覆盖init方法 控制类的创建 __init__
案例:
# 元类中的__call__方法 在对象加括号 会自动触发类中的__call__ 方法
# 覆盖父类的__call__ 这个类无法差生对象 必须调用super().__call__
# 来完成对象的创建，并返回其返回值
#实现将对象的所有属性名称转为大写
# 实现一
class Mytype(type):
# 控制对象的产生
def __call__(self, *args, **kwargs):
if args:
raise Exception(‘不能用位置参数‘)
return super().__call__(*args,**kwargs) # 必须返回这个对象
class Person(metaclass=Mytype):
def __init__(self,name,age):
self.name =name
self.age =age
a = Person(name=‘jcsk‘,age=19)
print(a.name)
print(a.age)
单列的实现
class Single(type):
def __call__(self, *args, **kwargs):
print(self) # Student 类
if hasattr(self, ‘obj‘):
return getattr(self, ‘obj‘)
obj = super().__call__(*args, **kwargs) # 没有则有创建
print(obj) # 实例化的对象
print(‘新开的试试看看‘)
self.obj = obj # 并保存到self 对象自己的名称空间中
return obj
class Student(metaclass=Single):
def __init__(self, name, age):
self.name = name
self.age = age
a = Student(‘jj‘, 12) #
Student(‘mm‘, 12)
Student(‘kk‘, 12)
Student(‘pp‘, 12)
Student(‘tt‘, 12)
# l = [2, 1, 3, 5] # 冒泡算是遍历里里面的元素 由第一个和第二个做比较 如是：按大到小进行编排
# 列表的个数
#
# 先比较 2,1 得到2 1 1 3 1 5
# 第一圈 0 索引
# >>> 元素比较元素次数 次数len-1 3
# 第二圈 1 索引
# 2 3 2 5 2和1已经再第一次拿到最小值了 不用再比较 比较元素次数 为2 len -1 -1
# l2 = [3, 5, 2, 1]
# 第三圈 2 索引
# 3 5 3和2 再 第二圈已经比较过了
# l3 = [5, 3, 2, 1]
# 需求要用函数的方法实现 找关系
s = [2, 3, 5, 1,10,309]
for i in range(len(s) - 1): # 元素比较的次数 第一次 顾头不顾尾range(3) 0 1 2 三次比较
# print(i) # 0 1 2 3 元素的索引下标
for j in range(len(s) - 1 - i): # i相当于圈数的索引i =1 第二次 顾头不顾尾range(2) 0 1 三次比较
if s[j] < s[j+1]:
# 解压赋值
s[j], s[j+1] = s[j+1], s[j]
print(s)
class Num:
def __init__(self,name,age):
self.age = name
self.age = age
def __str__(self):
return self.age
def __gt__(self, other):
return self.age > other.age
a1 = Num(‘json‘,‘48‘)
a2 = Num(‘json‘,‘19‘)
a3 = Num(‘json‘,‘26‘)
排序的 ？？？？
stu = [a1.age, a2.age, a3.age]
for i in range(len(stu)-1):
for j in range(len(stu)-1-i):
if stu[j]>stu[j+1]:
stu[j],stu[j+1] = stu[j],stu[j+1]
print(stu)
标签：核心 def 另一个 __call dir 需求 设置 字符串 索引
原文地址：https://www.cnblogs.com/mofujin/p/11272117.html
