目录

一、setattr函数的常见应用场景

二、setattr函数使用注意事项

三、如何用好setattr函数？

1、setattr函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页： https://blog.csdn.net/ygb_1024?spm=1010.2135.3001.5421

一、setattr函数的常见应用场景

        setattr函数在Python中有广泛的应用场景，特别是在动态实现类属性或方法、元编程(metaprogramming)以及处理对象时不知道具体属性名的情况下，常见的应用场景有：

1、动态实现类属性或方法：当你不确定类的所有属性或方法时，可以在运行时使用setattr()函数动态地添加它们，这可以用于创建可扩展的类，或者根据外部配置动态地添加功能。

2、简化对象属性的批量设置：如果你有一个对象，并且需要从字典或其他数据源中设置多个属性，setattr()函数可以帮助你简化这个过程。

3、实现代理对象或装饰器：在代理对象或装饰器模式中，你可能需要拦截对某个对象的属性访问，并在访问之前或之后执行一些操作，你可以使用setattr()函数来动态地修改被代理对象的属性。

4、结合描述符(Descriptors)使用：描述符是Python中一个强大的特性，允许你控制对对象属性的访问，当描述符与setattr()函数结合使用时，你可以实现更复杂的属性访问逻辑。

5、序列化和反序列化：在处理自定义对象的序列化和反序列化时，setattr()函数可以帮助你根据序列化的数据动态地设置对象的属性，这在处理JSON、XML或其他格式的数据时特别有用。

6、元编程：在元编程中，你编写操作其他代码的代码，setattr()函数允许你动态地修改对象的结构，这在创建代理、装饰器、元类等高级编程概念时非常有用。

7、处理用户输入：如果你正在编写一个接受用户输入并动态设置对象属性的程序，setattr()函数可以帮助你根据用户输入来设置属性。

        注意，过度使用setattr()函数可能会使代码难以理解和维护，因为它破坏了对象的明确性和封装性，因此，在使用setattr()函数时应该谨慎，并确保你的代码清晰、可读和可维护。

二、setattr函数使用注意事项

        在Python中，setattr()是一个内置函数，用于设置对象的属性值，它的基本用法是setattr(object, name, value)，其中，object是你想要修改其属性的对象，name是属性的名称(作为一个字符串)，而value是你想要设置的新值。

在使用setattr()函数时，需注意以下事项：

1、属性名称作为字符串：name参数必须是一个字符串，它指定了你想要设置的属性的名称，如果你尝试使用一个非字符串值，Python会抛出一个TypeError异常。
2、不存在的属性：如果对象没有名为name的属性，setattr()会创建一个新的属性，但是，如果你试图设置一个只读属性(如某些内置类型或扩展类型中的属性)，可能会引发异常。
3、隐藏或覆盖内置方法：如果你使用setattr()函数设置了一个与对象现有方法同名的属性，那么这个方法将被该属性隐藏或覆盖，这可能会导致意外的行为，特别是如果后来你尝试调用那个方法但忘记了已经被覆盖。
4、动态属性：虽然setattr()函数允许你动态地设置对象的属性，但这并不意味着你应该滥用它，过度使用动态属性可能会使代码难以理解和维护，在可能的情况下，最好明确地在类定义中声明属性。
5、安全性：setattr()函数可以被用于修改对象的任何属性，包括私有属性(在Python中，以双下划线开头的属性名称被认为是私有的)，这可能会破坏对象的内部状态，并导致不可预测的行为，因此，在使用setattr()函数时，你应该非常小心，确保你只修改你真正想要修改的属性。
6、异常处理：在设置属性时，可能会发生各种异常，如AttributeError(如果尝试访问不存在的属性)或TypeError(如果属性类型与赋值不兼容)，你应该准备好处理这些异常，以防止程序崩溃。
7、性能：虽然setattr()函数在大多数情况下都足够快，但在某些情况下，频繁地使用它可能会导致性能问题，如果你需要频繁地设置大量属性，可能需要考虑其他更高效的方法。
8、结合getattr()/delattr()使用：getattr()/delattr()是另外两个与setattr()相关的内置函数，它们分别用于获取和删除对象的属性，在编写处理对象属性的代码时，这三个函数通常会一起使用。

