Hexo
0%

16、集合.md

Posted on In

一、概要

set是一个无序且不重复的元素集合。

集合对象是一组无序排数据，集合成员可以做字典中的键。集合支持用in和not in操作符检查成员，由len()内建函数得到集合的基数(大小)， 用 for 循环迭代集合的成员。但是因为集合本身是无序的，不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值。set和dict一样，只是没有value，相当于dict的key集合，由于dict的key是不重复的，且key是不可变对象因此可以作为可以做字典中的键

主要用来做关系测试和消除重复元素

二、特点

  1. 不重复
  2. 元素为不可变对象
  3. 无序

三、创建

  1. 语法格式一

    1
    s = {元素,元素,元素,元素}

  2. 语法格式二

    1
    s = set(seq=())

  3. 注意事项

    • 在创建空集合的时候只能使用s=set()，因为s={}创建的是空字典
    • 如果传入的参数有重复，会自动忽略
    • 必须是可以迭代的对象 例如: 序列,元组

  4. 举个栗子

    1
    2
    3
    4
    5
    6
    7
    8
    9
    s = {'k1', 'k2', 'k2', 1, 3.14}
    # 字符串对象转化成集合
    s = set('python')
    # 将列表转化成集合
    s = set(['y', 'b', 'o', 'o'])
    # 将字典转化成集合,注意只会包含键,不包含value
    s = set({"k1": 'v1', 'k2': 'v2'})
    # 将元组转化成集合
    s = set(('k1', 'k2', 'k2')})
    1
    2
    3
    4
    5
    6
    #使用set()创建集合是注意
    # s = set(1)  # 错误
    # s = set(True) # 错误
    ```
    TypeError: 'int' object is not iterable
    ```

四、关系测试

4.1、说明

union（并集），intersection（交集），difference（差集）和sysmmetric difference（对称差集）等数学运算

4.2、并集（|）

  1. 说明

    数学概念: 给定两个集合A，B，把他们所有的元素合并在一起组成的集合，叫做集合A与集合B的并集，记作A∪B，读作A并B。

    去重后所有元素放一起

  2. 语法格式

    1
    集合.union(集合)
    1
    集合 | 集合 | 集合...

  3. 举个栗子

    1
    2
    3
    4
    5
    6
    7
    s1 = {1, 2, 3, 4, 5}
    s2 = {4, 5, 6, 7, 8}
    print(s1.union(s2))

    s1 = {'a', 'b', 'c', 'd', 'python', 1}
    s2 = {1, 2, 'd', 'java'}
    print(s1.union(s2))

4.3、交集（&）

  1. 说明

    数学概念: 设A，B是两个集合，由所有属于集合A且属于集合B的元素所组成的集合，叫做集合A与集合B的交集

    两者都存在的

  2. 语法格式

    1
    集合.intersection(集合)
    1
    集合 & 集合 & 集合 & 集合...

  3. 举个栗子

    1
    2
    3
    4
    5
    6
    7
    s1 = {1, 2, 3, 4, 5}
    s2 = {4, 5, 6, 7, 8}
    print(s1.intersection(s2))

    s1 = {'a', 'b', 'c', 'd', 'python', 1}
    s2 = {1, 2, 'd', 'java'}
    print(s1.intersection(s2))

4.4、差集（-）

  1. 说明

    数学概念:以属于A而不属于B的元素为元素的集合成为A与B的差

    你有我没有

  2. 语法格式

    1
    集合.difference(集合)
    1
    集合 - 集合  - 集合 ...

  3. 举个栗子

    1
    2
    3
    4
    5
    6
    7
    8
    s1 = {1, 2, 3, 4, 5}
    s2 = {4, 5, 6, 7, 8}
    print(s1.difference(s2))
    # {1, 2, 3}
    s1 = {'a', 'b', 'c', 'd', 'python', 1}
    s2 = {1, 2, 'd', 'java'}
    print(s1.difference(s2))
    # {'b', 'python', 'c', 'a'}

4.5、对称差集（^）

  1. 说明

    数学概念：两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合

    集合1和集合2都互相都没有（去重后放到一起）

  2. 语法格式

    1
    集合.symmetric_difference(集合)
    1
    集合 ^ 集合

  3. 举个栗子

    1
    2
    3
    4
    5
    6
    7
    s1 = {1, 2, 3, 4, 5}
    s2 = {4, 5, 6, 7, 8}
    print(s1.symmetric_difference(s2))

    s1 = {'a', 'b', 'c', 'd', 'python', 1}
    s2 = {1, 2, 'd', 'java'}
    print(s1.symmetric_difference(s2))

4.6、子集（issubset）

  1. 说明

    数学概念：如果集合A的任意一个元素都是集合B的元素，那么集合A称为集合B的子集。

    集合1是不是集合2的子集

  2. 语法格式

    1
    集合1.issubset(集合2)

  3. 举个栗子

    1
    2
    3
    4
    5
    6
    7
    8
    s1 = {1, 2, 3, 4, 5, 6, 7, 8}
    s2 = {4, 5, 6, 7, 8}
    print(s2.issubset(s1))
    # True
    s1 = {1, 2, 3, 4, 5, 6, 7, 8}
    s2 = {4, 5, 6, 7, 8,9}
    print(s2.issubset(s1))
    # False

