Python-VBA函数之旅-getattr函数

目录

一、getattr函数的常见应用场景：    

二、getattr函数使用注意事项：

1、getattr函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

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

一、getattr函数的常见应用场景：    

        getattr函数在 Python 中有许多实际应用场景，尤其是在处理对象属性、动态访问属性、实现灵活的 API 和框架等方面。常见的应用场景有：

1、动态属性管理：当你不确定一个对象是否有某个属性，或者属性名在运行时才能确定时，可以使用getattr()函数。例如，在处理配置文件或用户输入时，你可能需要根据这些动态信息来访问对象的属性。

2、实现可选参数或默认值：在某些情况下，你可能想为对象的属性提供默认值，以防该属性不存在。getattr()函数的 “default” 参数非常适合这种情况。

3、实现灵活的API：在构建API或库时，你可能希望允许用户通过字符串来访问函数或方法，而不是直接调用它们。这可以通过将函数或方法作为对象的属性，并使用getattr()函数来实现。

4、插件和扩展系统：在构建可扩展的系统时，getattr()函数可以用于动态加载和执行插件或扩展。例如，一个框架可能允许用户通过添加具有特定方法的对象来扩展其功能。

5、配置文件和设置管理：在处理配置文件或应用程序设置时，getattr()函数可以用来动态地获取配置选项的值。这允许你在不修改代码的情况下更改配置，并使代码更加模块化和可维护。

6、与外部库或模块交互：当与外部库或模块交互时，你可能不知道它们的确切属性或方法名称，或者这些名称可能在不同的版本中有所变化。使用getattr()函数可以使你的代码更加灵活和健壮，因为它允许你动态地访问这些属性或方法。

7、动态类创建：结合type()函数，你可以使用getattr()函数动态地创建类。

8、结合装饰器使用：你可以使用装饰器和getattr()函数结合来动态地添加或修改对象的属性或方法。

        总之，由于 Python 的动态性，getattr()函数的应用非常广泛，几乎可以在任何需要动态访问或操作对象属性的地方使用。

二、getattr函数使用注意事项：

        在使用 Python 中的getattr()函数时，需注意以下事项：

1、异常处理：如果尝试获取的对象没有指定的属性，并且没有提供 `default` 参数，`getattr()` 会引发 `AttributeError`。因此，你应该始终准备好处理这种异常，或者使用 `default` 参数来避免它。

2、属性名称作为字符串：getattr()函数的第二个参数必须是字符串，表示要获取的属性的名称。如果你传递了非字符串类型的参数，会引发 `TypeError`。

3、区分方法和属性：如果你使用getattr()函数获取的是一个方法而不是一个属性，你需要记得调用这个方法(加上括号)，否则，你会得到一个方法对象而不是它的返回值。

4、安全性和权限：在使用getattr()函数访问对象的属性时，要注意不要违反封装原则或访问不应该被外部访问的属性。如果对象的设计意图是隐藏某些属性或方法，你应该尊重这一点，并仅通过对象提供的公共接口进行交互。

5、避免过度使用：虽然getattr()函数提供了很大的灵活性，但过度使用它可能会使代码难以理解和维护。在大多数情况下，直接访问对象的属性或调用方法更加清晰和直接。只有在确实需要动态访问属性或实现某种特定逻辑时，才应使用getattr()函数。

6、与对象特殊方法的区别：getattr()函数是一个内置函数，用于从对象中获取属性。而 `__getattr__` 和 `__getattribute__` 是对象的特殊方法，用于在属性访问失败时定义自定义行为。它们通常在类定义中使用，而不是在普通的代码逻辑中。在使用这些特殊方法时要特别小心，因为它们会改变对象属性访问的基本行为。

