【基础知识】Python入门：集合

集合

type({"one"})
<class 'set'>
{'FishC','Python'}
{'Python', 'FishC'}
{s for s in 'FishC'}
{'s', 'C', 'F', 'i', 'h'} #无序
set("FishC")
{'s', 'C', 'F', 'i', 'h'}

集合中所有元素都是无序的，所以不能使用下标索引的方式来对其进行访问。

可以使用in和notin来判断元素是否存在于集合中。

s = set("FishC")
s[0]
Traceback (most recent call last):File "<pyshell#113>", line 1, in <module>s[0]
TypeError: 'set' object is not subscriptable
'C' in s
True

可以通过迭代的方式来访问全体集合元素。

for each in s:print(each)s
C
F
i
h

集合中的所有元素都是唯一的，不能存在重复的元素。因此可以使用集合来对列表进行去重或者检测列表是否存在重复元素

set([1,1,2,3,5])
{1, 2, 3, 5}
s = [1,1,2,3,5]
len(s) == len(set(s)) #判断数量
False 

集合的三种创建方法

（1）使用花括号，并在其传入多个元素

（2）使用集合推导式

（3）使用类型构造器set()

集合的各种内置方法

下面列举的方法不会对集合的元素进行改动，所以既适用于可变集合set()，也适用于不可变集合frozenset()：

t = frozenset("FishC")
t
frozenset({'s', 'C', 'F', 'i', 'h'})

s.copy()：返回s集合的一个浅拷贝

t = s.copy()
t
[1, 1, 2, 3, 5]

s.isdisjoint(other)：如果s集合中没有与other 容器存在共同的元素，那么返回True，否则返回False

s = set("FishC")
s
{'s', 'C', 'F', 'i', 'h'}
s.isdisjoint(set("Python")) #h为共同元素
False
s.isdisjoint("Python")
False

s.issubset(other)：如果s集合是 other容器的子集(注1)，那么返回True，否则返回False
注1:对于两个集合A、B，如果集合A中任意一个元素都是集合B中的元素，我们就说这两个集合有包含关系，称集合A为集合B的子集(Subset)（ <= 真子集、 < 子集）

s.issubset("FishC.com.cn")
True

s.issuperset(other)：如果s集合是 other容器的超集（注2)，那么返回True，否则返回False
注2∶对于两个集合A、B，如果集合B中任意一个元素都是集合A中的元素，我们就说这两个集合有包含关系，称集合A为集合B的超集(Superset) （ >= 真超集、 > 超集）

s.issuperset("Fish")
True

s.union(*others)：返回一个新集合，其内容是s集合与others容器的并集（注3)
注3:对于两个集合A、B，把他们所有的元素合并在一起组成的集合，叫做集合A与集合B的并集(Union).（ | 管道符）

s.intersection(*others)：返回一个新集合，其内容是s集合与others容器的交集(注4)
注4∶对于两个集合A、B，由所有属于集合A且属于集合B的元素所组成的集合，叫做集合A与集合B的交集（Intersection) .（ & and符）

s.difference(*others)：返回一个新集合，其内容是存在于s集合中，但不存在于others容器中的元素，差集（注5)
注5:对于两个集合A、B，由所有属于集合A且不属于集合B的元素所组成的集合，叫做集合A与集合B的差集(Difference)。（ - 减号）

s = set("FishC")
s.union({1,2,3})
{1, 's', 2, 3, 'i', 'F', 'C', 'h'}
s.intersection("Fish")
{'i', 's', 'F', 'h'}
s.difference("Fish")
{'C'}s.union({1,2,3},"Python")
{1, 's', 2, 3, 'P', 'n', 't', 'C', 'F', 'o', 'y', 'i', 'h'}
s.intersection("Php","Python")
{'h'}
s.difference("Php","Python")
{'s', 'i', 'F', 'C'}

s.symmetric_difference(other)：返回一个新集合，其内容是排除掉s集合和other容器中共有的元素后，剩余的所有元素，即对称差集。（ ^ 脱字符）

s = set("FishC")
s.symmetric_difference("Python")
{'s', 'P', 'n', 't', 'C', 'o', 'i', 'y', 'F'}

