15、集合

2019-03-05  本文已影响43人  唯老

一、概要

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

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

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

二、特点

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

三、创建

  1. 语法格式一 
    s = {元素,元素,元素,元素}
  2. 语法格式二 
    s = set(seq=())
  3. 注意事项
    • 在创建空集合的时候只能使用s=set()，因为s={}创建的是空字典
    • 如果传入的参数有重复，会自动忽略
    • 必须是可以迭代的对象 例如: 序列,元组
  4. 举个栗子 
    s = {'k1', 'k2', 'k2', 1, 3.14}
# 字符串对象转化成集合
s = set('python')
# 将列表转化成集合
s = set(['y', 'b', 'o', 'o'])
# 将字典转化成集合,注意只会包含键,不包含value
s = set({"k1": 'v1', 'k2': 'v2'})
# 将元组转化成集合
s = {('k1', 'k2', 'k2')}

    #使用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. 语法格式 
    集合.union(集合)

    集合 | 集合 | 集合...
    ​
  3. 举个栗子 
    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. 语法格式 
    集合.intersection(集合)

    集合 & 集合 & 集合 & 集合...
  3. 举个栗子 
    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. 语法格式 
    集合.difference(集合)

    集合 - 集合  - 集合 ...
  3. 举个栗子 
    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. 语法格式 
    集合.symmetric_difference(集合)

    集合 ^ 集合
  3. 举个栗子 
    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.issubset(集合2)
  3. 举个栗子 
    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.issuperset(集合2)
  3. 举个栗子 
    s1 = {1, 2, 3, 4, 5, 6, 7, 8}
s2 = {4, 5, 6, 7, 8}
print(s1.issubset(s2))

4.8、是否存在交集

  1. 说明
    是否存在交集
  2. 语法格式 
    集合1.isdisjoint(集合2)
  3. 举个栗子 
    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. 语法格式 
    set.add(元素)
  3. 参数说明
    • 要添加的元素,必须是不可变的
  4. 返回值
    无
  5. 举个栗子 
    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. 语法格式 
    set.update(s)
  3. 参数说明
    • 必须是可迭代的对象
      注意:传入的元素拆分，做为单个元素传入到集合中
  4. 返回
    无
  5. 举个栗子 
    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. 语法格式 
    element = s.pop()
  3. 参数说明：
    • 无
  4. 返回值
    被删除的元素
  5. 举个栗子 
    s = set([2, 3, 4, 5])
ele = s.pop()

5.4、remove

  1. 说明
    删除指定元素
  2. 语法格式 
    set.remove(ele)
  3. 参数说明
    • 要删除的元素
  4. 举个栗子 
    s = {1, 'python', (1, 2, 3)}
print(s)
s.remove(1)
print(s)

5.5、discard

  1. 说明
    如果存在则删除；如果没找到，则什么也不做
  2. 语法格式 
    discard(element)
  3. 参数说明
    • 表示要查找并删除的元素
  4. 返回值
    无
  5. 举个栗子 
    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. 语法格式 
    set.clear()
  3. 参数说明
    • 无
  4. 返回值
    无
  5. 举个栗子 
    s = set([1, 2, 3, 4, 5])
s.clear()

5.7、copy

  1. 说明
    复制集合
  2. 语法格式 
    set.copy()
  3. 参数说明
    • 无
  4. 返回值
    一个新的集合
  5. 举个栗子 
    s = set('123456')
new_s = s.copy()

5.8、集合的范围判断

  1. 说明
    集合可以使用大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）、不等于（!=）来判断某个集合是否完全包含于另一个集合，也可以使用子父集判断函数。 也可以使用成员运算
  2. 举个栗子 
    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. 语法格式 
    {表达式 for item in iterrator if 条件表达式}
  3. 举个栗子 
    # 重复的数据将会被忽略
num = {x**2 for x in [100, 100, 30,50,60,50]}
print(num)
上一篇下一篇

猜你喜欢

热点阅读