Python-VBA函数之旅-property函数

目录

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

二、property函数使用注意事项

三、如何用好property函数？

1、property函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

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

  

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

        在Python中，property()函数(或更常见的是@property装饰器)的实际应用场景非常广泛，主要用于封装类的内部状态并提供对外的访问接口，常见的应用场景有：

1、隐藏内部实现细节：通过getter和setter方法，我们可以隐藏对象的内部状态，只暴露必要的接口给外部调用者，这有助于保护对象的状态不被随意修改，同时也使得代码更加易于理解和维护。

2、添加属性验证：在setter方法中，我们可以添加对属性值的验证逻辑。例如，我们可以确保一个年龄属性总是大于0，或者一个邮箱地址属性总是符合某种格式。

3、计算属性：有些属性可能不是直接存储在对象的状态中的，而是需要基于其他属性计算得出，通过使用property，我们可以将这样的属性表示为对象的一个“正常”属性，而无需调用一个方法来获取它。

4、延迟计算：对于某些计算成本较高的属性，我们可能希望在第一次访问时才进行计算，并将结果缓存起来，通过使用property和内部变量，我们可以实现这样的延迟计算。

5、访问控制： property()函数允许你控制对属性的访问权限。例如，你可以使属性只读，或者只允许在特定条件下修改属性。

6、简化接口：在某些情况下，你可能想要隐藏对象的内部复杂性，只向外部提供一个简洁的接口，使用property可以将内部方法(如getter、setter)暴露为看起来像普通属性的接口。

7、实现数据绑定：在更复杂的场景中，property可以与观察者模式(Observer Pattern)或数据绑定库结合使用，以实现当属性发生变化时自动触发某些操作或更新UI等效果。

8、线程安全：在多线程环境中，对属性的直接访问可能会导致数据竞争或其他并发问题，使用property可以确保在访问或修改属性时执行必要的同步操作，从而保证线程安全。

9、日志记录或监控：在获取或设置属性时，你可能想要记录一些信息(如访问时间、访问者等)，或者触发某些监控事件，通过property可以轻松实现这些功能。

10、惰性加载：对于某些需要大量计算或需要从外部资源(如数据库或网络)加载的属性，可以使用property实现惰性加载，这意味着属性只有在首次被访问时才会进行计算或加载，从而节省资源。

二、property函数使用注意事项

        在Python中，property()函数是一个内置函数，用于在新式类中返回属性值；property()函数允许你定义getter，setter和deleter方法，这些方法分别用于获取、设置和删除对象的属性。以下是在使用property()函数时需要注意的一些事项：

1、定义getter/setter/deleter方法：getter方法通常不需要任何参数，并返回属性的值；setter方法需要接收两个参数：self和要设置的值value；deleter方法只需要self参数。   

  1. 示例：
  2.    class Circle:
  3.        def __init__(self, radius=1.0):
  4.            self._radius = radius
  5.  
  6.        @property
  7.        def radius(self):
  8.            return self._radius
  9.  
  10.        @radius.setter
  11.        def radius(self, value):
  12.            if value < 0:
  13.                raise ValueError("Radius cannot be negative")
  14.            self._radius = value
  15.  
  16.        @radius.deleter
  17.        def radius(self):
  18.            del self._radius

2、私有属性：当你使用@property装饰器时，通常建议将实际存储数据的属性设为私有(例如使用下划线前缀)，以避免直接访问和修改它们。

3、装饰器语法：你可以使用装饰器语法来定义getter，setter和deleter方法；另一种语法是使用property()函数直接返回getter，setter和deleter方法作为元组，但这种方法较少使用，因为它不够直观。

4、性能：虽然property()通常不会成为性能瓶颈，但在需要处理大量对象的场合中，频繁地调用getter或setter可能会产生一些开销，在这种情况下，你可能需要考虑其他方法，如使用@cached_property装饰器(来自cached_property库或类似库)来缓存getter方法的返回值。

5、线程安全：如果你在多线程环境中使用setter或deleter方法，并且这些方法可能会修改共享状态，那么你需要确保这些方法是线程安全的。

6、错误处理：在setter方法中，你可能需要添加错误处理逻辑来确保设置的值是有效的。

7、文档字符串：为getter，setter和deleter方法提供文档字符串是一个好习惯，这有助于其他开发者理解这些方法的作用和用法。

8、可读性：当使用property()函数时，确保你的getter，setter和deleter方法的命名清晰易懂，以便其他开发者能够轻松理解你的代码。

