反射、魔法方法、元类

最新推荐文章于 2024-05-09 17:51:30 发布
最新推荐文章于 2024-05-09 17:51:30 发布
阅读量92 收藏
点赞数
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56371364/article/details/126091262
版权

内容概要

  • 反射实战
  • 魔法方法
  • 魔法方法的实战
  • 元类
  • 创建元类的两种方式

内容详细

反射的实战案例

案例1

加载配置文件纯大写的配置（配置文件加载:获取配置文件中所有大写的配置 小写的直接忽略 组织成字典）

import settings
new_dic = {}
for i in dir(settings):
    if i.isupper():
       new_dic[i] = getattr(settings,i)
print(new_dic)

总结：
1.dir(obj) :获取对象中可以调用的名字，以列表的形式返回
2.熟悉：在python中，一切皆对象（文件，模块...）

案例2

模拟操作系统cmd终端执行用户命令

class Mywindows(object):
    def dir(self):
        print('dir获取当前目录下所有的文件名称')
    def ls(self):
        print('ls获取当前路径下所有的文件名称')
    def ipconfig(self):
        print('ipconfig获取当前计算机的网卡信息')
obj = Mywindows()
while True:
    cmd = input("请输入你的指令>>>:").strip()
    if hasattr(obj,cmd):
        name_cmd = getattr(obj,cmd)
        name_cmd()
    else:
        print(f"{cmd}没有这个指令哦")

面向对象的魔法方法

魔法方法其实就是类中定于的双下方法。被称为魔法方法的原因就是这些方法都是到达某个条件自动触发，不需要调用，例如：双下init方法在给对象设置独有的数据的时候，就会自动触发（实例化）。

1.str(self)

对象在被执行打印操作的时候会自动触发，该方法必须返回一个字符串，打印的时候，返回的是什么就打印什么（前提必须是字符串类型）

class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
obj = Student("nana",18)
print(obj)  # <__main__.Student object at 0x0000026135F772B0>


class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        print("__str__")
        # return f'这是对象：{self}'  # 报错，进行了递归
        return f'这是对象的名字：{self.name}'
obj = Student("nana",18)
print(obj)  # __str__  这是对象的名字：nana

2.call(self, *args, **kwargs)

只要对象加括号调用，就会触发该方法，括号里面可以写位置实参，关键字实参

class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
obj = Student("nana",18)
obj()  # 报错 TypeError: 'Student' object is not callable

class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __call__(self, *args, **kwargs):
        print("__call__")
        print(args)
        print(kwargs)
obj = Student("nana",18)
obj(1,2,name='xiao')  # __call__  (1, 2)  {'name': 'xiao'}

3.getattr(self, item)

只要当对象获取一个不存在的属性名，就会自动触发。该方法返回的是：return后面写的什么就返回什么，一般可以提示某个属性名不存在。形参item就是对象想要获取的不存在的属性名

class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
obj = Student("nana",18)
print(obj.name)  # nana
print(obj.hobby)  # 报错 AttributeError: 'Student' object has no attribute 'hobby'

class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __getattr__(self, item):
        print("__getattr__")
        return '您想要获取的属性名:%s不存在'%item

obj = Student("nana",18)
print(obj.name)  # nana
print(obj.hobby)  # __getattr__  您想要获取的属性名:hobby不存在

4. setattr(self, key, value)

当对象操作属性的时候会自动触发 eg：对象.属性名= 属性值

class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __getattr__(self, item):
        print("__getattr__")
        return '您想要获取的属性名:%s不存在'%item

obj = Student("nana",18)
print(obj.name)  # nana
print(obj.age)  # 18


class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __getattr__(self, item):
        print("__getattr__")
        return '您想要获取的属性名:%s不存在'%item

    def __setattr__(self, key, value):
        print("__setattr__")
        print(key)
        print(value)

obj = Student("nana",18)  # __setattr__ name nana __setattr__ age 18
print(obj.__dict__)  # {}
print(obj.name)  # __setattr__ name nana __setattr__ age 18 __getattr__ 您想要获取的属性名:name不存在
print(obj.age) # __setattr__ name nana __setattr__ age 18 __getattr__ 您想要获取的属性名:age不存在
obj.name = 'xiao'  # __setattr__ name nana __setattr__ age 18 __setattr__ name xiao

