【Python】set() 函数详解：集合运算、查找、去重 （附代码示例）

set 函数介绍

在Python中，集合（Set）是一种无序且元素唯一的数据结构。集合中的元素不能重复，即每个元素在集合中只能出现一次。

集合是一种高效的查找结构。

• Python 中的集合（set）通常是通过哈希表实现的。哈希表是一种数据结构，它使用哈希函数将键映射到存储桶（buckets）中，以便在常数时间复杂度内执行插入、删除和查找操作。
• 换言之，无论集合中有多少个元素，查找某个元素所需的时间都是固定的，与集合的大小无关。
• 因此在大数据量的情况下，集合仍然具有高效的性能。

  在《【数据分析面试】26.判断相同字符》中，答案使用了set()函数将字符串转换为集合。set()函数会创建一个新的集合对象，并且会去除字符串中重复的字符，因为集合中的元素是唯一的。然后通过len()函数获取集合的长度，如果集合的长度为1，说明字符串中的所有字符都相同，即集合中只包含一个元素，因此返回True，否则返回False。

  集合的其他常见用法包括：

  • 去除重复元素：和unique用法相似：df['列名'].unique() 和 set(df['列名])得到的结果相同。
  • 快速查找：由于集合的特性是每个元素都是唯一的，因此在集合中查找元素的速度非常快。
  • 集合运算：比如集合的交、并、差等。

    代码示例

    创建集合

    # 从列表创建集合
    my_list = [1, 2, 3, 3, 4]
    my_set = set(my_list)
    print(my_set)  # 输出：{1, 2, 3, 4}
    # 从字符串创建集合
    my_string = "hello"
    my_set = set(my_string)
    print(my_set)  # 输出：{'l', 'o', 'h', 'e'}
    # 从元组创建集合
    my_tuple = (1, 2, 3, 3, 4)
    my_set = set(my_tuple)
    print(my_set)  # 输出：{1, 2, 3, 4}
    

    求唯一值

    import pandas as pd
    import numpy as np
    # 创建水果列表
    fruits = ['苹果', '香蕉', '橙子']
    # 随机生成包含 20 行的 DataFrame
    df= pd.DataFrame({
        '水果': np.random.choice(fruits, 20),
        '数量': np.random.randint(1, 10, 20),  # 生成随机数量
        '价格': np.random.uniform(1.0, 10.0, 20)  # 生成随机价格
    })
    set(df['水果']) # 返回：{'橙子', '苹果', '香蕉'}
    df['水果'].unique() # 返回：array(['苹果', '橙子', '香蕉'], dtype=object)
    #如果使用print,则都返回：{'苹果', '香蕉', '橙子'}
    

    快速查找

    my_set = {1, 2, 3, 4, 5}
    print(3 in my_set)  # 输出: True
    

    集合的运算

    1. add (添加元素):

       s = {1, 2, 3}
       s.add(4)  # 添加元素4到集合s中
       

    2. clear (清空):

       s = {1, 2, 3}
       s.clear()  # 清空集合s中的所有元素
       

    3. copy (复制):

       s = {1, 2, 3}
       t = s.copy()  # 复制集合s到集合t中
       

    4. difference (差集):

       s1 = {1, 2, 3}
       s2 = {3, 4, 5}
       diff = s1.difference(s2)  # 返回s1中存在但s2中不存在的元素
       diff # 返回s1：{1,2}
       

    5. difference_update (差集更新):

       s1 = {1, 2, 3}
       s2 = {3, 4, 5}
       s1.difference_update(s2)  # 从s1中移除s2中存在的元素
       s1 # 返回：{1,2}
       

    6. discard (移除):

       s = {1, 2, 3}
       s.discard(2)  # 移除集合s中的元素2
       s # 返回：{1,3}
       

    7. intersection (交集):

       s1 = {1, 2, 3}
       s2 = {3, 4, 5}
       intersection = s1.intersection(s2)  # 返回同时存在于s1和s2中的元素
       intersection # 返回: {3}
       

    8. intersection_update (交集更新):

       s1 = {1, 2, 3}
       s2 = {3, 4, 5}
       s1.intersection_update(s2)  # 保留同时存在于s1和s2中的元素到s1中
       s1 # 返回: {3}
       

    9. isdisjoint (不相交):

       s1 = {1, 2, 3}
       s2 = {4, 5, 6}
       disjoint = s1.isdisjoint(s2)  # 如果s1和s2没有共同元素则返回True
       disjoint # 返回：True
       

    10. issubset (子集):

        s1 = {1, 2}
        s2 = {1, 2, 3, 4}
        subset = s1.issubset(s2)  # 如果s1是s2的子集则返回True
        subset # 返回：True
        

    11. issuperset (超集):

        s1 = {1, 2, 3, 4}
        s2 = {1, 2}
        superset = s1.issuperset(s2)  # 如果s1包含s2则返回True
        superset # 返回：True
        

    12. pop (弹出):

        s = {1, 2, 3}
        popped = s.pop()  # 弹出并返回集合s中的任意元素
        popped # 返回：1（示例中可能得到的任意元素）
        

    13. remove (移除):

        s = {1, 2, 3}
        s.remove(2)  # 从集合s中移除元素2，如果不存在则引发错误
        s # 返回：{1, 3}
        

    14. symmetric_difference (对称差集):

        s1 = {1, 2, 3}
        s2 = {3, 4, 5}
        sym_diff = s1.symmetric_difference(s2)  # 返回仅存在于一个集合中的元素
        sym_diff # 返回：{1, 2, 4, 5}
        

    15. symmetric_difference_update (对称差集更新):

        s1 = {1, 2, 3}
        s2 = {3, 4, 5}
        s1.symmetric_difference_update(s2)  # 更新s1为仅存在于一个集合中的元素
        s1 # 返回：{1, 2, 4, 5}
        

    16. union (并集):

        s1 = {1, 2, 3}
        s2 = {3, 4, 5}
        union_set = s1.union(s2)  # 返回s1和s2的所有元素的集合
        union_set # 返回：{1, 2, 3, 4, 5}
        

    17. update (更新):

        s1 = {1, 2, 3}
        s2 = {3, 4, 5}
        s1.update(s2)  # 将s2中的元素添加到s1中
        s1 # 返回：{1, 2, 3, 4, 5}