1、getattr函数：
1-1、Python：
  1. # 1.函数：getattr
  2. # 2.功能：用于获取对象的属性值
  3. # 3.语法：getattr(object, name [,default])
  4. # 4.参数：
  5. # 4-1、object：必须，对象。Python内置了一些基本的对象类型，包括但不限于：
  6. #   4-1-1、 数字(Numbers):
  7.     # int：整数
  8.     # float：浮点数
  9.     # complex：复数
  10. #   4-1-2、 序列(Sequences):
  11.     # list：列表，可以包含任意类型的元素
  12.     # tuple：元组，与列表类似但不可变
  13.     # str：字符串，字符序列
  14.     # bytes：字节序列
  15.     # bytearray：可变字节序列
  16.     # memoryview：内存视图，是原始数据的不同解释
  17. #   4-1-3、集合(Sets):
  18.     # set：无序且不包含重复元素的集合
  19.     # frozenset：不可变的集合
  20. #   4-1-4、映射(Mappings):
  21.     # dict：字典，键值对映射
  22. #   4-1-5、布尔值(Booleans):
  23.     # bool：布尔类型，只有两个值:True和False
  24. #   4-1-6、类型(Types):
  25.     # type：类型对象，用于描述其他对象的数据类型
  26. #   4-1-7、其他内置类型:
  27.     # NoneType：只有一个值None，表示空或没有值
  28.     # ellipsis：...，通常用于切片操作或表示省略
  29.     # slice：表示切片对象，用于切片操作
  30.     # range：表示不可变的整数序列，通常用于循环
  31.     # property：用于获取、设置或删除属性的内置装饰器类型
  32.     # function：函数对象
  33.     # method：方法对象，即绑定到类实例的函数
  34.     # classmethod和staticmethod：特殊的方法类型，分别表示类方法和静态方法
  35.     # module：模块对象
  36.     # traceback、frame和code：与异常和调试相关的对象
  37. # 4-2. name：必须，字符串，对象属性
  38. # 4-3、default：可选，默认返回值，若不提供该参数，在没有对应属性时，将触发AttributeError错误
  39. # 5.返回值：返回对象属性
  40. # 6.说明：
  41. # 7.示例：
  42. # 应用1：动态属性管理
  43. # 访问对象属性
  44. class MyClass:
  45.     def __init__(self):
  46.         self.my_attribute = "Hello, Python!"
  47. obj = MyClass()
  48. # 使用getattr访问属性
  49. attribute_value = getattr(obj, 'my_attribute')
  50. print(attribute_value)
  51. # Hello, Python!
  52.  
  53. # 灵活处理属性不存在的情况
  54. class MyClass:
  55.     def __init__(self):
  56.         self.existing_attribute = "I exist!"
  57. obj = MyClass()
  58. # 尝试访问一个不存在的属性，使用default参数来避免AttributeError
  59. attribute_value = getattr(obj, 'non_existing_attribute', 'Default value')
  60. print(attribute_value)
  61. # Default value
  62.  
  63. # 动态调用方法
  64. class MyClass:
  65.     def say_hello(self):
  66.         print("Hello!")
  67.  
  68.     def say_goodbye(self):
  69.         print("Goodbye!")
  70. obj = MyClass()
  71. # 根据用户输入动态调用方法
  72. method_name = input("Enter method name (say_hello or say_goodbye): ")
  73. if hasattr(obj, method_name):
  74.     getattr(obj, method_name)()
  75. else:
  76.     print(f"No such method: {method_name}")
  77. # Enter method name (say_hello or say_goodbye): say_hello
  78. # Hello!
  79.  
  80. # 处理嵌套对象
  81. class InnerClass:
  82.     def __init__(self):
  83.         self.value = "Inner value"
  84. class OuterClass:
  85.     def __init__(self):
  86.         self.inner = InnerClass()
  87. obj = OuterClass()
  88. # 使用getattr访问嵌套对象的属性
  89. inner_value = getattr(getattr(obj, 'inner'), 'value')
  90. print(inner_value)
  91. # Inner value
  92.  
  93. # 动态设置属性
  94. class MyClass:
  95.     pass
  96. obj = MyClass()
  97. # 使用setattr动态设置属性
  98. setattr(obj, 'new_attribute', 'This is a new attribute')
  99. # 使用getattr获取刚刚设置的属性
  100. attribute_value = getattr(obj, 'new_attribute')
  101. print(attribute_value)
  102. # This is a new attribute
  103.  
  104. # 实现链式调用
  105. class Chainable:
  106.     def __init__(self):
  107.         self.value = 0
  108.     def add(self, value):
  109.         self.value += value
  110.         return self
  111.     def result(self):
  112.         return self.value
  113. obj = Chainable()
  114. result = getattr(getattr(obj, 'add')(5), 'add')(10).result()
  115. print(result)
  116. # 15
  117.  
  118. # 应用2：实现可选参数或默认值
  119. class User:
  120.     def __init__(self, name):
  121.         self.name = name
  122.         self.age = None
  123. user = User("Myelsa")
  124. age = getattr(User, "age", 18)  # 如果age不存在，则返回18
  125. print(age)
  126. # 18
  127.  
  128. # 应用3：实现灵活的API
  129. class API:
  130.     def method1(self):
  131.         return "Method 1 called"
  132.  
  133.     def method2(self):
  134.         return "Method 2 called"
  135. api = API()
  136. method_name = input("请输入要调用的方法名（method1 或 method2）：")
  137. result = getattr(api, method_name, lambda: "Invalid method")()
  138. print(result)
  139. # 请输入要调用的方法名（method1 或 method2）：method1
  140. # Method 1 called
  141.  
  142. # 应用4：插件和扩展系统
  143. import os
  144. class PluginBase:
  145.     def execute(self):
  146.         raise NotImplementedError("Subclasses must implement this!")
  147. plugins = []
  148. def load_plugins(directory):
  149.     for filename in os.listdir(directory):
  150.         if filename.endswith(".py"):
  151.             module_name = os.path.splitext(filename)[0]
  152.             module = importlib.import_module(f"plugins.{module_name}")
  153.             for attr_name in dir(module):
  154.                 attr = getattr(module, attr_name)
  155.                 if isinstance(attr, type) and issubclass(attr, PluginBase):
  156.                     plugins.append(attr())
  157. def run_plugins():
  158.     for plugin in plugins:
  159.         plugin.execute()
  160. # 加载并执行插件
  161. load_plugins("plugins_myelsa") # 假设存在插件plugins_myelsa
  162. run_plugins()
  163.  
  164. # 应用5：配置文件和设置管理
  165. class Config:
  166.     DEBUG = False
  167.     DATABASE_URL = 'sqlite:///db.sqlite3'
  168. config = Config()
  169. debug_mode = getattr(config, 'DEBUG', False)
  170. database_url = getattr(config, 'DATABASE_URL', 'default_database_url')
  171.  
  172. # 应用6：与外部库或模块交互
  173. def interact_with_external_module(module_name, attribute_name):
  174.     module = __import__(module_name)
  175.     attribute = getattr(module, attribute_name, None)
  176.     if attribute:
  177.         # 使用attribute执行操作
  178.         pass
  179.     else:
  180.         print(f"Attribute {attribute_name} not found in module {module_name}")
  181.  
  182. # 应用7：动态类创建
  183. def dynamic_class_factory(class_name, base_class, attribute_dict):
  184.     class Meta(base_class):
  185.         pass
  186.     for name, value in attribute_dict.items():
  187.         setattr(Meta, name, value)
  188.     return Meta
  189. attribute_dict = {'my_attribute': 'Hello, world!'}
  190. DynamicClass = dynamic_class_factory('DynamicClass', object, attribute_dict)
  191. instance = DynamicClass()
  192. print(getattr(instance, 'my_attribute'))
  193. # Hello, world!
  194.  
  195. # 应用8：结合装饰器使用
  196. def dynamic_property(func):
  197.     def wrapper(self, *args, **kwargs):
  198.         attr_name = '_' + func.__name__
  199.         if not hasattr(self, attr_name):
  200.             setattr(self, attr_name, func(self, *args, **kwargs))
  201.         return getattr(self, attr_name)
  202.     return wrapper
  203. class MyClass:
  204.     @dynamic_property
  205.     def expensive_calculation(self):
  206.         print("Calculating...")
  207.         return 42
  208. obj = MyClass()
  209. print(obj.expensive_calculation)
  210. print(obj.expensive_calculation)
  211. # .wrapper of <__main__.MyClass object at 0x000002254717D850>>
  212. # .wrapper of <__main__.MyClass object at 0x000002254717D850>>
1-2、VBA：
略，待后补。
2、推荐阅读：

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

2-2、Python-VBA函数之旅-bytes()函数 

Python算法之旅：Algorithm

Python函数之旅：Functions

个人主页：神奇夜光杯-CSDN博客
文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览61139 人正在系统学习中
遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/137987118"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！