Python 中的反射操作

最新推荐文章于 2025-04-06 09:13:34 发布
最新推荐文章于 2025-04-06 09:13:34 发布
阅读量600 收藏 3
点赞数
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jianglianye21/article/details/106691640
版权
本文深入讲解Python中的反射机制，包括hasattr、getattr、setattr、delattr等方法的使用，实例化对象、类、模块的反射操作，以及特殊双下划线方法、单例模式和item系列的运用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

**内容概览：**
1、反射
2、实例化对象的反射操作
3、类名的反射操作
4、其他 py 文件的反射操作
5、本py文件的反射操作
6、特殊双下划线方法
7、单例模式
8、item 系列

反射

反射有四个方法：hasattr、getattr、setattr、delattr，比较常用的是前两种，一般会结合起来用。
最最重要的一点：通过字符串去操作对象的属性和方法，是字符串形式！
什么对象可以用反射？
实例化对象、类、其他模块、本模块
只有以上四个才能使用，因为他们都能通过 . 的方式获取或调用，这也算是一种前提

class A:

    name = "海绵宝宝"

    def func(self):
        print(666)

content = input("请输入：").strip()
ret = getattr(A, content)
print(ret)

运行结果一：
请输入：name 
海绵宝宝

运行结果二：
请输入：func
<function A.func at 0x7f4bdc6710d0>

运行结果三：

请输入：123
Traceback (most recent call last):
  File "test01.py", line 9, in <module>
    ret = getattr(A, content)
AttributeError: type object 'A' has no attribute '123'

原因解析：报错提示类 A 里面没有这个属性
也就是说，只有用户输入的是字符串形式的属于类 A 的属性时才不会报错

实例化对象的反射操作

class A:

    country = "中国"
    area = "深圳"

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

    def func(self):
        print(666)

a = A("Jane", 18)
#对象的属性
print(a.name)                       # Jane

#注意这个变量名也要用字符串形式！
print(hasattr(a, "name"))           # True

#不是这样用，而是字符串形式的属性名
print(hasattr(a, "Jane"))           # False

#一般 hasattr 与 getattr 结合起来使用
if hasattr(a, "name"):
    print(getattr(a, "name"))       # Jane

#可以设置一个默认值，目的是防止程序报错
#如果没有该属性，就返回默认值
print(getattr(a, "sex", None))      # None

print(a.country)                    # 中国
print(getattr(a, "country"))        # 中国

ret = getattr(a, "func")
#注意这里　ret() 相当于 func()
print(ret())                        # 666

#给对象添加一个属性
setattr(a, "sex", "男")
print(a.sex)                        # 男

#删除对象的某个属性
delattr(a, "name")
print(a.name)                       # AttributeError: 'A' object has no attribute 'name'

类名的反射操作

class A:

    country = "中国"
    area = "深圳"

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

    def func(self):
        print(666)

# 获取类 A 的静态属性 country
print(getattr(A, "country"))    # 中国
# 获取类 A 的静态属性 area
print(getattr(A, "area"))       # 深圳

# 获取类A 的动态方法并执行
getattr(A, "func")(23)          # 666

其他 py 文件的反射操作

1|假设有个 test02.py 文件，内容如下

flag = True

def func(a):
    return a + 3


class B:

    name_list = ["aaa", "bbb", "ccc"]

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

    def func(self):
        print(666)
  1. 在本 py 文件中，不用反射的操作方法
import test02

print(test02.flag)          # True

ret = test02.func
print(ret(10))              # 13

print(test02.B.name_list)   # ['aaa', 'bbb', 'ccc']

obj = test02.B("barry", "男")
print(obj.name_list)        # ['aaa', 'bbb', 'ccc']
  1. 在本 py 文件中，使用反射的操作方法
import test02

# 获取 test02 包中的 flag 变量对应的值
print(getattr(test02, "flag"))          # True

# 执行 test02 包中的 func 方法
ret = getattr(test02, "func")(10)   
print(ret)                              # 13

# 获取 test02 包中的类 B
print(getattr(test02, "B"))             # <class 'test02.B'>

# 获取 test02 包中的类 B 的 name_list 属性的方式：
# 方式一：
print(getattr(test02, "B").name_list)   # ['aaa', 'bbb', 'ccc']
# 方式二：
print(getattr(test02.B, "name_list"))   # ['aaa', 'bbb', 'ccc']

