集合python_Python之集合详解

定义&＃xff1a;

1.不同元素组成

2.无序

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

创建集合

s &＃61; {1,2,3,4,5,6,7,8}

1.定义可变集合

>>> set_test &＃61; set(&＃39;hello&＃39;)

>>> set_test

{&＃39;h&＃39;, &＃39;l&＃39;, &＃39;e&＃39;, &＃39;o&＃39;}

2.定义不可变集合

>>> set_test &＃61; set(&＃39;hello&＃39;)

>>> set_test

{&＃39;h&＃39;, &＃39;l&＃39;, &＃39;e&＃39;, &＃39;o&＃39;}　　# 由此可见集合中的元素不可重复&＃xff0c;都是不同的

>>> n_set_test &＃61; frozenset(set_test)

>>> n_set_test

frozenset({&＃39;h&＃39;, &＃39;l&＃39;, &＃39;e&＃39;, &＃39;o&＃39;})

集合运算

集合之间也可进行数学集合运算&＃xff08;例如&＃xff1a;并集、交集等&＃xff09;&＃xff0c;可用相应的操作符或方法来实现。

子集

子集&＃xff0c;为某个集合中一部分的集合&＃xff0c;故亦称部分集合。

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

>>> A &＃61; set(&＃39;abcd&＃39;)

>>> B &＃61; set(&＃39;cdef&＃39;)

>>> C &＃61; set("ab")

>>> C

True # C 是 A 的子集

>>> C

False

>>> C.issubset(A)

True

并集

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

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

>>> A | B

{&＃39;c&＃39;, &＃39;b&＃39;, &＃39;f&＃39;, &＃39;d&＃39;, &＃39;e&＃39;, &＃39;a&＃39;}

>>> A.union(B)

{&＃39;c&＃39;, &＃39;b&＃39;, &＃39;f&＃39;, &＃39;d&＃39;, &＃39;e&＃39;, &＃39;a&＃39;}

交集

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

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

>>> A & B

{&＃39;c&＃39;, &＃39;d&＃39;}

>>> A.intersection(B)

{&＃39;c&＃39;, &＃39;d&＃39;}

差集

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

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

>>> A - B

{&＃39;b&＃39;, &＃39;a&＃39;}

>>> A.difference(B)

{&＃39;b&＃39;, &＃39;a&＃39;}

对称差

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

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

>>> A ^ B

{&＃39;b&＃39;, &＃39;f&＃39;, &＃39;e&＃39;, &＃39;a&＃39;}

>>> A.symmetric_difference(B)

{&＃39;b&＃39;, &＃39;f&＃39;, &＃39;e&＃39;, &＃39;a&＃39;}

集合方法

1.add 向集合中添加元素

>>> s &＃61; {1, 2, 3, 4, 5, 6}

>>> s.add("s")

>>> s

{1, 2, 3, 4, 5, 6, &＃39;s&＃39;}

2.clear 清空集合

>>> s &＃61; {1, 2, 3, 4, 5, 6}

>>> s.clear()

>>> s

set()

3.copy 返回集合的浅拷贝

>>> s &＃61; {1, 2, 3, 4, 5, 6}

>>> new_s &＃61; s.copy()

>>> new_s

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

4.pop 删除并返回任意的集合元素&＃xff08;如果集合为空&＃xff0c;会引发 KeyError&＃xff09;

>>> s &＃61; {1, 2, 3, 4, 5, 6}

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

1

>>> s

{2, 3, 4, 5, 6}

5.remove 删除集合中的一个元素&＃xff08;如果元素不存在&＃xff0c;会引发 KeyError&＃xff09;

>>> s &＃61; {1, 2, 3, 4, 5, 6}

>>> s.remove(3)

>>> s

{1, 2, 4, 5, 6}

6.discard 删除集合中的一个元素&＃xff08;如果元素不存在&＃xff0c;则不执行任何操作&＃xff09;

>>> s &＃61; {1, 2, 3, 4, 5, 6}

>>> s.discard("sb")

>>> s

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

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

>>> s &＃61; {1, 2, 3, 4, 5, 6}