三、如何用好setattr函数？

        要在Python中妥善使用setattr()函数，你需遵循以下建议：

1、明确目的：首先，确定你为何需要使用setattr()函数？在大多数情况下，直接在类定义中声明属性或使用常规的赋值语法是更简单、更直观的选择，如果你确实需要动态地设置属性，那么setattr()函数是一个有用的工具。

2、避免覆盖内置方法：在调用setattr()函数时，确保你没有意外地覆盖对象的内置方法或属性，你可以通过检查name参数的值来避免这种情况。

3、考虑封装：如果你经常需要动态地设置属性，可以考虑将setattr()的调用封装到一个类或方法中，这样可以隐藏底层复杂性，并提供一个更清晰的接口给调用者。

4、使用字典代替属性：如果你需要存储大量的动态属性，并且不关心它们作为对象的属性暴露给外部代码，那么使用字典来存储这些属性可能是一个更好的选择。字典提供了灵活的键值对存储，并且你可以使用dict.get(), dict.setdefault() 和dict.update()等方法来操作它们。

5、处理异常：当使用setattr()函数时，要准备好处理可能发生的异常，如AttributeError(如果尝试访问不存在的属性)或TypeError(如果赋值类型不兼容)，你可以使用try/except块来捕获这些异常，并相应地处理它们。

6、文档化：如果你在你的代码中使用setattr()函数，确保在相关的文档或注释中解释清楚它的用途和潜在的影响，这可以帮助其他开发者更好地理解你的代码，并避免意外的副作用。

7、测试：编写测试用例来验证你使用setattr()函数的代码的正确性。确保你的测试覆盖了各种情况，包括正常情况和异常情况，这可以帮助你发现潜在的问题，并确保你的代码在所有预期的情况下都能正常工作。

8、谨慎使用：尽管setattr()函数在某些情况下很有用，但它也可能导致代码难以理解和维护，因此，你应该谨慎地使用它，并确保你的代码在不需要动态属性时仍然能够正常工作。

1、setattr函数：

1-1、Python：

# 1.函数：setattr
# 2.功能：用于设置对象的属性值
# 3.语法：setattr(object, name, value)
# 4.参数：
# 4-1、object：对象
# 4-2、name：字符串，表示对象属性
# 4-3、value：属性值
# 5.返回值：无
# 6.说明：
# 7.示例：
# 用dir()函数获取该函数内置的属性和方法
print(dir(setattr))
# ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
# '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__',
# '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__',
# '__str__', '__subclasshook__', '__text_signature__']
 
# 用help()函数获取该函数的文档信息
help(setattr)
 
# 应用一：动态实现类属性或方法
# 示例1：动态设置类实例的属性
class MyClass:
    def __init__(self):
        self.existing_attribute = 'I exist!'
# 创建一个类的实例
instance = MyClass()
# 使用setattr()动态地添加一个属性
setattr(instance, 'my_weight', '70.6kg')
# 访问动态添加的属性
print(instance.my_weight)
# 70.6kg
 
# 示例2：动态设置类的方法
class MyClass:
    def existing_method(self):
        print('I am an existing method!')
# 创建一个类的实例
instance = MyClass()
# 定义一个要动态添加的方法
def dynamic_method(self):
    print('I am a dynamically added method!')
# 使用setattr()动态地添加一个方法
setattr(MyClass, 'dynamic_method', dynamic_method)
# 在类的实例上调用动态添加的方法(注意：我们是在类上添加的方法，所以所有实例都可以访问)
instance.dynamic_method()
# I am a dynamically added method!
 
# 示例3：动态设置类的属性(即类变量)
class MyClass:
    existing_class_variable = 'I am a class variable!'
