Python数据结构之集合

发布时间:2019-07-4 15:04--阅读:335--评论:0条

定义：

1.不同元素组成，元素不能重复

2.无序

3.集合中的元素必须是不可变类型

创建集合

1

s = {1,2,3,4,5,6,7,8}

1.定义可变集合

1

2

3

>>> set_test = set('hello')

>>> set_test

{'h', 'l', 'e', 'o'}

2.定义不可变集合

1

2

3

4

5

6

>>> set_test = set('hello')

>>> set_test

{'h', 'l', 'e', 'o'}　　# 由此可见集合中的元素不可重复，都是不同的

>>> n_set_test = frozenset(set_test)

>>> n_set_test

frozenset({'h', 'l', 'e', 'o'})

集合运算

 集合之间也可进行数学集合运算（例如：并集、交集等），可用相应的操作符或方法来实现。

子集

　　子集，为某个集合中一部分的集合，故亦称部分集合。

　　使用操作符 < 执行子集操作，同样地，也可使用方法 issubset() 完成。

1

2

3

4

5

6

7

8

9

>>> A = set('abcd')

>>> B = set('cdef')

>>> C = set("ab")

>>> C < A

True         # C 是 A 的子集

>>> C < B

False

>>> C.issubset(A)

True        

并集　

　　一组集合的并集是这些集合的所有元素构成的集合，而不包含其他元素。

　　使用操作符 | 执行并集操作，同样地，也可使用方法 union() 完成。

1

2

3

4

>>> A | B

{'c', 'b', 'f', 'd', 'e', 'a'}

>>> A.union(B)

{'c', 'b', 'f', 'd', 'e', 'a'}

交集

　　两个集合 A 和 B 的交集是含有所有既属于 A 又属于 B 的元素，而没有其他元素的集合。

　　使用 & 操作符执行交集操作，同样地，也可使用方法 intersection() 完成。

1

2

3

4

>>> A & B

{'c', 'd'}

>>> A.intersection(B)

{'c', 'd'}

差集

　　A 与 B 的差集是所有属于 A 且不属于 B 的元素构成的集合

　　使用操作符 - 执行差集操作，同样地，也可使用方法 difference() 完成。

1

2

3

4

>>> A - B

{'b', 'a'}

>>> A.difference(B)

{'b', 'a'}

对称差

　　两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合。

　　使用 ^ 操作符执行差集操作，同样地，也可使用方法 symmetric_difference() 完成。

1

2

3

4

>>> A ^ B

{'b', 'f', 'e', 'a'}

>>> A.symmetric_difference(B)

{'b', 'f', 'e', 'a'}

集合方法

1.add 向集合中添加元素

1

2

3

4

>>> s = {1, 2, 3, 4, 5, 6}

>>> s.add("s")

>>> s

{1, 2, 3, 4, 5, 6, 's'}

2.clear 清空集合

1

2

3

4

>>> s = {1, 2, 3, 4, 5, 6}

>>> s.clear()

>>> s

set()

3.copy 返回集合的浅拷贝

1

2

3

4

>>> s = {1, 2, 3, 4, 5, 6}

>>> new_s = s.copy()

>>> new_s

{1, 2, 3, 4, 5, 6}

4.pop 删除并返回任意的集合元素（如果集合为空，会引发 KeyError）

1

2

3

4

5

>>> s = {1, 2, 3, 4, 5, 6}

>>> s.pop()　　# pop删除时是无序的随机删除

1

>>> s

{2, 3, 4, 5, 6}

5.remove 删除集合中的一个元素（如果元素不存在，会引发 KeyError）

1

2

3

4

>>> s = {1, 2, 3, 4, 5, 6}

>>> s.remove(3)

>>> s

{1, 2, 4, 5, 6}

6.discard 删除集合中的一个元素（如果元素不存在，则不执行任何操作）

1

2

3

4

>>> s = {1, 2, 3, 4, 5, 6}

>>> s.discard("sb")

>>> s

{1, 2, 3, 4, 5, 6}

7.intersection 将两个集合的交集作为一个新集合返回

1

2

3

4

5

6

>>> s = {1, 2, 3, 4, 5, 6}

>>> s2 = {3, 4, 5, 6, 7, 8}

>>> s.intersection(s2)

{3, 4, 5, 6}

>>> s&s2　　# 可以达到相同的效果

{3, 4, 5, 6}

8.union 将集合的并集作为一个新集合返回

1

2

3

4

5

6

>>> s = {1, 2, 3, 4, 5, 6}

>>> s2 = {3, 4, 5, 6, 7, 8}

>>> print(s.union(s2))

{1, 2, 3, 4, 5, 6, 7, 8}

>>> print(s|s2)    # 用 | 可以达到相同效果

{1, 2, 3, 4, 5, 6, 7, 8}

9.difference 将两个或多个集合的差集作为一个新集合返回　

1

2

3

4

5

6

7

8

9

10

>>> s = {1, 2, 3, 4, 5, 6}

>>> s2 = {3, 4, 5, 6, 7, 8}

>>> print("差集:",s.difference(s2)) # 去除s和s2中相同元素，删除s2 保留s中剩余元素