>>> s2 &＃61; {3, 4, 5, 6, 7, 8}

>>> s.intersection(s2)

{3, 4, 5, 6}

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

{3, 4, 5, 6}

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

>>> s &＃61; {1, 2, 3, 4, 5, 6}

>>> s2 &＃61; {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 将两个或多个集合的差集作为一个新集合返回

>>> s &＃61; {1, 2, 3, 4, 5, 6}

>>> s2 &＃61; {3, 4, 5, 6, 7, 8}

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

差集: {1, 2}

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

差集: {8, 7}

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

差集: {1, 2}

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

差集: {8, 7}

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

>>> s &＃61; {1, 2, 3, 4, 5, 6}

>>> s2 &＃61; {3, 4, 5, 6, 7, 8}

>>> s.symmetric_difference(s2)

{1, 2, 7, 8}

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

>>> s &＃61; {&＃39;p&＃39;, &＃39;y&＃39;}

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

>>> s

{&＃39;p&＃39;, &＃39;t&＃39;, &＃39;o&＃39;, &＃39;y&＃39;, &＃39;h&＃39;, &＃39;n&＃39;}

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

>>> s

{&＃39;p&＃39;, &＃39;H&＃39;, &＃39;t&＃39;, &＃39;l&＃39;, &＃39;o&＃39;, &＃39;y&＃39;, &＃39;e&＃39;, &＃39;h&＃39;, &＃39;n&＃39;}

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

>>> s &＃61; {&＃39;a&＃39;, &＃39;b&＃39;, &＃39;c&＃39;, &＃39;d&＃39;, &＃39;q&＃39;}

>>> s2 &＃61; {&＃39;c&＃39;, &＃39;d&＃39;, &＃39;e&＃39;, &＃39;f&＃39;}

>>> s.intersection_update(s2) # 相当于s &＃61; s - s2

>>> s

{&＃39;c&＃39;, &＃39;d&＃39;}

13.isdisjoint() 　如果两个集合有一个空交集&＃xff0c;返回 True

>>> s &＃61; {1, 2}

>>> s1 &＃61; {3, 4}

>>> s2 &＃61; {2, 3}

>>> s.isdisjoint(s1)

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

>>> s.isdisjoint(s2)

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

14.issubset()　如果另一个集合包含这个集合&＃xff0c;返回 True

>>> s &＃61; {1, 2, 3}

>>> s1 &＃61; {1, 2, 3, 4}

>>> s2 &＃61; {2, 3}

>>> s.issubset(s1)

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

>>> s.issubset(s2)

False # s2 集合 不包含 s 集合

15.issuperset() 　如果这个集合包含另一个集合&＃xff0c;返回 True

>>> s &＃61; {1, 2, 3}

>>> s1 &＃61; {1, 2, 3, 4}

>>> s2 &＃61; {2, 3}

>>> s.issuperset(s1)

False # s 集合不包含 s1 集合

>>> s.issuperset(s2)

True # s 集合包含 s2 集合

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

>>> s &＃61; {1, 2, 3}

>>> s1 &＃61; {1, 2, 3, 4}

>>> s2 &＃61; {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() 用自己和另一个的对称差来更新这个集合

>>> s &＃61; {1, 2, 3}

>>> s1 &＃61; {1, 2, 3, 4}

>>> s2 &＃61; {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}

集合与内置函数

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

函数

描述

all()

如果集合中的所有元素都是 True&＃xff08;或者集合为空&＃xff09;&＃xff0c;则返回 True。

any()

如果集合中的所有元素都是 True&＃xff0c;则返回 True&＃xff1b;如果集合为空&＃xff0c;则返回 False。

enumerate()

返回一个枚举对象&＃xff0c;其中包含了集合中所有元素的索引和值&＃xff08;配对&＃xff09;。

len()

返回集合的长度&＃xff08;元素个数&＃xff09;

max()

返回集合中的最大项

min()

返回集合中的最小项

sorted()

从集合中的元素返回新的排序列表&＃xff08;不排序集合本身&＃xff09;

sum()

返回集合的所有元素之和