# 使用setattr()动态地添加一个类变量
setattr(MyClass, 'dynamic_class_variable', 'I was dynamically added as a class variable!')
# 访问动态添加的类变量(通过类本身或其实例)
print(MyClass.dynamic_class_variable)  # 输出: I was dynamically added as a class variable!
print(MyClass().dynamic_class_variable)  # 同样输出: I was dynamically added as a class variable!
# I was dynamically added as a class variable!
# I was dynamically added as a class variable!
 
# 应用二：简化对象属性的批量设置
class Person:
    def __init__(self):
        self.name = None
        self.age = None
        self.city = None
# 创建一个Person实例
person = Person()
# 使用字典来存储要设置的属性值
attributes = {
    'name': 'Myelsa',
    'age': 18,
    'city': 'Guangzhou'
}
# 使用setattr()批量设置属性
for key, value in attributes.items():
    setattr(person, key, value)
# 验证属性是否设置成功
print(person.name)
print(person.age)
print(person.city)
# Myelsa
# 18
# Guangzhou
 
# 应用三：实现代理对象或装饰器
class Proxy:
    def __init__(self, obj):
        self._obj = obj
    def __setattr__(self, name, value):
        # 检查是否是要拦截的属性
        if name.startswith('_'):
            # 如果以'_'开头，则直接设置到代理对象本身
            super().__setattr__(name, value)
        else:
            # 否则，拦截对_obj属性的设置，并可能添加一些额外的逻辑
            print(f"Intercepted setattr for {name}. Original value: {getattr(self._obj, name, 'None')}")
            # 在这里可以添加一些逻辑，比如验证、转换等
            # ...
            # 设置值到_obj
            setattr(self._obj, name, value)
            print(f"Set {name} to {value} in the original object.")
    def __getattr__(self, name):
        # 如果访问的属性不存在于代理对象本身，则转发到_obj
        return getattr(self._obj, name)
class MyClass:
    def __init__(self):
        self.x = 10
# 创建一个MyClass实例和一个代理对象
obj = MyClass()
proxy = Proxy(obj)
# 尝试设置代理对象的属性
proxy.x = 20
# 尝试访问代理对象的属性
print(proxy.x)
# Intercepted setattr for x. Original value: 10
# Set x to 20 in the original object.
# 20
 
# 应用四：结合描述符(Descriptors)使用
class BoundedDescriptor:
    def __init__(self, name, lower=None, upper=None):
        self.name = name
        self.lower = lower
        self.upper = upper
        self._value = None
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return self._value
    def __set__(self, instance, value):
        if self.lower is not None and value < self.lower:
            raise ValueError(f"{self.name} must be greater than or equal to {self.lower}")
        if self.upper is not None and value > self.upper:
            raise ValueError(f"{self.name} must be less than or equal to {self.upper}")
        self._value = value
        print(f"Setting {self.name} to {value}")
    def __delete__(self, instance):
        raise AttributeError("Cannot delete the descriptor")
class MyClass:
    x = BoundedDescriptor('x', 0, 10)
# 创建一个MyClass的实例
obj = MyClass()
# 使用setattr()设置属性(这实际上是调用描述符的__set__方法)
setattr(obj, 'x', 5)  # 输出: Setting x to 5
print(obj.x)  # 输出: 5
# 尝试设置一个超出范围的值
try:
    setattr(obj, 'x', -1)
except ValueError as e:
    print(e)  # 输出: x must be greater than or equal to 0
# 尝试删除描述符（会引发异常）
try:
    delattr(obj, 'x')
except AttributeError as e:
    print(e)  # 输出: Cannot delete the descriptor
# Setting x to 5
# 5
# x must be greater than or equal to 0
# Cannot delete the descriptor
 
# 应用五：序列化和反序列化
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"Person(name={self.name}, age={self.age})"
def serialize_person(person):
    """将Person对象序列化为字典"""
    return {
        'name': person.name,
        'age': person.age
    }
def deserialize_person(data):
    """从字典反序列化为Person对象"""
    person = Person(None, None)  # 创建一个空的Person对象
    for key, value in data.items():
        setattr(person, key, value)  # 使用setattr()设置属性
    return person