4.7、父集（issuperset）

  1. 说明

    集合1是不是集合2的父集

  2. 语法格式

    1
    集合1.issuperset(集合2)

  3. 举个栗子

    1
    2
    3
    s1 = {1, 2, 3, 4, 5, 6, 7, 8}
    s2 = {4, 5, 6, 7, 8}
    print(s1.issuperset(s2))

4.8、是否存在交集

  1. 说明

    是否存在交集

  2. 语法格式

    1
    集合1.isdisjoint(集合2)

  3. 举个栗子

    1
    2
    3
    4
    5
    6
    7
    8
    s1 = {1, 2, 3, 4, 5}
    s2 = {4, 5, 6, 7, 8}
    print(s1.isdisjoint(s2))
    # False
    s1 = {'a', 'b', 'c', 'python'}
    s2 = {1, 2, 'd', 'java'}
    print(s1.isdisjoint(s2))
    # True

五、其它方法

5.1、add

  1. 说明

    往set中添加一个元素只有set中不存在该元素时，才会加入该元素

  2. 语法格式

    1
    set.add(元素)

  3. 参数说明

    • 要添加的元素,必须是不可变的

  4. 返回值

    无

  5. 举个栗子

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    s = {(1, 2, 3), '元素1', 1, True}
    s.add(2)
    # {'元素1', 2, 1, (1, 2, 3)}
    s = {(1, 2, 3), '元素1', 1, True}
    s.add(1)
    # {'元素1', 1, (1, 2, 3)}

    #注意元素是不可变的所以list不能作为元素
    s.add([1, 2])
    ```
    TypeError: unhashable type: 'list'
    ```

5.2、update

  1. 说明

    把新的元素添加到set中，把已有元素从set中删除。

  2. 语法格式

    1
    set.update(s)

  3. 参数说明

    • 必须是可迭代的对象

    注意:传入的元素拆分，做为单个元素传入到集合中

  4. 返回

    无

  5. 举个栗子

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    s = set()

    # 将字符串中的每一个元素添加到集合中
    s.update('python')
    print(s)
    #讲列表中的每一个元素更新到集合中
    s.update([1, 2, 3, 4, 5])
    print(s)
    #把字典里的key更新到集合中
    s.update({1: 2, 'name': '小明'})
    print(s)
    #错误
    s.update(1)
    s.update(True)

5.3、pop

  1. 说明

    随机删除并返回set类型的集合中的一个不确定的元素，如果为空引发KeyError错误。

  2. 语法格式

    1
    element = s.pop()

  3. 参数说明：

    • 无

  4. 返回值

    被删除的元素

  5. 举个栗子

    1
    2
    s = set([2, 3, 4, 5])
    ele = s.pop()

5.4、remove

  1. 说明

    删除指定元素

  2. 语法格式

    1
    set.remove(ele)

  3. 参数说明

    • 要删除的元素

  4. 举个栗子

    1
    2
    3
    4
    s = {1, 'python', (1, 2, 3)}
    print(s)
    s.remove(1)
    print(s)

5.5、discard

  1. 说明

    如果存在则删除；如果没找到，则什么也不做

  2. 语法格式

    1
    discard(element)

  3. 参数说明

    • 表示要查找并删除的元素

  4. 返回值

    无

  5. 举个栗子

    1
    2
    3
    4
    set_list = set([1, 2, 3, 4, 5])
    set_list.discard(1)
    set_list.discard('python')
    print(set_list)

5.6、clear

  1. 说明

    清空s集合中的所有元素

  2. 语法格式

    1
    set.clear()

  3. 参数说明

    • 无

  4. 返回值

    无

  5. 举个栗子

    1
    2
    s = set([1, 2, 3, 4, 5])
    s.clear()

5.7、copy

  1. 说明

    复制集合

  2. 语法格式

    1
    set.copy()

  3. 参数说明

    • 无

  4. 返回值

    一个新的集合

  5. 举个栗子

    1
    2
    s = set('123456')
    new_s = s.copy()

5.8、集合的范围判断

  1. 说明

    集合可以使用大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）、不等于（!=）来判断某个集合是否完全包含于另一个集合，也可以使用子父集判断函数。 也可以使用成员运算

  2. 举个栗子

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    s1 = set([1, 2, 3, 4, 5])
    s2 = set([1, 2, 3, 4])
    s3 = set(['1', '8', '9', '5'])

    s1 > s2
    True
    s1 > s3
    False
    s1 >= s2
    True

    s2 < s1
    True
    s1 < s3
    False
    s3 < s1
    False

    s1 == s2
    False
    s2 == s3
    False
    s1 != s2
    True
    1 in s1

    True

    6 in s1

    False

    2 not in s1

    False

    6 not in s1

    True

六、集合推导

  1. 说明

    它们跟列表推导式也是类似的。 唯一的区别在于它使用大括号{}。

  2. 语法格式

    1
    {表达式 for item in iterrator if 条件表达式}

  3. 举个栗子

    1
    2
    3
    # 重复的数据将会被忽略
    num = {x**2 for x in [100, 100, 30,50,60,50]}
    print(num)