跳转至

8. 集合

集合 set

  • 集合是可变的容器
  • 集合内的数据对象都是唯一的
  • 集合是无序的存储结构,集合中的数据没有先后顺序
  • 集合内的元素必须是不可变对象
  • 集合是可迭代对象

创建空的集合

​ set()

创建非空集合的字面值表示

s = {1, 2, 3}

集合的构造函数

  • set() #创建一个空的集合(不能用{} 来创建集合)
  • set(iterable) 用可迭代对象来创建一个新的集合
# 示例:
        s = set()
        s = {2, 3, 5, 7}
        s = set('ABC')  # s = {'A', 'B', 'C'}
        s = set('ABCCBA')   # s = {'A', 'B', 'C'}
        s = set({1:'1', 2:'2', 5:'5'})  # s = {1, 2, 5}
        s = set('ABC', '123', True)
        s = {True, None, 'ABc', (1, 2, 3)}

集合的运算

  • 交集 &
  • 并集 |
  • 补集 -
  • 对称补集 ^
  • 子集 <
  • 超集 >
&
    用于生成两个集合的交集
       s1 = {1, 2, 3}
       s2 = {2, 3, 4}
       s1 & s2      #{2, 3}

|
    用于生成两个集合的交集
       s1 = {1, 2, 3}
       s2 = {2, 3, 4}
       s1 | s2      #{1, 2, 3, 4}


- 生成两个集合的补集
       s1 = {1, 2, 3}
       s2 = {2, 3, 4}
       s1 - s2  # 生成s1 但不属于 s2 的所有元素

^ 对称补集
        s1 = {1, 2, 3}
        s2 = {2, 3, 4}
        s1 ^ s2     # {1, 4}

< 判断一个集合是另一个集合的子集
> 判断一个集合是另一个集合的超集
    s1 = {1, 2, 3}
    s2 = {2, 3}
    s1 > s2     #True
    s2 < s1     #True

== != 相同/不同
    s1 = {1, 3, 2}
    s2 = {1, 2, 3}
    s1 == s2    #  True

能用于集合的函数

    len(s)  返回集合的长度
    max(s)  返回集合的最大值元素
    min(s)  返回集合的最小值元素
    sum(s)  返回集合中所有元素的和
    any(s)  真值测试,规则与列表相同
    all(s)  假值测试,规则与列表相同

集合是可迭代对象

可以用于for 语句中

练习

    经理有 : 曹操, 刘备, 孙权
    技术有 : 曹操, 孙权,张飞,关羽
    用集合求:
        1. 既是经理又是技术的有
        2. 是经理, 但不是技术的有
        3. 是技术,但不是经理的有
        4. 张飞是经理吗
        5. 身兼一职的人都有谁
        6. 经理和技术共有几人

集合推导式

    用可迭代对象创建集合的表达式
    语法:
        {表达式 for 变量  in 可迭代对象 [if 真值表达式]}
        [] 部分可省略
    示例
        numbers = [1, 2, 3, 4, 5, 6, 7, 8 ,9]
        s = {x ** 2 for x in numbers}
        s = set(i for i in range(10))

固定集合 frozenset

固定集合是不可改变的,无序的,含有唯一元素的集合

作用
    固定集合可以作为字典的键,也可以作为集合的值

固定集合的构造函数
    frozenset()     创建一个空的固定集合
    frozenset(iterable)     用可迭代对象创建一个新的固定集合
示例
    fz = frozenset()
    fz = frozenset('ABCACA')
    fz = frozenset([1, 2, 3, 4, 5])

固定集合的运算

    &   交集
    |   并集
    -   补集
    ^   对称补集
    in / not in
    > >= < <= == !=
    (以上运算等同于集合的运算)

固定集合的方法

​ 相当于集合的全部的方法去掉修改集合的方法