# 执行 test02 包中的类 B 的 func 方法（同上两种方式)
getattr(test02, "B").func(111)          # 666
getattr(test02.B, "func")(1)            # 666

实例化对象

obj = getattr(test02, "B")("小明", "男")

# 获取实例化对象的属性 name
print(obj.name)                         # 小明

# 通过实例化对象获取到类 B 中的共享数据之静态属性： name_list
print(obj.name_list)                    # ['aaa', 'bbb', 'ccc']

# 通过实例化对象执行类 B 中的共享数据之动态方法： func()
obj.func()                              # 666

本py文件的反射操作：反射的主体是本文件

import sys

def func():
    print(666)

ret = input("请输入: ").strip()
obj = sys.modules[__name__]
getattr(obj, ret)()
# 运行结果：只有输入 func 才不会报错
请输入: func
666


# 在本文件调用所有的函数
def func1():
    print("in func1")

def func2():
    print("in func2")

def func3():
    print("in func3")

l1 = [func1, func2, func3]
for i in l1:
    i()
# 运行结果：
in func1
in func2
in func3
# 要是有100个就不能这样了


import sys

l1 = ["func%s" % i for i in range(1, 4)]
print(l1)  # ['func1', 'func2', 'func3']
obj = sys.modules[__name__]
for i in l1:
    getattr(obj, i)()
# 运行结果：
in func1
in func2
in func3

特殊双下划线方法

1、项目中几乎不会自定义一个特殊双下划线方法，因为一般是给 Python 开发者在源码中使用
2、len 方法

class A:

    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.sex = "男"

    def __len__(self):
        return len(self.__dict__)

a1 = A("蓬蓬", 18)
# 这里假如要计算实例化对象中 a1 的属性个性
# 我们知道，直接使用 len(a1) 是不行的，因为类没有 len 方法
# 这时候，可以在 A 里面添加一个 __len__ 方法，伪装它有 len()
print(len(a1))          # 3
# 通过这个例子可以得知，那些能使用 len()的数据类型内部肯定有 __len__方法


print(hash(a1))         # -9223371957293561519
# 这里的结果是实例化对象(object) 中有 __hash__ ，而不是A的
# 因为 A 里并没有添加一个 __hash__ 方法
  1. str 方法
class A:

    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.sex = "男"

    def __str__(self):
        print(555)
        return "abc"

a1 = A("蓬蓬", 18)


# 对一个对象打印时，自动执行 __str__ 方法
print(a1)
# 运行结果：
555
abc
  1. call 方法
class Foo:

    def __init__(self):
        print("实例化一个对象时自动执行 __init__ 方法")

    def __call__(self, *args, **kwargs):
        print('调用实例化对象时自动触发 __call__ 方法')


obj = Foo()     # 实例化一个对象时自动执行 __init__ 方法
obj()           # 调用实例化对象时自动触发 __call__ 方法
  1. new 构造方法
class A:

    def __init__(self, name):
        self.name = name
        print("in A __init__")

a = A("小明")
# 实例化一个对象时，发生了三件事
# 1. 在内存中开辟了一个对象空间，注意是 obj (即 a )中 __new__ 开辟的
# 2. 自动执行 __init__ 方法，将空间传给 self
# 3. 在 __init__ 给对象封装属性，并返回给对象
# 也就是说，实例化一个对象的时候，首先执行了 __new__ 方法
# 然后执行了 __init__ 方法
class A:

    def __init__(self, name):
        self.name = name
        print("in A __init__")

    def __new__(cls, *args, **kwargs):
        print(111)

a = A("小明")
print(a.name)
# 运行结果：
111
Traceback (most recent call last):
  File "test01.py", line 11, in <module>
    print(a.name)
AttributeError: 'NoneType' object has no attribute 'name'

# 原因分析：注意本来实例化一个对象 a 后
# a 的 __new__ 方法会在内存中创建一个空间
# 但是，这里类中有 __new__，此时只会执行 A 中的 __new__，即会打印 111
# 也就是说，内存中并没有 a1 的空间，因此也就没有 a1.name
# 最终，print(a1.name) 会报错
# 为了执行 obj(a1) 的 __new__，可以这样：
class A:

    def __init__(self, name):
        self.name = name
        print("in A __init__")

    def __new__(cls, *args, **kwargs):
        print("in A __new__")
        return object.__new__(cls)