s <= set("FishC") #检测子集
True
s < set("FishC") #检测真子集
False
s >= set("FishC") #检测超集
True
s > set("FishC") #检测真超集
False
s | {1,2,3} |set("Python") #并集
{1, 's', 2, 3, 'P', 'n', 't', 'C', 'F', 'o', 'y', 'i', 'h'}
s &set("Php") &set("Python")
{'h'}
s - set("Php") -set("Python")
{'F', 's', 'i', 'C'}
s ^set("Python")
{'s', 'P', 'n', 't', 'C', 'o', 'i', 'y', 'F'}

注6: others参数表示支持多个容器（参数类型可以是集合，也可以是序列) ; other参数则表示单个容器。若使用括号中的运算符，则需要符号两边都为集合类型的数据。

仅适用于set()的方法

update(*others)：使用others参数指定的值来更新集合，同交集

s = set("FishC")
s
{'h', 'i', 'C', 's', 'F'}
s.update([1,1], "23") #只放了1
s
{1, 'h', '2', '3', 'i', 'C', 's', 'F'}

intersection_update(*others)：使用交集的方式来更新集合

difference_update( *others)：使用差集的方式来更新集合

symmetric_difference_update(others)：使用对称差集的方式来更新集合
以上三个方法与上一点中的交集差集对称差集的区别在于，上一点是直接返回一个新的集合，而update是对原集合进行更新，在原集合上进行改动。

s.intersection_update("FishC")
s
{'h', 'i', 'C', 's', 'F'}

add(elem)：向集合中添加数据。当向集合中添加字符串时，使用update是迭代字符串中的每一个字符分别作为集合的元素，而add是将整个字符串作为一个元素插入。

s.add("45")
s
{'h', 'i', 'C', '45', 's', 'F'}

remove(elem)、discard(elem)：删除集合中指定的元素，但不同的是remove方法在找不到指定的元素时会抛出异常，而discard则会静默处理。

s.remove("啊啊")
Traceback (most recent call last):File "<pyshell#11>", line 1, in <module>s.remove("啊啊")
KeyError: '啊啊'
s.discard("啊啊")

pop()：随机从集合中集合中弹出一个元素

s.pop()
'h'
s.pop()
'i'
s.pop()
'C'

clear()：清空集合的所有元素

s
{'45', 's', 'F'}
s.clear()
s
set()

可哈希

想要正确的创建字典或者集合，那么则要求字典的键和集合元素是可哈希的

可哈希：如果一个对象是可哈希的，那么就要求他的哈希值必须在其整个生命周期中保持不变

不可变对象：可哈希。例如元组、字符串等

可变对象：不可哈希。例如列表等

hash(object)：获取对象的哈希值。
对整数求哈希值，其哈希值等于本身。
若两个对象的值是相等的，尽管是不同的对象，那么哈希值也是相等的。
只能对不可变的对象求哈希值，可变的对象不行。

hash(1)
1
hash(1.0) #值相等，hash值相等
1 
hash(1.001)
2305843009213441{"Python":520}
{'Python': 520}
{[1,2,3]:"FishC"} #含列表，不可哈希
Traceback (most recent call last):File "<pyshell#25>", line 1, in <module>{[1,2,3]:"FishC"}
TypeError: unhashable type: 'list'
{"Python","FishC",520,1314}
{520, 1314, 'FishC', 'Python'}
{"Python","FishC",520,1314,[1,2,3]} #含列表，不可哈希
Traceback (most recent call last):File "<pyshell#27>", line 1, in <module>{"Python","FishC",520,1314,[1,2,3]}
TypeError: unhashable type: 'list'x = {1,2,3}
y = {x,4,5} #集合x是可变的，可变的是不可哈希的
Traceback (most recent call last):File "<pyshell#29>", line 1, in <module>y = {x,4,5}
TypeError: unhashable type: 'set'x = frozenset(x)
y = {x,4,5}

【I】添加一行代码，提高10000倍以上的执行效率,《Python学习之奇技淫巧》,Python交流,鱼C论坛 - Powered by Discuz! (2023_4_10 16_10_09)

以空间换时间