Python-VBA函数之旅-id函数

目录

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

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

1、id函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

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

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

        id函数在Python中有一些实际应用场景，尽管它在日常编程中并不常用，常见的应用场景有：

1、调试和内存管理：在开发过程中，特别是在处理复杂的数据结构或进行性能优化时，id()函数可以用来检查对象是否在内存中被正确地创建和销毁，通过比较对象的id，可以追踪对象的生命周期，以及检测是否发生了意外的对象复制或重复创建。

2、检查对象是否相同：虽然通常我们使用`==`操作符来比较两个对象的值是否相等，但id()函数可以用来检查两个引用是否指向内存中的同一个对象，这在某些情况下可能是有用的，特别是当你需要确保两个引用不指向同一个可变对象，以避免意外的共享状态。

3、单例模式实现：在单例模式中，确保一个类只有一个实例，并提供一个全局访问点，在实现单例时，id()函数可以用来检查是否已经创建了实例，从而避免重复创建。

4、性能分析和优化：id()函数可以帮助你了解对象的创建和销毁情况，这对于性能分析和优化可能是有用的。例如，如果你发现某个函数在每次调用时都创建了大量的临时对象，这可能会导致不必要的内存分配和垃圾回收开销，通过检查这些对象的id，你可以确定它们是否在每次调用时都被重新创建。

5、缓存和重用对象：在某些情况下，你可能希望重用已经创建过的对象，而不是每次都创建新的对象，通过存储对象的id，你可以检查是否已经创建了具有相同属性或状态的对象，并重用它们而不是创建新的。

        注意，id()函数返回的是对象的内存地址，这取决于Python解释器的实现和当前的内存状态。因此，它不应该被用于一般的对象比较或逻辑判断，在大多数情况下，应该使用`==`操作符来比较对象的值，使用`is`操作符来比较对象的身份(即它们是否指向同一个对象)。

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

        在Python中使用id()函数时，需要注意以下几点：

1、不要依赖特定的id值：id()函数返回的是对象的“标识”或内存地址，这个值依赖于Python解释器的实现和当前内存状态。因此，不要编写依赖于特定id值的代码，因为不同运行时刻或不同解释器中的相同对象可能会有不同的id。

2、不要用于比较对象的相等性：即使两个对象具有相同的值，它们的id也可能不同，因为它们是内存中的不同实例。相反，即使两个对象的id相同，也不意味着它们的值一定相等(尽管在对象的生命周期内，id相同的对象必然是同一个对象)，因此，不要使用id()函数来比较对象的相等性，而应该使用`==`操作符。

3、不要用于跨不同解释器或会话的对象比较：由于id()返回的是内存地址，这个地址只在当前的Python解释器实例和会话中有效，如果你试图在不同的解释器实例或会话之间比较对象的id，那么这将没有意义，因为每个解释器实例都有自己独立的内存空间。

4、不要用于跨不同程序执行的对象比较：即使在同一解释器会话中，如果你在不同的程序执行(例如，通过多次启动Python脚本)中创建相同的对象，它们的id也可能不同，因为每次执行时内存布局都可能发生变化。

5、不要用于对象的持久化存储：id()函数返回的id是特定于当前内存布局的，因此不应该用于对象的持久化存储或跨不同执行环境的比较。如果你需要跨不同执行环境或持久化存储中唯一标识对象，应该使用其他机制，如UUID或数据库主键。

6、注意对象回收和内存重用：当对象被垃圾回收后，其id可能会被重新分配给新创建的对象，因此，不要假设已删除对象的id永远不会再次被使用。

7、谨慎用于性能优化：虽然id()函数有时可以用于性能分析和内存优化，但通常更好的做法是使用Python内置的分析工具(如`memory_profiler`)或专门的性能分析工具。直接依赖id()函数进行性能优化可能会使代码难以理解和维护。

        总之，id()函数主要用于调试和内部检查，而不是用于常规的编程逻辑或对象比较，在编写代码时，应该尽量避免依赖对象的id，而是使用更稳定、更可预测的比较和标识机制。