a = A("小明")
print(a.name)
# 运行结果：
in A __new__
in A __init__
小明

# 根据上面所写实例化对象时的三个步骤，可以推导出以上打印结果

单例模式：一个类只能实例化一个对象

1、一般情况下，一个类可以有很多的实例化对象，但是每个的内存地址不一样

class A:
    pass

ret1 = A()
ret2 = A()
ret3 = A()

print(ret1)
print(ret2)
print(ret3)

# 运行结果：
<__main__.A object at 0x7f33e2ccab70>
<__main__.A object at 0x7f33e12b1400>
<__main__.A object at 0x7f33e12b13c8>
  1. 单例模式示例
class A:

    __instance = None

    def __new__(cls, *args, **kwargs):
        # cls 表示类本身, 这一句表示如果是第一次实例化对象
        if cls.__instance is None:
            obj = object.__new__(cls)
            cls.__instance = obj
        return cls.__instance

ret1 = A()
ret2 = A()
ret3 = A()

print(ret1)
print(ret2)
print(ret3)

# 运行结果：
<__main__.A object at 0x7f2fc69493c8>
<__main__.A object at 0x7f2fc69493c8>
<__main__.A object at 0x7f2fc69493c8>

# 可以看出是在同一个内存地址，也就是说单例模式可以节省内存
# 比如有时很多地方要调用这个类，又必须调用实例对象，就用单例模式
  1. 通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案
class A:

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

    __instance = None

    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            obj = object.__new__(cls)
            cls.__instance = obj
        return cls.__instance

ret1 = A("小明", 20)
ret2 = A("小花", 28)
ret3 = A("小白", 34)

print(ret1)
print(ret2)
print(ret3)

# 运行结果：
<__main__.A object at 0x7f0b8309f4a8>
<__main__.A object at 0x7f0b8309f4a8>
<__main__.A object at 0x7f0b8309f4a8>

item 系列

class Foo:

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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        # 这里不能使用 self.key = value
        # 因为那样相当于 self."age" = 18
        self.__dict__[key]=value

    def __delitem__(self, key):
        print('del obj[key] 时, 我执行')
        self.__dict__.pop(key)

    def __delattr__(self, item):
        print('del obj.key 时, 我执行')
        self.__dict__.pop(item)

f = Foo('abc')
f['age'] = 18
f['age1'] = 19
del f.age1              # del obj.key时,我执行
del f['age']            # del obj[key]时,我执行
f['name'] = '小明'
print(f.__dict__)       # {'name': '小明'}

原文链接：https://zhuanlan.zhihu.com/p/99150129

