Python学习第三十三天—集合（上）

Python 3.12.1 (tags/v3.12.1:2305ca5, Dec  7 2023, 22:03:25) [MSC v.1937 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
type({})
<class 'dict'>            （这是一个字典）
type({"one"})
<class 'set'>               （这是一个集合）
type({"one":1})
<class 'dict'>
与字典一样，集合最大的特性就是唯一性，集合中所有元素都应该是独一无二的，并且也是无序的！
创建一个集合，通常由三种方法：
{"FishC","Python"}
{'Python', 'FishC'}
{s for s in "FishC"}       （集合推导式，s 是临时变量，用于迭代字符串”FishC”中的每个字符）
{'s', 'h', 'F', 'i', 'C'}       （集合无序的特征）
{x for x in range(10)}        （如果用{x for x in range(10)}这样出来的集合就是有序的）
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
set("FishC")         （set()类型构造器，笔者理解成构造集合的，set(iterable)，传入的”FishC”被看作是可迭代对象进行迭代，而不是单个字符串的）
{'s', 'h', 'F', 'i', 'C'}
s=set("FishC")
s[0]                 （由于集合是无序的，所以不能使用下标索引的方式对它进行访问）
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    s[0]
TypeError: 'set' object is not subscriptable
"C" in s        （可以使用in或 not in判断某个元素是否存在于集合中）
True
"c" not in s
True
for each in s:          （访问集合中的元素，使用迭代的方式）
    print(each)

   
s
h
F
i
C                     （打印出来也是一个无序的状态）
唯一性
set([1,1,2,3,5])            （利用集合去重很方便）
{1, 2, 3, 5}               （去重）
s=[1,1,2,3,5]
len(s)==len(set(s))     （检测一个列表中是否存在相同的元素，没学集合前，通常是通过迭代来统计每个元素出现的次数，从而来判断是否是唯一的，）
False
t=s.copy()           （浅拷贝）
t
[1, 1, 2, 3, 5]
s=set("FishC")
s
{'s', 'h', 'F', 'i', 'C'}
s.isdisjoint(set("Python"))       （检测两个集合之间是否毫不相干）
False
s.isdisjoint(set("JAVA"))           （没有共同元素，这里set()把字符串”JAVA”变成一个集合类型，使用时，可省略set()）
True
s.isdisjoint("JAVA")             （省略set()函数，直接传入一个可迭代对象）
True
s.isdisjoint("Python")            （省略set()函数，直接传入一个可迭代对象）
False
六种“方法”
子集：对于两个集合A、B，如果集合A中任意一个元素都是集合B中的元素，我们就说这两个集合有包含关系，称集合A为集合B的子集。
s.issubset("FishC.com.cn")
True
超集：对于两个集合A、B，如果集合B中任意一个元素都是集合A中的元素，我们就说这两个集合有包含关系，称集合A为集合B的超集。
s.issuperset("Fish")
True
还有并集，交集，差集，以及对称差集：
并集：对于两个集合A、B，把他们所有的元素合并在一起组成的集合，叫做集合A和集合B的并集
s.union({1,2,3})
{1, 's', 2, 3, 'h', 'F', 'i', 'C'}
交集：对于两个集合A、B，由所有属于集合A且属于集合B的元素组成的集合，叫做集合A与集合B的交集。
s.intersection("Fish")
{'s', 'i', 'F', 'h'}
差集：对于两个集合A、B，由所有属于集合A且不属于集合B的元素所组成的集合，叫做集合A与集合B的差集。
s.difference("Fish")
{'C'}
上面的并集，交集，差集，三个都是支持多参数的
s.union({1,2,3},"Python")
{1, 2, 3, 'h', 'F', 'y', 's', 'P', 'n', 't', 'o', 'i', 'C'}
s.intersection("Php","Python")
{'h'}
s.difference("Php","Python")
{'s', 'F', 'i', 'C'}
对称差集（这个不能多参数）
对于两个集合A、B，先排除集合A与集合B的所有共同元素，由剩余的元素组成的集合，叫做集合A与集合B的对称差集。
s.symmetric_difference("Python")
{'s', 'P', 'n', 't', 'F', 'o', 'i', 'y', 'C'}
六种“运算符”：
上面这六种常见的操作，Python也提供了相应的运算符可以直接进行计算的
s<=set("FishC")        （检测子集的）
True
s<set("FishC")           （检测真子集）
False
s<set("FishC.com.cn")
True
s > set("FishC")          （检测真超集）
False
s >= set("FishC")          （检测超集）
True
s | {1,2,3}| set("PYthon")          （并集，用管道符隔开，在键盘上那个竖线|）
{1, 's', 2, 3, 'h', 'Y', 'P', 'n', 't', 'F', 'o', 'i', 'C'}
s & set("Php") & set("Python")       （交集，用&隔开）
{'h'}
s - set("Php") - set("Python")         （差集，用减号“-”隔开
{'s', 'F', 'i', 'C'}
s ^ set("Python")                   （对称差集，用“^”隔开）
{'F', 'y', 's', 'P', 'n', 't', 'o', 'i', 'C'}

这里需要注意的一点是：使用运算符的话，符合两边都必须是集合类型的数据才行，不然的话，就会报错，“方法”是可以使用任何可迭代对象，但是我们要使用运算符的话，就不能这么做了，比如：
s <= "FishC"
Traceback (most recent call last):
  File "<pyshell#46>", line 1, in <module>
    s <= "FishC"
TypeError: '<=' not supported between instances of 'set' and 'str' (报错原因：一个集合和一个字符串作比较是不同类型，不支持进行这样这么一个对比)