# 示例用法
# 序列化
person = Person("Myelsa", 18)
serialized_data = serialize_person(person)
print(serialized_data)
# 反序列化
deserialized_person = deserialize_person(serialized_data)
print(deserialized_person)
# {'name': 'Myelsa', 'age': 18}
# Person(name=Myelsa, age=18)
 
# 应用六：元编程
class DynamicClass:
    def __init__(self):
        # 用于存储动态方法的字典
        self._dynamic_methods = {}
    def add_method(self, name, func):
        """动态地添加一个方法到类中"""
        setattr(self, name, func)
        # 同时将方法存储在字典中以便后续可能的操作
        self._dynamic_methods[name] = func
    def remove_method(self, name):
        """动态地移除一个方法"""
        if hasattr(self, name):
            delattr(self, name)
            if name in self._dynamic_methods:
                del self._dynamic_methods[name]
    def list_methods(self):
        """列出所有的动态方法(不包括内置方法)"""
        return list(self._dynamic_methods.keys())
# 示例函数
def hello_world():
    print("Hello, world!")
def greet(name):
    print(f"Hello, {name}!")
# 创建一个DynamicClass的实例
dynamic_instance = DynamicClass()
# 动态地添加一个方法
dynamic_instance.add_method('hello', hello_world)
# 调用动态添加的方法
dynamic_instance.hello()  # 输出: Hello, world!
# 列出所有的动态方法
print(dynamic_instance.list_methods())  # 输出: ['hello']
# 动态地添加另一个方法，这次使用lambda表达式
dynamic_instance.add_method('greet_by_name', lambda name: greet(name))
# 调用通过lambda添加的方法
dynamic_instance.greet_by_name('Myelsa')  # 输出: Hello, Myelsa!
# 移除一个方法
dynamic_instance.remove_method('hello')
# 再次列出所有的动态方法
print(dynamic_instance.list_methods())  # 输出: ['greet_by_name']
# 尝试调用已被移除的方法
# dynamic_instance.hello()  # 这将引发 AttributeError
# Hello, world!
# ['hello']
# Hello, Myelsa!
# ['greet_by_name']
 
# 应用七：处理用户输入
class UserDefinedAttributes:
    def __init__(self):
        # 初始化一个空字典来存储用户定义的属性
        self._user_attributes = {}
    def set_attribute(self, name, value):
        # 检查属性名是否以"user_"开头，以限制可设置的属性范围
        if name.startswith("user_"):
            # 使用setattr()来设置属性
            setattr(self, name, value)
            # 同时将属性存储在字典中，以便后续可能的操作或检查
            self._user_attributes[name] = value
            print(f"Attribute {name} set to {value}")
        else:
            print(f"Error: Cannot set attribute {name}. Only attributes starting with 'user_' are allowed.")
    def get_attribute(self, name):
        # 检查属性是否存在
        if hasattr(self, name):
            return getattr(self, name)
        else:
            print(f"Error: Attribute {name} does not exist.")
            return None
    def list_attributes(self):
        # 列出所有用户定义的属性
        return list(self._user_attributes.keys())
# 示例用法
obj = UserDefinedAttributes()
# 获取用户输入
name = input("Enter attribute name (must start with 'user_'): ")
value = input("Enter attribute value: ")
# 尝试设置属性
obj.set_attribute(name, value)
# 列出所有用户定义的属性
print("User defined attributes:")
for attr in obj.list_attributes():
    print(f"{attr}: {obj.get_attribute(attr)}")
# 尝试获取并打印一个属性
attr_to_get = input("Enter attribute name to get (or 'exit' to quit): ")
if attr_to_get.lower() != 'exit':
    print(f"Value of {attr_to_get}: {obj.get_attribute(attr_to_get)}")
else:
    print("Exiting...")

1-2、VBA：

略，待后补。

2、推荐阅读：

2-1、Python-VBA函数之旅-round()函数

Python算法之旅：Algorithm

Python函数之旅：Functions

个人主页： 神奇夜光杯-CSDN博客