差集: {1, 2}

>>> print("差集:",s2.difference(s))　　# 去除s和s2中相同元素，删除s2 保留s2中剩余元素<br>

差集: {8, 7}

>>> print("差集:",s - s2)    # 符号 - 可以达到相同结果

差集: {1, 2}

>>> print("差集:",s2 - s)    # 符号 - 可以达到相同结果

差集: {8, 7}

10.　symmetric_difference 将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分，其余保留)　

1

2

3

4

>>> s = {1, 2, 3, 4, 5, 6}

>>> s2 = {3, 4, 5, 6, 7, 8}

>>> s.symmetric_difference(s2)

{1, 2, 7, 8}

11.update 用自己和另一个的并集来更新这个集合 

1

2

3

4

5

6

7

>>> s = {'p', 'y'}

>>> s.update(['t', 'h', 'o', 'n'])    # 添加多个元素

>>> s

{'p', 't', 'o', 'y', 'h', 'n'}

>>> s.update(['H', 'e'], {'l', 'l', 'o'})    # 添加列表和集合

>>> s

{'p', 'H', 't', 'l', 'o', 'y', 'e', 'h', 'n'}

12.intersection_update()  用自己和另一个的交集来更新这个集合

1

2

3

4

5

>>> s = {'a', 'b', 'c', 'd', 'q'}

>>> s2 = {'c', 'd', 'e', 'f'}

>>> s.intersection_update(s2)   # 相当于s = s - s2

>>> s

{'c', 'd'}

13.isdisjoint() 　如果两个集合有一个空交集，返回 True

1

2

3

4

5

6

7

>>> s = {1, 2}

>>> s1 = {3, 4}

>>> s2 = {2, 3}

>>> s.isdisjoint(s1)   

True                               # s  和 s1 两个集合的交集为空返回 True

>>> s.isdisjoint(s2)

False                             # s  和 s2 两个集合的交集为 2 不是空 所有返回False

14.issubset()　如果另一个集合包含这个集合，返回 True

1

2

3

4

5

6

7

>>> s = {1, 2, 3}

>>> s1 = {1, 2, 3, 4}

>>> s2 = {2, 3}

>>> s.issubset(s1)

True                            # 因为 s1 集合 包含 s 集合

>>> s.issubset(s2)

False                           # s2 集合 不包含 s 集合

15.issuperset() 　如果这个集合包含另一个集合，返回 True

1

2

3

4

5

6

7

>>> s = {1, 2, 3}

>>> s1 = {1, 2, 3, 4}

>>> s2 = {2, 3}

>>> s.issuperset(s1)

False                                        # s 集合不包含 s1 集合

>>> s.issuperset(s2)

True                                         # s 集合包含 s2 集合                                     

16.difference_update() 从这个集合中删除另一个集合的所有元素

1

2

3

4

5

6

7

8

9

>>> s = {1, 2, 3}

>>> s1 = {1, 2, 3, 4}

>>> s2 = {2, 3}

>>> s.difference_update(s2)

>>> s

{1}# s2中的2,3   s集合中也有2,3  所以保留1

>>> s1.difference_update(s2)

>>> s1

{1, 4}

　　

17.symmetric_difference_update() 用自己和另一个的对称差来更新这个集合

1

2

3

4

5

6

7

8

9

10

11

12

>>> s = {1, 2, 3}

>>> s1 = {1, 2, 3, 4}

>>> s2 = {2, 3}

>>> s1.symmetric_difference_update(s)

>>> s1

{4}

>>> s1.symmetric_difference_update(s2)

>>> s1

{2, 3, 4}

>>> s.symmetric_difference_update(s2)

>>> s

{1}

集合内置方法

方法 描述
add() 为集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
difference() 返回多个集合的差集
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
discard() 删除集合中指定的元素
intersection() 返回集合的交集
intersection_update() 删除集合中的元素，该元素在指定的集合中不存在。
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset() 判断指定集合是否为该方法参数集合的子集。
issuperset() 判断该方法的参数集合是否为指定集合的子集
pop() 随机移除元素
remove() 移除指定元素
symmetric_difference() 返回两个集合中不重复的元素集合。
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union() 返回两个集合的并集
update() 给集合添加元素

集合与内置函数

下述内置函数通常作用于集合，来执行不同的任务。

函数 描述
all() 如果集合中的所有元素都是 True（或者集合为空），则返回 True。
any() 如果集合中的所有元素都是 True，则返回 True；如果集合为空，则返回 False。
enumerate() 返回一个枚举对象，其中包含了集合中所有元素的索引和值（配对）。
len() 返回集合的长度（元素个数）
max() 返回集合中的最大项
min() 返回集合中的最小项
sorted() 从集合中的元素返回新的排序列表（不排序集合本身）
sum() 返回集合的所有元素之和

微信公众号ID:feiutech

评论列表

共0条评论

我要评论

用户名：
邮箱：

本站概况

  • 本站共76篇文章
  • 文章阅读共36449次数
  • 博客创建日期：2019-07-03

  • 微信公众号ID:feiutech

    • 标签云

    分类文章统计

    本站推荐