9、继承：虽然property()函数提供了更好的封装和抽象，但它也带来了一定的开销，因为每次访问属性时都会调用一个方法，然而，在大多数情况下，这种开销是可以接受的，因为Python方法调用的开销相对较低。

10、向后兼容性：如果你的类需要向后兼容Python 2，请注意property()函数在Python 2和Python 3中的行为可能略有不同：在Python 2中，property()是一个内置的工厂函数；而在Python 3中，它不仅是一个内置函数，也可以用作装饰器。

三、如何用好property函数？

        在Python中，property()函数是一个内置函数，用于创建只读的、可写的或可删除的属性，这提供了一种将方法作为属性访问的方式，从而简化了对对象属性的访问和修改。

property()函数的基本用法有三种：

1、只读属性：只需要定义一个getter方法。

  1. class MyClass:
  2.     def __init__(self, value):
  3.         self._value = value
  4.  
  5.     @property
  6.     def value(self):
  7.         return self._value
  8.  
  9. obj = MyClass(10)
  10. print(obj.value)  # 输出: 10

在这个例子中，`value` 是一个只读属性，只能通过 `obj.value` 来访问，但不能直接赋值。

2、可读写属性：除了getter方法，还需要定义一个setter方法。

  1. class MyClass:
  2.     def __init__(self, value):
  3.         self._value = value
  4.  
  5.     @property
  6.     def value(self):
  7.         return self._value
  8.  
  9.     @value.setter
  10.     def value(self, new_value):
  11.         if new_value < 0:
  12.             raise ValueError("Value must be non-negative")
  13.         self._value = new_value
  14.  
  15. obj = MyClass(10)
  16. print(obj.value)  # 输出: 10
  17. obj.value = 20
  18. print(obj.value)  # 输出: 20
  19. obj.value = -1    # 抛出 ValueError

在这个例子中，`value` 是一个可读写属性，可以通过 `obj.value` 来访问，也可以通过 `obj.value = new_value` 来修改，在setter方法中，我们还添加了一个简单的验证逻辑。

3、可删除属性：除了getter和setter方法，还需要定义一个deleter方法。

  1. class MyClass:
  2.     def __init__(self, value):
  3.         self._value = value
  4.  
  5.     @property
  6.     def value(self):
  7.         return self._value
  8.  
  9.     @value.setter
  10.     def value(self, new_value):
  11.         self._value = new_value
  12.  
  13.     @value.deleter
  14.     def value(self):
  15.         del self._value
  16. obj = MyClass(10)
  17. print(obj.value)  # 输出: 10
  18. obj.value = 20
  19. print(obj.value)  # 输出: 20
  20. del obj.value
  21. # 尝试访问 obj.value 将引发 AttributeError

在这个例子中，`value` 是一个可删除的属性，可以使用 `del obj.value` 来删除它。

注意：虽然property()函数可以直接使用，但通常建议使用@property、@value.setter和 @value.deleter装饰器来定义属性，因为它们更加简洁和易读。