ps：出现以上情况原因：
1.obj = Student("nana",18) >>>在__init__中也有对象操作属性的时候(self.name = name),说以会触发__setattr__
2.print(obj.__dict__),返回空字典，是因为Student类中，默认继承object父类，那object父类中本来就有__setattr__方法(对象操作属性)，然而我们在重写了_setattr__方法，却没有任何操作,所以返回{}是理所应当的

解决：用super()继承父类
class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __getattr__(self, item):
        print("__getattr__")
        return '您想要获取的属性名:%s不存在'%item

    def __setattr__(self, key, value):
        super().__setattr__(key,value)

obj = Student("nana",18)
print(obj.name) # nana

5. del(self)

对象在被删除的时候会自动触发。删除包含主动删除和被动删除，主动删除就是执行删除操作，被动删除就是代码运行完毕，文件执行结束，释放内存，进行被动删除

class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __del__(self):
        print("__del__")
obj = Student("nana",18)
del obj  # __del__

6.getattribute(self, item)

对象获取属性的时候自动触发，无论这个属性存不存在。当类中既有__getattr__，又有__getattribute__的时候，只会执行__getattribute__

class Student:
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __getattribute__(self, item):
        print("getattribute__")
obj = Student("nana",18)
print(obj.name)  # getattribute__  None
print(obj.hobby)  # getattribute__  None

class Student(object):
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __getattribute__(self, item):
        print("getattribute__")
        return super(Student, self).__getattribute__(item)
obj = Student("nana",18)
print(obj.name)  # getattribute__  nana
print(obj.hobby)  # getattribute__

7.enter(self) 、exit(self, exc_type, exc_val, exc_tb)

enter(self):对象被with语法执行的时候自动触发，该方法返回什么，as关键字后面的变量名就能得到什么；exit(self, exc_type, exc_val, exc_tb)：对象被with语法执行并运行完with子代码之后，自动触发

class Student(object):
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
obj = Student("nana",18)
with obj as f:
    pass       # 报错  AttributeError: __enter__

class Student(object):
    school = '清华'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __enter__(self):
        print('__enter__')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("__exit__")
obj = Student("nana",18)
with obj as f:
    print(f)    # >>>__enter__ <__main__.Student object at 0x00000152B76C7358>   __exit__

魔法方法练习

补全以下代码 执行之后不报错

class Context:
    pass
with Context() as f:
    f.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 f:
    f.do_something()

元类

元类的简介

1.基础阶段我们使用type来查看数据的数据类型，学习了面向对象之后，发现查看的不是数据类型，而是数据类型所属的类

l1 = [1,2,3,4]
print(type(l1))  # <class 'list'>
s1 ={1,2,3,4}
print(type(s1))  # <class 'set'>

2.我们定义的数据类型 其实本质还是通过各个类产生对象

class str:
	pass
s1 = 'naan'  >>>相当于：s1 = str('naan')

3.type也可以被理解为用于查看产生当前对象的类是谁

class Myclass:
    pass
obj = Myclass()
print(type(obj))  # <class '__main__.Myclass'>
print(type(Myclass))  # <class 'type'>

总结：自定义的类都是由type类产生的，我们将产生类的类称之为元类

产生类的两种方式

1.class关键字
class 类名:
    类体代码
2.利用元类type
type(name, bases, dict) -> a new type
即：type(类名、类的父类、类的名称空间)
	type("Myclass",(),{})

学习元类其实就是掌握了类的产生过程，我们就可以在类的产生过程中高度定制化类的行为

类的基本使用

只有继承了type的类才可以称之为是元类；如果想要切换产生类的元类，不能使用继承，必须使用关键字metaclass声明

class MyMetaClass(type):
    pass

class Myclass(metaclass = MyMetaClass):
    pass

推论：类中的__init__用于实例化对象，元类中的__init__用于实例化类

class MyMetaClass(type):
    def __init__(self,what, bases=None, dict=None):
        print("你好")
        print('what', what)  # 类名 what Myclass
        print('bases', bases) # 类的父类 bases ()
        print('dict', dict) # 类的名称空间 dict {'__module__': '__main__', '__qualname__': 'Myclass'}
        super().__init__(what, bases, dict)
