Python-VBA函数之旅-frozenset函数

目录

1、frozenset函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

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

        frozenset函数是Python中的一个内置函数，用于创建一个不可变的集合对象。这个函数特别适用于需要集合作为唯一标识符或作为另一个集合元素的场景，常见的应用场景有：

1、集合操作：你可以使用集合操作符(如交集、并集、差集、对称差集)来组合多个frozenset对象。

2、用作哈希表的键：frozenset()函数由于其不可变性，可以安全地用作哈希表的键。这在需要基于集合的内容进行查找或存储时非常有用。

3、作为函数的参数和返回值：当函数的参数或返回值需要是集合，并且你不希望这个集合在函数执行过程中被修改时，可以使用frozenset()函数，这有助于确保函数的输入和输出是固定的，从而增强代码的可预测性和健壮性。

4、数据序列化和反序列化：当需要将集合数据序列化为JSON或其他格式时，由于这些格式通常不支持可变类型，可以使用frozenset()函数作为集合的替代。序列化时，先将集合转换为frozenset，然后再进行序列化。反序列化时，再将frozenset转换回集合。

5、算法和数据结构：在算法实现中，特别是需要用到不可变集合来表示状态或唯一性标识的场合，frozenset()函数会很有用。例如，在解决某些图论问题时，可能需要表示一组顶点作为状态，而frozenset()函数可以用来表示这些不可变的顶点集合。

6、缓存和状态管理：当需要缓存某个状态或配置，并且这个状态或配置是由集合表示的，frozenset()函数可以作为不可变的键来存储和检索缓存。

7、文件内容去重：实现给一个文件内容去重后，再将去重后的数据写入一个新文件中。

        总之，frozenset()函数提供了一种创建不可变集合的方法，使得集合可以作为唯一标识符或作为另一个集合的元素。这种特性使得frozenset()函数在Python编程中具有一定的实用价值。