python中的反射---用字符串的调用函数和方法
敲代码的设计师
03-17 3058
我们在实际应用中会碰到这样的场景：写好代码之后，我们希望通过输入代码指令直接调用某个函数或者方法，通常的做法，我们会采用if语句来实现， a=input('<<<') if a == 要输入的指令 代码块 elif a==要输入的指令 代码块 .... 当需要的判断比较少的时候，这样做是没有问题的，但当需要判断的代码比较多的时候，代码就会变的非常长。 这时我们可以利用反射来快速...
Python反射的用法实例分析
09-20
主要介绍了Python反射的用法,结合实例形式分析了Python反射机制所涉及的几个常用方法与相关使用技巧,需要的朋友可以参考下
python中的反射
Think_lion的博客
09-06 2842
反射说简单点 --> 就是利用字符串的形式去对象(模块)中操作(寻找/检查/删除/设置)成员。 第一种：项目的目录如下图，需要导入的文件和可执行文件都在一个目录下 # -*- coding: utf-8 -*- import commons ''' 当前是index.py 文件 导入的模块是commons.py 文件 ''' def main(): #利用字符串的
Python中的反射机制使用方法说明
最新发布
demonlg0112的博客
04-06 346
是指程序在运行时动态访问、检测和修改对象结构和行为的能力。通过反射机制，可以实现基于字符串名称操作对象的属性、方法或类，从而编写更灵活、解耦的代码。：根据用户输入的命令，动态调用对应方法，例如实现一个命令行工具。Python 对象的属性和方法存储在 __dict__：将配置文件（如字典）的键值对动态注入对象属性。等函数，可以大幅提升代码的灵活性和扩展性。：根据数据字段动态调用不同的清洗函数。：将数据库查询结果动态映射到对象属性。Python 反射机制的核心价值在于。：根据类名动态创建实例并注入依赖。
python面试题——Python中怎么通过反射来调用对象的函数？
python全栈
08-05 1892
执行结果：3.6055512754639896动态编程才会用到反射场景：假如原始的一个Point类中定义了distance方法，之后由于业务需求我又在类中又偷偷的定义了distance2方法，但是其他程序员不知道我做了什么改动，我直接告诉他函数名和函数实现的方法就可以了，当他调用类中的distance2方法时就不需要看代码逻辑了。 方法二：利用反射，operator.methodcaller...
python通过反射执行代码
xyz的博客
12-17 1481
场景：python2.7没有@注解 用于实现适配器模式，不能再方法执行前后维护一些全局变量。所以用反射的思路来统一调用一个方法来执行其他的函数。 比如以下例子是为了维护一个长期使用的mysql连接，以此减少mysql的访问压力。在每次执行其他方法的时候调用 self.conn = conn_app_db.check_conn(self.conn)，以此来维护连接，或者产生新连接（通过conn....
【反射与函数属性】：Python中反射操作函数的高级技巧
[【反射与函数属性】：Python中反射操作函数的高级技巧](https://blog.finxter.com/wp-content/uploads/2021/02/object-1-1024x576.jpg) # 1. Python反射技术概述 在现代的编程实践中，代码的灵活性和可维护性成为...
python中反射用法实例
09-22
在Python编程语言中，反射（Reflection）是一种强大的特性，它允许在运行时动态地访问和修改对象的属性、方法和模块。具体来说，反射机制通过内置的函数如type()、getattr()、setattr()和hasattr()来操作对象的内部...
python3 反射的四种基本方法解析
09-18
这四个基本方法——getattr()、hasattr()、setattr() 和 delattr()，构成了Python反射的核心，使得代码更加灵活和动态。下面我们将逐一详细介绍这些方法。 1. getattr() 方法 getattr() 方法用于获取对象的属性或...
Python3.6简单反射操作示例
09-20
下面将详细解释这些概念、原理以及如何在Python3.6中进行简单的反射操作。 1. `getattr()`: 此函数用于获取对象的属性值。如果属性存在，它会返回该属性的值；如果不存在，可以提供一个默认值，否则会抛出`...
python反射
qq_41119282的博客
07-21 185
python的反射，用最简单的例子，完成一个python理论的运用，反射可以用在自动化的关键字驱动中
python的反射机制
xianjie0318的博客
02-09 1683
python中如何通过模块参数获取到 模块路径 __import__作用: 同import语句同样的功能，但__import__是一个函数，并且只接收字符串作为参数，所以它的作用就可想而知了。 其实import语句就是调用这个函数进行导入工作的，import sys sys = __import__('sys') getattr()函数是Python自省的核心函数获取对象引用getatt
Python的反射（Reflection）
iamnotacoder的博客
08-07 1051
这包括获取对象的类、方法、属性等信息，以及动态地调用对象的方法和修改对象的属性等。3. `getattr()` 函数：可以用来获取一个对象的方法或属性。1. `type()` 和 ` isinstance()` 函数：可以用来获取对象的类型或一个对象是否是某个类的实例。4. `setattr()` 函数：可以用来动态地给一个对象设置属性。2. `dir()` 函数：可以用来获取一个对象的所有属性和方法。6. `delattr()` 函数：可以用来删除一个对象的属性。4. 类和对象的动态创建和修改。
python3学习之反射的四种基本方法
weixin_30266829的博客
07-09 537
class Person(object): def __init__(self): pass def info(self): print('我是person类中的info方法') 1.getattr()方法 这个方法是根据字符串去某个模块中寻找方法 instantiation = reflect....
python的反射
weixin_41496625的博客
12-28 432
python 反射
[转载] python通过反射执行代码
u013946150的博客
12-28 173
参考链接： Python中的反射 场景：python2.7没有@注解 用于实现适配器模式，不能再方法执行前后维护一些全局变量。所以用反射的思路来统一调用一个方法来执行其他的函数。 比如以下例子是为了维护一个长期使用的mysql连接，以此减少mysql的访问压力。在每次执行其他方法的时候调用 self.conn = conn_app_db.check_conn(self.conn)，以此来维护连接，或者产生新连接（通过conn.ping方法判断是否连接断开）。 class upload_arti...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值