class Myclass(metaclass = MyMetaClass):
    pass

需求：类名必须首字母大写

class MyMetaClass(type):
    def __init__(self,what, bases=None, dict=None):
        if not what.istitle():
            raise Exception('首字母大写')
        super().__init__(what, bases, dict)
class Myclass(metaclass = MyMetaClass):
    pass

元类的进阶

元类不单单可以控制类的产生过程，其实也可以控制对象的

对象加括号执行产生该对象类里面的双下call方法

class Myclass:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __call__(self, *args, **kwargs):
        print("__call__")
obj = Myclass('nana',18)
obj()  # __call__

推导出：类加括号执行产生该类的元类里面的双下call方法

class Father_Father(type):
    def __call__(self, *args, **kwargs):
        print('__call__')
        print(args)
        print(kwargs)
        super().__call__(*args, **kwargs)

class Myclass(metaclass= Father_Father):
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print('__init__')
obj = Myclass('nana',18)  # __call__ ('nana', 18) {} __init__

总结：如果我们想高度定制对象的产生过程，可以操作元类里面的双下call方法，如果我们想要高度定制类的产生过程，可以操作元类里面的双下init方法

练习

需求：实例化对象 所有的参数都必须采用关键字参数的形式

class Father_Father(type):
    def __call__(self, *args, **kwargs):
        if args:
            raise Exception('不能有位置参数')
        super().__call__(*args, **kwargs)

class Myclass(metaclass= Father_Father):
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print('__init__')
obj = Myclass(name = 'nana',age = 18)   # __init__
print(obj.name)

双下new方法

1.类产生的步骤
	1.1 产生一个空对象  >>>self.__new__(*args.**kwargs)
    1.2 自动触发__init__方法实例化对象  >>> super().__call__(*args, **kwargs)
    1.3 返回实例化好的对象  >>>给对象添加属性
2.__new__方法专门用于产生空对象
  __init__方法专门用于给对象添加属性

作业

自定义字典并且让你字典具备d.key = value 修改键值对；d.key = value 添加键值对

class MyDict(dict):

    def __setattr__(self, key, value):
        super(MyDict, self).__setattr__(key, value)
        self[key] =  value # d['name']='nana'