1、frozenset函数：
1-1、Python：
  1. # 1.函数：frozenset
  2. # 2.功能：根据传入的可迭代对象创建一个新的不可变集合，即冻结集合，一旦创建后就无法增加、删除和修改其中的任何元素
  3. # 3.语法：frozenset(iterable=set())
  4. # 4.参数：Python中的可迭代对象iterable包括但不限于以下类型：
  5. # # 4-1、序列类型：
  6. #         # list(列表)：有序的元素集合
  7. #         # tuple(元组)：不可变的有序的元素集合
  8. #         # str(字符串)：字符的有序集合
  9. #         # bytes(字节序列)：字节的有序集合
  10. #         # bytearray(可变字节序列)：可变的字节的有序集合
  11. #         # range(范围对象)：表示一个不可变的整数序列
  12. #         # memoryview(内存视图)：用于在不需要复制数据的情况下访问对象的内存
  13. # # 4-2、集合类型：
  14. #         # set(集合)：无序且不包含重复元素的集合
  15. #         # frozenset(冻结集合)：不可变的无序且不包含重复元素的集合
  16. # # 4-3、字典与字典视图：
  17. #         # dict(字典)：无序的键值对集合
  18. #         # dict的keys()、values()、items()方法返回的视图对象
  19. # # 4-4、文件对象：
  20. #         # 打开的文件对象也是可迭代的，可以通过迭代逐行读取文件内容
  21. # # 4-5、自定义可迭代对象：
  22. #         # 任何定义了__iter__()方法的对象都可以被视为可迭代对象。这个方法应该返回一个迭代器对象
  23. # # 4-6、生成器：
  24. #         # 生成器函数和生成器表达式创建的生成器对象也是可迭代的
  25. # # 4-7、其他内置类型：
  26. #         # 某些内置的数据类型或函数返回的对象也可能是可迭代的，比如map、filter、zip等函数返回的对象
  27. # 5.返回值：返回新的frozenset对象，若不提供任何参数，默认会生成空集合
  28. # 6.说明：
  29. # 6-1、不可变性：frozenset对象是不可变的，即创建后不能添加、删除或修改其中的元素，这使得它可以作为字典的键或其他需要不可变对象的场景中使用
  30. # 6-2、哈希性：由于frozenset是不可变的，它可以被哈希化并用作字典的键或集合的元素，这是因为哈希值是根据对象的内容计算得出的，而不是根据对象的内存地址
  31. # 6-3、集合操作：frozenset对象支持集合操作，例如并集、交集、差集等，可以使用交集运算符(&)、并集运算符(|)、差集运算符(-)等来执行这些操作
  32. # 6-4、可迭代性：frozenset对象是可迭代的，可以使用for循环遍历其中的元素
  33. # 6-5、内存效率：由于frozenset是不可变的，它在内存占用的空间相对较小，这对于需要存储大量数据的场景来说是优势
  34. # 7.示例：
  35. # 应用1：集合操作
  36. # 创建集合的集合
  37. set_of_sets = {
  38.     frozenset(['a', 'b']),
  39.     frozenset(['b', 'c']),
  40.     frozenset(['c', 'd'])
  41. }
  42. # 检查某个集合是否在set_of_sets中
  43. to_check = frozenset(['a', 'b'])
  44. if to_check in set_of_sets:
  45.     print("The set is present.")
  46. else:
  47.     print("The set is not present.")
  48. # The set is present.
  49.  
  50. # 创建两个frozenset
  51. set1 = frozenset([1, 2, 3])
  52. set2 = frozenset([2, 3, 4])
  53.  
  54. # 集合运算
  55. union = set1 | set2       # 并集
  56. intersection = set1 & set2 # 交集
  57. difference = set1 - set2  # 差集
  58. symmetric_difference = set1 ^ set2 # 对称差集
  59. print(union)
  60. print(intersection)
  61. print(difference)
  62. print(symmetric_difference)
  63. # frozenset({1, 2, 3, 4})
  64. # frozenset({2, 3})
  65. # frozenset({1})
  66. # frozenset({1, 4})
  67.  
  68. # 创建一个包含重复元素的列表
  69. lst = [3, 5, 6, 8, 10, 10, 11, 24]
  70. # 使用frozenset去除重复元素
  71. unique_elements = frozenset(lst)
  72. print(unique_elements)
  73. # frozenset({3, 5, 6, 8, 10, 11, 24})
  74.  
  75. # 比较两个frozenset是否相等
  76. set1 = frozenset([1, 2, 3])
  77. set2 = frozenset([3, 2, 1])
  78. print(set1 == set2)
  79. # True
  80.  
  81. # 使用frozenset作为集合的元素
  82. set_of_sets = {frozenset([1, 2]), frozenset([3, 4]), frozenset([5, 6])}
  83. print(set_of_sets)
  84. # {frozenset({3, 4}), frozenset({5, 6}), frozenset({1, 2})}
  85.  
  86. # 应用2：用作哈希表的键
  87. my_dict = {frozenset([1, 2, 3]): 'value1', frozenset([4, 5, 6]): 'value2'}
  88. print(my_dict[frozenset([1, 2, 3])])
  89. # value1
  90.  
  91. # 应用3：作为函数的参数和返回值
  92. def process_set(input_set):
  93.     # 对集合进行处理，不修改原集合
  94.     processed_set = frozenset(x * 2 for x in input_set)
  95.     return processed_set
  96. # 使用frozenset作为函数的参数和返回值
  97. input_data = {1, 2, 3}
  98. result = process_set(input_data)
  99. print(result)
  100. # frozenset({2, 4, 6})
  101.  
  102. # 应用4：数据序列化和反序列化
  103. import pickle
  104. # 创建一个 frozenset
  105. fs = frozenset([3, 5, 6, 8, 10, 11, 24])
  106. # 序列化 frozenset 到字节串
  107. serialized_fs = pickle.dumps(fs)
  108. # 从字节串反序列化回 frozenset
  109. deserialized_fs = pickle.loads(serialized_fs)
  110. print(deserialized_fs)
  111. # frozenset({3, 5, 6, 8, 10, 11, 24})
  112.  
  113. import json
  114. # 创建一个 frozenset
  115. fs = frozenset([3, 5, 6, 8, 10, 11, 24])
  116. # 将 frozenset 转换为列表，然后序列化
  117. serialized_fs = json.dumps(list(fs))
  118. # 从字符串反序列化回列表，然后转换为frozenset
  119. deserialized_fs = frozenset(json.loads(serialized_fs))
  120. print(deserialized_fs)
  121. # frozenset({3, 5, 6, 8, 10, 11, 24})
  122.  
  123. # 应用5：算法和数据结构
  124. # 一个简单的深度优先搜索(DFS)算法
  125. from collections import defaultdict, deque
  126. # 使用 frozenset 表示图中的边
  127. graph = {
  128.     'A': frozenset(['B', 'C']),
  129.     'B': frozenset(['A', 'D', 'E']),
  130.     'C': frozenset(['A', 'F']),
  131.     'D': frozenset(['B']),
  132.     'E': frozenset(['B', 'F']),
  133.     'F': frozenset(['C', 'E']),
  134. }
  135. # 深度优先搜索函数，检查从start到end是否存在路径
  136. def dfs_path_exists(graph, start, end, visited=None):
  137.     if visited is None:
  138.         visited = set()
  139.     # 如果已经访问过当前节点，或者当前节点就是目标节点，则返回
  140.     if start in visited or start == end:
  141.         return start == end
  142.     visited.add(start)
  143.     # 对与当前节点相连的每个未访问过的节点进行递归搜索
  144.     for neighbor in graph[start]:
  145.         if dfs_path_exists(graph, neighbor, end, visited):
  146.             return True
  147.     # 如果没有找到路径，则回溯并返回 False
  148.     visited.remove(start)
  149.     return False
  150. if __name__ == '__main__':
  151.     # 检查从'A'到'F'是否存在路径
  152.     print(dfs_path_exists(graph, 'A', 'F'))
  153.     # 检查从'A'到'G'是否存在路径(不存在)
  154.     print(dfs_path_exists(graph, 'A', 'G'))
  155. # True
  156. # False
  157.  
  158. # 应用6：缓存和状态管理
  159. class CacheAndStateManager:
  160.     def __init__(self):
  161.         # 使用字典来存储缓存数据，键是frozenset类型的状态
  162.         self.cache = {}
  163.     def set_state(self, state):
  164.         """设置当前状态，state 是一个可哈希的集合（最终转换为 frozenset）"""
  165.         self.current_state = frozenset(state)
  166.     def get_state(self):
  167.         """获取当前状态"""
  168.         return self.current_state
  169.     def cache_data(self, state, data):
  170.         """根据状态缓存数据"""
  171.         self.cache[state] = data
  172.     def get_cached_data(self, state):
  173.         """根据状态获取缓存的数据"""
  174.         return self.cache.get(state)
  175. if __name__ == '__main__':
  176.     cache_manager = CacheAndStateManager()
  177.     # 设置初始状态
  178.     initial_state = {'key1': 'value1', 'key2': 'value2'}
  179.     cache_manager.set_state(initial_state)
  180.     print("Initial State:", cache_manager.get_state())
  181.     # 根据当前状态缓存一些数据
  182.     data_to_cache = "Some important data"
  183.     cache_manager.cache_data(cache_manager.get_state(), data_to_cache)
  184.     # 更改状态
  185.     new_state = {'key1': 'value1', 'key3': 'value3'}
  186.     cache_manager.set_state(new_state)
  187.     print("New State:", cache_manager.get_state())
  188.     # 尝试获取基于新状态的缓存数据（应该返回None，因为新状态的数据没有被缓存）
  189.     print("Cached Data for New State:", cache_manager.get_cached_data(cache_manager.get_state()))
  190.     # 尝试获取基于初始状态的缓存数据
  191.     print("Cached Data for Initial State:", cache_manager.get_cached_data(frozenset(initial_state.items())))
  192. # Initial State: frozenset({'key2', 'key1'})
  193. # New State: frozenset({'key3', 'key1'})
  194. # Cached Data for New State: None
  195. # Cached Data for Initial State: None
  196.  
  197. # 应用7：文件内容去重
  198. with open("test.txt", "w", encoding="utf-8") as write:
  199.     with open("file.txt", "r", encoding="utf-8") as read:
  200.         data = read.readline()
  201.         data = frozenset(data)
  202.     write.writelines(data)
1-2、VBA：
略，待后补。
2、推荐阅读：

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

Python算法之旅：Algorithm

Python函数之旅：Functions 

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

评论记录：

未查询到任何数据！