1、id函数：
1-1、Python：
  1. # 1.函数：id
  2. # 2.功能：用于获取对象的内存地址
  3. # 3.语法：id(object)
  4. # 4.参数：object，对象
  5. # 5.返回值：一个整数，返回对象的内存地址
  6. # 6.说明：
  7. # 6-1、返回一个整数，在此对象的生命周期中保证是唯一且恒定的
  8. # 6-2、两个生命期不重叠的对象可能具有相同的id()值
  9. # 7.示例：
  10. # 应用1：调试和内存管理
  11. # 理解对象身份
  12. # 创建两个相同的整数对象
  13. a = 10
  14. b = 10
  15. # 打印它们的id
  16. print(f"ID of a: {id(a)}")
  17. print(f"ID of b: {id(b)}")
  18. # 由于Python对小的整数进行了缓存，所以a和b可能指向同一个对象
  19. # 因此，它们的id可能相同
  20. # ID of a: 140715802354760
  21. # ID of b: 140715802354760
  22.  
  23. # 理解对象赋值
  24. # 创建一个列表对象
  25. list1 = [3, 5, 6]
  26. print(f"ID of list1: {id(list1)}")
  27. # 将list1赋值给list2
  28. list2 = list1
  29. print(f"ID of list2: {id(list2)}")
  30. # list1和list2指向同一个对象，所以它们的id相同
  31. # ID of list1: 2581367673280
  32. # ID of list2: 2581367673280
  33.  
  34. # 理解对象复制
  35. # 创建一个列表对象
  36. list1 = [3, 5, 6]
  37. print(f"ID of list1: {id(list1)}")
  38. # 使用切片操作复制list1
  39. list2 = list1[:]
  40. print(f"ID of list2: {id(list2)}")
  41. # list2是list1的一个新副本，所以它们有不同的id
  42. # ID of list1: 2333963122432
  43. # ID of list2: 2333963122560
  44.  
  45. # 理解对象在内存中的变化
  46. # 创建一个列表对象
  47. list1 = [3, 5, 6]
  48. print(f"ID of list1 before modification: {id(list1)}")
  49. # 修改列表
  50. list1.append(8)
  51. print(f"ID of list1 after modification: {id(list1)}")
  52. # 修改列表不会改变它的id，因为列表对象在内存中的位置没有改变
  53. # 只是列表的内容发生了变化
  54. # ID of list1 before modification: 2302696935872
  55. # ID of list1 after modification: 2302696935872
  56.  
  57. # 应用2：检查对象是否相同
  58. # 检查两个整数是否指向相同的对象
  59. a = 123
  60. b = 123
  61. # 使用id()函数检查它们的身份是否相同
  62. if id(a) == id(b):
  63.     print("a 和 b 指向相同的对象")
  64. else:
  65.     print("a 和 b 指向不同的对象")
  66. # 对于小的整数，Python通常会缓存它们，所以a和b可能指向相同的对象
  67. # 但是，这并非总是如此，所以这种方法并不完全可靠来检查整数值是否相等
  68. # a 和 b 指向相同的对象
  69.  
  70. # 检查两个列表是否指向相同的对象
  71. list1 = [1, 2, 3]
  72. list2 = list1  # list2是list1的引用，它们指向同一个对象
  73. list3 = [1, 2, 3]  # list3是一个新的列表对象，与list1内容相同但身份不同
  74. # 使用id()函数检查它们的身份
  75. if id(list1) == id(list2):
  76.     print("list1 和 list2 指向相同的对象")
  77. else:
  78.     print("list1 和 list2 指向不同的对象")
  79. if id(list1) == id(list3):
  80.     print("list1 和 list3 指向相同的对象")
  81. else:
  82.     print("list1 和 list3 指向不同的对象")
  83. # 在这个例子中，list1和list2指向同一个对象，而list1和list3指向不同的对象，尽管它们的内容相同
  84. # list1 和 list2 指向相同的对象
  85. # list1 和 list3 指向不同的对象
  86.  
  87. # 使用is运算符检查对象身份
  88. if list1 is list2:
  89.     print("list1 is list2(它们指向相同的对象)")
  90. else:
  91.     print("list1 is not list2")
  92. if list1 is list3:
  93.     print("list1 is list3(它们指向相同的对象)")
  94. else:
  95.     print("list1 is not list3")
  96.     # is运算符是检查对象身份更直接、更常见的方法
  97. # list1 is list2(它们指向相同的对象)
  98. # list1 is not list3
  99.  
  100. # 应用3：单例模式实现
  101. class Singleton:
  102.     _instance = None
  103.     def __new__(cls, *args, **kwargs):
  104.         if not cls._instance:
  105.             cls._instance = super(Singleton, cls).__new__(cls)
  106.         return cls._instance
  107.     def __init__(self, value):
  108.         self.value = value
  109. # 创建第一个实例
  110. singleton1 = Singleton(42)
  111. print(f"ID of singleton1: {id(singleton1)}")
  112. # 尝试创建第二个实例
  113. singleton2 = Singleton(24)
  114. print(f"ID of singleton2: {id(singleton2)}")
  115. # 检查两个实例是否相同
  116. if singleton1 is singleton2:
  117.     print("singleton1 and singleton2 are the same instance")
  118. else:
  119.     print("singleton1 and singleton2 are different instances")
  120. # 使用id()函数进一步验证
  121. if id(singleton1) == id(singleton2):
  122.     print("ID of singleton1 and singleton2 are the same")
  123. else:
  124.     print("ID of singleton1 and singleton2 are different")
  125. # ID of singleton1: 2438427103696
  126. # ID of singleton2: 2438427103696
  127. # singleton1 and singleton2 are the same instance
  128. # ID of singleton1 and singleton2 are the same
  129.  
  130. # 应用4：缓存和重用对象
  131. class ObjectCache:
  132.     def __init__(self):
  133.         self.cache = {}
  134.     def get_or_create(self, key, creator_function, *args, **kwargs):
  135.         """
  136.         根据key获取对象，如果不存在则使用creator_function创建并缓存。
  137.         """
  138.         if key not in self.cache:
  139.             # 调用creator_function创建新对象，并传入额外的参数
  140.             new_object = creator_function(*args, **kwargs)
  141.             # 将新对象添加到缓存中
  142.             self.cache[key] = new_object
  143.             # 返回缓存中的对象
  144.         return self.cache[key]
  145. # 示例：创建一个缓存对象
  146. cache = ObjectCache()
  147. # 假设我们有一个创建对象的函数
  148. def create_expensive_object(id):
  149.     print(f"Creating object with ID: {id}")
  150.     # 这里模拟创建一个昂贵的对象(比如从数据库加载或执行复杂计算)
  151.     return f"Object {id}"
  152. # 尝试获取一个ID为1的对象
  153. obj1 = cache.get_or_create('1', create_expensive_object, '1')
  154. print(f"Object with ID 1: {obj1}")
  155. # 再次尝试获取ID为1的对象，这次应该直接从缓存中获取
  156. obj2 = cache.get_or_create('1', create_expensive_object, '1')
  157. print(f"Object with ID 1 (cached): {obj2}")
  158. # 检查两个对象是否相同(实际上是缓存中的同一个对象)
  159. print(f"obj1 is obj2: {obj1 is obj2}")
  160. # 尝试获取一个ID为2的新对象
  161. obj3 = cache.get_or_create('2', create_expensive_object, '2')
  162. print(f"Object with ID 2: {obj3}")
  163. # Creating object with ID: 1
  164. # Object with ID 1: Object 1
  165. # Object with ID 1 (cached): Object 1
  166. # obj1 is obj2: True
  167. # Creating object with ID: 2
  168. # Object with ID 2: Object 2
1-2、VBA：
略，待后补。
2、推荐阅读：

1、Python-VBA函数之旅-hex()函数

Python算法之旅：Algorithm

Python函数之旅：Functions 

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

评论记录：

未查询到任何数据！