d = MyDict({'name': 'cx', 'age': 18})
d.name = 'nana'  
print('d.name:', d.name)  # d.name: nana
print('d:',d)  # d: {'name': 'nana', 'age': 18}
d.age2=22
print(d)  # {'name': 'nana', 'age': 18, 'age2': 22}
nana_cx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python基础之面向对象&静态方法&类方法&属性方法&魔法方法以及 反射，封装，继承（新式类 与 经典类），多态，
12-22
一. 面向对象编程主要优点 1、面向对象编程主要优点：易维护，易扩展，效率高 其实OOP编程的主要作用和函数一样也...一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。 在类中定义了这些对象的都具备的属性（va
反射，魔法方法，元类相关知识点总结
Yydsaoligei的博客
07-29 136
反射，魔法方法，元类
面向对象高级-反射/魔法方法/元类
weixin_30563917的博客
12-19 71
day25 面向对象高级 一、isinstance and issubclass： 1、isinstance() 判断一个对象是不是一个类的实例化对象； 2、issubclass 判断一个类是不是另一个类的子类。 class People(object): pass class Student(People): pass ​ stu = Student(...
类特殊属性魔法方法反射
从0到1
05-13 181
概述 运行时，区别于编译时，指的是程序被加载到内存中执行的时候 反射，reflection，指的是运行时获取类型定义信息 一个对象能够在运行时，像照镜子一样，反射出其类型信息 简单说，在python中，能够通过一个对象，找出其type、class、attribute或method的能力，称为反射或者自省。 具有反射能力的函数有：type()、isinstance()、callable()...
元类与魔法方法
aa1384656303的博客
12-19 57
1.isinstances与issubclass 　isinstances作用是判断耨个对象是不是某各类的实例(判断类型) 　issubclass作用是判断一个类是不是另外一个类的子类 1 class Person: 2 pass 3 4 class Student(Person): 5 pass 6 7 stu = Stude...
Java 之反射的魔法
极客星云-CSDN博客
05-04 1431
本篇博文讲解如何使用反射动态获取一个类中所有的成员字段信息和方法信息
面向对象的魔法方法，元类
lzq78998的博客
07-29 280
快来学习
python魔法方法_Python魔法方法指南
weixin_39619893的博客
11-21 75
有很多人说学习Python基础之后不知道干什么，不管你是从w3c还是从廖雪峰的教程学习的，这些教程都有一个特点：只能引你快速入门，但是有关于Python的很多基础内容这些教程中都没介绍，而这些你没学习的内容会让你在后期做项目的时候非常困惑。就比如下面这篇我要给大家推荐的文章所涉及的内容，不妨你用一天时间耐心看完，把代码都敲上一遍。--11：33更新--很多人想要我的一份学习笔记，所以在魔法指南之前...
Python魔法方法
既然选择远方，便只顾风雨兼程！
10-19 2652
从入门到进阶，一个很重要的点就是Python中的魔法方法，魔法方法就是可以给你的类增加魔力的特殊方法，如果你的对象实现了这些方法中的某一个，那么这个方法就会在特殊的情况下被 Python 所调用，你可以定义自己想要的行为，而这一切都是自动发生的。它们经常是两个下划线包围来命名的（比如__init__/__new__等等），Python的魔法方法是非常强大的。
用反射拿到私有构造方法的类的对象
php_thebest_language的博客
10-23 189
public class HelloWorld { public static void main(String[] args){ System.out.println("HelloWorld"); try{ Class aClass = Class.forName("java.lang.System"); ...
Java-ME-程序设计第13角色扮演类游戏开发.pptx
05-29
MyGameCanvas类：该类是游戏的画布屏幕类，在该类中定义了如何根据用户的游戏动作绘制对应的游戏运行画面的方法。 Select类：该类作为游戏按键的响应类，主要定义了如何根据用户选择菜单和游戏按键绘制响应的屏幕...
「Java学习+面试指南」一份涵盖大部分 Java 程序员所需要掌握的核心知识
05-21
Java 魔法类 Unsafe 详解 Java SPI 机制详解 Java 语法糖详解 集合 知识点/面试题总结： Java 集合常见知识点&面试题总结(上) (必看 ) Java 集合常见知识点&面试题总结(下) (必看 ) Java 容器使用注意事项总结 源码...
「Java学习+面试指南」一份涵盖大部分 Java 程序员所需要掌握的核心知识 准备 Java 面试，首选.zip
04-15
Java 魔法类 Unsafe 详解 Java SPI 机制详解 Java 语法糖详解 集合 知识点/面试题总结 ： Java 集合常见知识点&面试题总结(上) (必看 ) Java 集合常见知识点&面试题总结(下) (必看 ) Java 容器使用注意事项总结 ...
python入门到高级全栈工程师培训 第3期 附课件代码
06-07
16 自定义元类 17 函数复习 18 文件操作复习 第29章 01 上节课复习 02 什么是异常处理及异常处理的两种方式对比 03 多分支与万能异常 04 异常处理的其他内容 05 什么时候用异常处理 06 什么是socket 07 套接字发展...
第五节课《LMDeploy 量化部署 LLM 实践》
fanre的专栏
05-06 691
PDF链接：https://pan.baidu.com/s/1JFtvBWgEGFWJq8pHafvIUg?pwd=6666提取码：6666。
Python3实现三菱PLC串口通讯(附源码和运行图)
最新发布
qq_38203551的博客
05-09 242
通过Python语言结合三菱通信协议实现的PyQt5上位机示例
继承与组合
g1446992400的博客
05-06 1017
继承就是创建新类的一种方式，这个新类可以继承一个或者多个其他类的属性新的类如果有自己属性，那就叫派生如果属性不封的情况下，谁实例化得到的self 就去谁里面找如果属性封装的情况下 ，谁实例化得到的self 无效，只能在当前所在的类的名称空间里面找。
Python 自动化脚本系列：介绍
代码说，代码让世界更美好。
05-08 844
Python 自动化脚本系列：介绍
java反射拿到类的方法
07-25
使用Java反射可以获取一个类中的所有方法。实现思路如下： 1. 使用`Class.forName()`方法获取指定的Class对象。 2. 使用`getMethods()`或`getDeclaredMethods()`方法获取类中的所有方法。 3. 可以通过遍历获取到的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值