1、property函数：
1-1、Python：
  1. # 1.函数：property
  2. # 2.功能：用于创建属性实例，这些实例可以绑定到类的方法上，从而允许我们像访问数据属性一样访问类的方法
  3. # 3.语法：property([fget=None[, fset=None[, fdel=None[, doc=None]]]])
  4. # 4.参数：
  5. # 4-1、fget：用于获取属性值的方法(getter)，它应该是一个不带参数的方法，并且返回一个值；如果省略，则属性为只读
  6. # 4-2、fset：用于设置属性值的方法(setter)，它应该是一个接受一个参数(新值)的方法，并且不返回任何内容(或者返回None)；如果省略，则属性为只读
  7. # 4-3、fdel：用于删除属性的方法(deleter)，它应该是一个不带参数的方法，并且不返回任何内容(或者返回None)；如果省略，则不能删除属性
  8. # 4-4、doc：一个可选的字符串，作为属性的文档字符串，如果省略，则使用`fget`、`fset`或`fdel`方法中的文档字符串(如果存在的话)
  9. # 5.返回值：返回类的属性
  10. # 6.说明：
  11. # 6-1、如果给出doc参数，doc将成为该property属性的文档字符串；否则该property将复制fget/fset/fdel等方法中的文档字符串(如果存在的话)
  12. # 7.示例：
  13. # 用dir()函数获取该函数内置的属性和方法
  14. print(dir(property))
  15. # ['__class__', '__delattr__', '__delete__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__',
  16. # '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__isabstractmethod__', '__le__', '__lt__',
  17. # '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__set__', '__set_name__', '__setattr__', '__sizeof__',
  18. # '__str__', '__subclasshook__', 'deleter', 'fdel', 'fget', 'fset', 'getter', 'setter']
  19.  
  20. # 用help()函数获取该函数的文档信息
  21. help(property)
  22.  
  23. # 应用一：隐藏内部实现细节
  24. class Circle:
  25.     def __init__(self, radius):
  26.         self._radius = radius
  27.  
  28.     @property
  29.     def radius(self):
  30.         """Getter for radius."""
  31.         return self._radius
  32.  
  33.     @radius.setter
  34.     def radius(self, value):
  35.         """Setter for radius, checks if value is positive."""
  36.         if value < 0:
  37.             raise ValueError("Radius cannot be negative.")
  38.         self._radius = value
  39.  
  40.     @property
  41.     def diameter(self):
  42.         """Calculate and return the diameter."""
  43.         return 2 * self._radius
  44.  
  45.     @property
  46.     def area(self):
  47.         """Calculate and return the area."""
  48.         import math
  49.         return math.pi * (self._radius ** 2)
  50. # 注意：diameter和area是只读的，因为它们没有setter方法
  51. # 使用Circle类
  52. c = Circle(5)
  53. print(c.radius)  # 访问radius属性
  54. print(c.diameter)  # 访问diameter属性(只读)
  55. print(c.area)  # 访问area属性(只读)
  56. # 5
  57. # 10
  58. # 78.53981633974483
  59.  
  60. c.radius = 10  # 修改radius属性
  61. print(c.radius)  # 再次访问radius属性，确认已修改
  62. print(c.diameter)  # 再次访问diameter属性，确认已根据新的radius更新
  63. print(c.area)  # 再次访问area属性，确认已根据新的radius更新
  64. # 10
  65. # 20
  66. # 314.1592653589793
  67.  
  68. # 尝试设置直径或面积(这将失败，因为它们没有setter方法)
  69. # c.diameter = 15  # 这会抛出一个 AttributeError
  70. # c.area = 50      # 这也会抛出一个 AttributeError
  71. # AttributeError: property 'diameter' of 'Circle' object has no setter
  72.  
  73. # 应用二：添加属性验证
  74. class Person:
  75.     def __init__(self, name, age):
  76.         self._name = name
  77.         self._age = None
  78.         self.age = age  # 使用setter方法进行初始化
  79.  
  80.     @property
  81.     def name(self):
  82.         return self._name
  83.  
  84.     @property
  85.     def age(self):
  86.         """Getter for age."""
  87.         return self._age
  88.  
  89.     @age.setter
  90.     def age(self, value):
  91.         """Setter for age, checks if value is a positive integer."""
  92.         if not isinstance(value, int) or value < 0:
  93.             raise ValueError("Age must be a positive integer.")
  94.         self._age = value
  95.  
  96.     # 如果你想要一个deleter方法，可以添加如下：
  97.     @age.deleter
  98.     def age(self):
  99.         raise AttributeError("Cannot delete the age attribute.")
  100. # 使用 Person 类
  101. try:
  102.     p = Person("Myelsa", 18)
  103.     print(p.name)  # 输出: Myelsa
  104.     print(p.age)  # 输出: 18
  105.  
  106.     p.age = 42  # 修改age属性
  107.     print(p.age)  # 输出: 42
  108.  
  109.     # 尝试设置不合法的age值
  110.     p.age = -1  # 抛出 ValueError
  111.     # p.age = "fourty two"  # 也会抛出ValueError
  112. except ValueError as e:
  113.     print(e)
  114. # Myelsa
  115. # 18
  116. # 42
  117. # Age must be a positive integer.
  118.  
  119. # 尝试删除age属性(如果已定义deleter)
  120. del p.age  # 如果 deleter 存在且未抛出AttributeError，则会执行
  121. # 否则，上面的代码会按原样运行，因为deleter抛出了AttributeError
  122. # AttributeError: Cannot delete the age attribute.
  123.  
  124. # 应用三：计算属性
  125. class Rectangle:
  126.     def __init__(self, width, height):
  127.         self._width = width
  128.         self._height = height
  129.  
  130.     @property
  131.     def width(self):
  132.         """Getter for width."""
  133.         return self._width
  134.  
  135.     @width.setter
  136.     def width(self, value):
  137.         """Setter for width."""
  138.         if value < 0:
  139.             raise ValueError("Width cannot be negative.")
  140.         self._width = value
  141.  
  142.     @property
  143.     def height(self):
  144.         """Getter for height."""
  145.         return self._height
  146.  
  147.     @height.setter
  148.     def height(self, value):
  149.         """Setter for height."""
  150.         if value < 0:
  151.             raise ValueError("Height cannot be negative.")
  152.         self._height = value
  153.  
  154.     @property
  155.     def area(self):
  156.         """Calculate and return the area."""
  157.         return self._width * self._height
  158.  
  159.     @property
  160.     def perimeter(self):
  161.         """Calculate and return the perimeter."""
  162.         return 2 * (self._width + self._height)
  163.  
  164. # 使用Rectangle类
  165. rect = Rectangle(5, 10)
  166. print(rect.area)  # 输出: 50 (宽度5乘以高度10)
  167. print(rect.perimeter)  # 输出: 30 (两倍的(宽度5加高度10))
  168.  
  169. rect.width = 7
  170. print(rect.area)  # 输出: 70 (新的宽度7乘以高度10)
  171. print(rect.perimeter)  # 输出: 34 (两倍的(新的宽度7加高度10))
  172. # 50
  173. # 30
  174. # 70
  175. # 34
  176.  
  177. # 应用四：延迟计算
  178. class Circle:
  179.     def __init__(self, radius):
  180.         self._radius = radius
  181.         self._area = None
  182.         self._circumference = None
  183.  
  184.     @property
  185.     def radius(self):
  186.         """Getter for radius."""
  187.         return self._radius
  188.  
  189.     @radius.setter
  190.     def radius(self, value):
  191.         """Setter for radius."""
  192.         if value < 0:
  193.             raise ValueError("Radius cannot be negative.")
  194.         self._radius = value
  195.         # 当半径改变时，重置缓存的area和circumference
  196.         self._area = None
  197.         self._circumference = None
  198.  
  199.     @property
  200.     def area(self):
  201.         """Calculate and cache the area."""
  202.         if self._area is None:
  203.             self._area = 3.14159 * self._radius ** 2
  204.         return self._area
  205.  
  206.     @property
  207.     def circumference(self):
  208.         """Calculate and cache the circumference."""
  209.         if self._circumference is None:
  210.             self._circumference = 2 * 3.14159 * self._radius
  211.         return self._circumference
  212. # 使用 Circle 类
  213. circle = Circle(5)
  214. print(circle.area)  # 首次访问，进行计算并缓存结果
  215. print(circle.circumference)  # 首次访问，进行计算并缓存结果
  216.  
  217. # 再次访问，直接从缓存中获取结果
  218. print(circle.area)  # 输出与之前相同，因为结果是缓存的
  219. print(circle.circumference)  # 输出与之前相同，因为结果是缓存的
  220.  
  221. circle.radius = 7
  222. print(circle.area)  # 半径改变，重新计算并缓存新的area
  223. print(circle.circumference)  # 半径改变，重新计算并缓存新的circumference
  224. # 78.53975
  225. # 31.4159
  226. # 78.53975
  227. # 31.4159
  228. # 153.93791
  229. # 43.98226
  230.  
  231. # 应用五：访问控制
  232. class AccessControlled:
  233.     def __init__(self, value):
  234.         self._value = value
  235.  
  236.     def get_value(self):
  237.         """Getter for value."""
  238.         # 在这里可以添加访问前的验证或逻辑
  239.         print("Reading value...")
  240.         return self._value
  241.  
  242.     def set_value(self, value):
  243.         """Setter for value."""
  244.         # 在这里可以添加设置前的验证或逻辑
  245.         if value < 0:
  246.             raise ValueError("Value cannot be negative.")
  247.         print("Setting value...")
  248.         self._value = value
  249.  
  250.     def del_value(self):
  251.         """Deleter for value."""
  252.         # 在这里可以添加删除前的验证或逻辑
  253.         print("Deleting value...")
  254.         del self._value
  255.     # 使用property()将方法绑定到属性
  256.     value = property(get_value, set_value, del_value, "This is a controlled access value.")
  257. # 使用AccessControlled类
  258. obj = AccessControlled(10)
  259. # 读取属性值
  260. print(obj.value)  # 输出: Reading value... 10
  261. # 设置属性值
  262. obj.value = 20
  263. # 输出: Setting value...
  264. # 尝试设置不合法的属性值
  265. try:
  266.     obj.value = -5
  267. except ValueError as e:
  268.     print(e)  # 输出: Value cannot be negative.
  269. # 删除属性值
  270. del obj.value
  271. # 输出: Deleting value...
  272. # 尝试访问已删除的属性值
  273. try:
  274.     print(obj.value)
  275. except AttributeError:
  276.     print("Value has been deleted.")  # 输出: Value has been deleted.
  277. # Reading value...
  278. # 10
  279. # Setting value...
  280. # Value cannot be negative.
  281. # Deleting value...
  282. # Reading value...
  283. # Value has been deleted.
  284.  
  285. # 应用六：简化接口
  286. class Rectangle:
  287.     def __init__(self, width, height):
  288.         self._width = width
  289.         self._height = height
  290.  
  291.     @property
  292.     def width(self):
  293.         """Getter for width."""
  294.         return self._width
  295.  
  296.     @width.setter
  297.     def width(self, value):
  298.         """Setter for width."""
  299.         if value < 0:
  300.             raise ValueError("Width cannot be negative.")
  301.         self._width = value
  302.  
  303.     @property
  304.     def height(self):
  305.         """Getter for height."""
  306.         return self._height
  307.  
  308.     @height.setter
  309.     def height(self, value):
  310.         """Setter for height."""
  311.         if value < 0:
  312.             raise ValueError("Height cannot be negative.")
  313.         self._height = value
  314.  
  315.     @property
  316.     def area(self):
  317.         """Calculate and return the area of the rectangle."""
  318.         return self._width * self._height
  319.  
  320.     @property
  321.     def perimeter(self):
  322.         """Calculate and return the perimeter of the rectangle."""
  323.         return 2 * (self._width + self._height)
  324. # 使用 Rectangle 类
  325. rect = Rectangle(5, 10)
  326.  
  327. # 访问属性，无需关心内部计算
  328. print(rect.area)  # 输出: 50
  329. print(rect.perimeter)  # 输出: 30
  330.  
  331. # 设置属性
  332. rect.width = 7
  333. rect.height = 8
  334.  
  335. # 再次访问属性
  336. print(rect.area)  # 输出: 56
  337. print(rect.perimeter)  # 输出: 30
  338.  
  339. # 尝试设置不合法的属性值
  340. try:
  341.     rect.width = -5
  342. except ValueError as e:
  343.     print(e)  # 输出: Width cannot be negative.
  344. # 50
  345. # 30
  346. # 56
  347. # 30
  348. # Width cannot be negative.
  349.  
  350. # 应用七：实现数据绑定
  351. class DataBinder:
  352.     def __init__(self, initial_value, callback=None):
  353.         self._value = initial_value
  354.         self._callback = callback
  355.  
  356.     @property
  357.     def value(self):
  358.         """Getter for value."""
  359.         return self._value
  360.  
  361.     @value.setter
  362.     def value(self, new_value):
  363.         """Setter for value. Triggers the callback if provided."""
  364.         self._value = new_value
  365.         if self._callback:
  366.             self._callback(new_value)
  367.  
  368. # 定义一个回调函数来模拟数据绑定的效果
  369. def on_value_change(new_value):
  370.     print(f"Value has changed to: {new_value}")
  371. # 使用 DataBinder 类并设置回调函数
  372. binder = DataBinder(10, on_value_change)
  373.  
  374. # 访问属性值
  375. print(binder.value)  # 输出: 10
  376.  
  377. # 修改属性值，这会触发回调函数
  378. binder.value = 20
  379. # 输出: Value has changed to: 20
  380.  
  381. # 再次修改属性值
  382. binder.value = 30
  383. # 输出: Value has changed to: 30
  384.  
  385. # 应用八：线程安全
  386. import threading
  387. class ThreadSafeClass:
  388.     def __init__(self):
  389.         self._value = 0
  390.         self._lock = threading.Lock()
  391.  
  392.     @property
  393.     def value(self):
  394.         """线程安全的getter方法"""
  395.         with self._lock:
  396.             return self._value
  397.  
  398.     @value.setter
  399.     def value(self, new_value):
  400.         """线程安全的setter方法"""
  401.         with self._lock:
  402.             self._value = new_value
  403. # 使用示例
  404. if __name__ == "__main__":
  405.     # 创建一个ThreadSafeClass的实例
  406.     obj = ThreadSafeClass()
  407.     # 假设我们有两个线程，它们将尝试同时访问和修改obj.value
  408.     def worker(obj, name, increment):
  409.         for _ in range(100000):  # 假设我们进行大量操作以突出线程安全问题
  410.             with obj._lock:  # 在这里，我们只是为了演示而手动加锁，但在实际setter/getter中不需要
  411.                 old_value = obj.value
  412.                 new_value = old_value + increment
  413.                 obj.value = new_value
  414.             print(f"{name}: Value after increment is {obj.value}")
  415.     # 创建两个线程
  416.     t1 = threading.Thread(target=worker, args=(obj, "Thread 1", 1))
  417.     t2 = threading.Thread(target=worker, args=(obj, "Thread 2", -1))
  418.     # 启动线程
  419.     t1.start()
  420.     t2.start()
  421.     # 等待线程完成
  422.     t1.join()
  423.     t2.join()
  424.     # 输出最终值(可能不是0，因为线程调度是随机的，但每次操作都是线程安全的)
  425.     print(f"Final value: {obj.value}")
  426.  
  427. # 应用九：日志记录或监控
  428. import logging
  429. class LoggedPropertyClass:
  430.     def __init__(self):
  431.         self._value = None
  432.         self._logger = logging.getLogger(__name__)
  433.         self._logger.setLevel(logging.INFO)
  434.  
  435.         # 创建一个handler，用于写入日志文件
  436.         fh = logging.FileHandler('property_log.log')
  437.         fh.setLevel(logging.INFO)
  438.  
  439.         # 再创建一个handler，用于输出到控制台
  440.         ch = logging.StreamHandler()
  441.         ch.setLevel(logging.INFO)
  442.  
  443.         # 定义handler的输出格式
  444.         formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
  445.         fh.setFormatter(formatter)
  446.         ch.setFormatter(formatter)
  447.  
  448.         # 给logger添加handler
  449.         self._logger.addHandler(fh)
  450.         self._logger.addHandler(ch)
  451.  
  452.     @property
  453.     def value(self):
  454.         """Getter方法，用于访问_value属性，并添加日志记录"""
  455.         self._logger.info("Accessing value: %s", self._value)
  456.         return self._value
  457.  
  458.     @value.setter
  459.     def value(self, new_value):
  460.         """Setter方法，用于设置_value属性，并添加日志记录"""
  461.         self._logger.info("Setting value to: %s", new_value)
  462.         self._value = new_value
  463.  
  464. # 使用示例
  465. if __name__ == "__main__":
  466.     obj = LoggedPropertyClass()
  467.     obj.value = 42  # 这将触发setter方法并记录日志
  468.     print(obj.value)  # 这将触发getter方法并记录日志
  469. # 42
  470. # 2024-05-07 18:46:57,919 - __main__ - INFO - Setting value to: 42
  471. # 2024-05-07 18:46:57,919 - __main__ - INFO - Accessing value: 42
  472.  
  473. # 应用十：惰性加载
  474. class LazyLoadedClass:
  475.     def __init__(self):
  476.         # 初始化时，我们不立即加载数据，而是设置一个标记
  477.         self._data = None
  478.         self._loaded = False
  479.  
  480.     @property
  481.     def data(self):
  482.         """惰性加载的getter方法"""
  483.         if not self._loaded:
  484.             # 模拟数据加载过程，这里可以替换为实际的数据加载逻辑
  485.             self._data = self._load_data()
  486.             self._loaded = True
  487.         return self._data
  488.  
  489.     def _load_data(self):
  490.         """模拟的数据加载函数"""
  491.         # 这里可以放置实际的加载逻辑，比如从数据库、文件或网络请求中获取数据
  492.         # 这里我们只是简单地返回一个固定的值作为示例
  493.         print("Loading data...")
  494.         return "Loaded data"
  495.  
  496. # 使用示例
  497. if __name__ == "__main__":
  498.     obj = LazyLoadedClass()
  499.     print(obj.data)  # 第一次访问，会加载数据并打印"Loading data..."，然后返回"Loaded data"
  500.     print(obj.data)  # 第二次访问，因为数据已经被加载和缓存，所以不会再次加载，直接返回"Loaded data"
  501. # Loading data...
  502. # Loaded data
  503. # Loaded data
1-2、VBA：
略，待后补。
2、推荐阅读：

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

Python算法之旅：Algorithm

Python函数之旅：Functions

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

评论记录：

未查询到任何数据！