Python-集合类型及操作

1. 集合类型定义

集合是多个元素的无序组合

• 集合类型与数学中的集合概念一致；
• 集合元素之间无序，每个元素唯一，不存在相同元素；
• 集合元素不可更改，不能是可变数据类型；（为什么？防止后加入的数据和已有的数据重复）；
• 集合用大括号{}表示，元素间用逗号分隔；
• 建立集合类型用{}或set()；
• 建立空集合类型，必须使用set()；

>>> A = {"python", 123, ("python", 123)} #使用{}建立集合
>>> print(A);
{123, 'python', ('python', 123)}
>>> B = set("pypy123"); #使用set建立集合
>>> print(B);
{'y', '3', 'p', '2', '1'}
>>> C = {"python", 123, "python", 123};
>>> print(C);
{123, 'python'}

2. 集合操作符

集合操作符

操作符及应用	描述
S | T	并，返回一个新集合，包括在集合S和T中所有的元素
S - T	差，返回一个新集合，包括在集合S但不在T中的元素
S & T	交，返回一个新集合，包括同时在集合S和T中的元素
S ^ T	补，返回一个新集合，包括集合S和T中的非相同元素
S <= T 或 S < T	返回True或False,判断S和T的子集关系
S >= T 或 S > T	返回True或False,判断S和T的包含关系
S |= T	并，更新集合S,包括在集合S和T中所有的元素
S -= T	差，更新集合S,包括在集合S但不在T中的元素
S &= T	交，更新集合S,包括同时在集合S和T中的元素
S ^= T	补，更新集合S,包括集合S和T中非相同的元素

A = {"p", "y", 123};
B = set("pypy123");

print("A与B的并集A|B={0}".format(A|B));
print("A与B的差集A-B={0}".format(A-B));
print("B与A的差集B-A={0}".format(B-A));
print("A与B的交集A&B={0}".format(A&B));
print("A与B的补集A^B={0}".format(A^B));
print("A与B是子集关系A<=B:{0}".format(A<=B));
print("A与B是包含关系A>=B:{0}".format(A>=B));

#运行结果
#A与B的并集A|B={'3', 'y', '2', '1', 'p', 123}
#A与B的差集A-B={123}
#B与A的差集B-A={'3', '1', '2'}
#A与B的交集A&B={'p', 'y'}
#A与B的补集A^B={'3', '2', '1', 123}
#A与B是子集关系A<=B:False
#A与B是包含关系A>=B:False

3. 集合处理方法

集合处理方法

操作函数或方法	描述
S.add(x)	如果x不在集合S中，将x增加到S
S.discard(x)	移除S中元素x,如果x不在集合S中，不报错
S.remove(x)	移除S中元素x,如果x不在集合S中，产生KeyError异常
S.clear()	移除S中所有元素
S.pop()	随机返回S的一个元素，更新S,若S为空产生KeyError异常
S.copy()	返回集合S的一个副本
len(S)	返回集合S的元素个数
x in S	判断S中元素x,x在集合S中，返回True,否则返回False
x not in S	判断S中元素x,x不在集合S中，返回True,否则返回False
set(x)	将其他类型变量x转变为集合类型

S = {"p", "y", 123};

#1.若x不在集合S中，将x增加到S
S.add("t");
S.add("p");
print(S);
#运行结果
#{'t', 123, 'p', 'y'}

#2.移除S中元素x,如果x不在集合S中，不报错
S.discard("t");
S.discard("0");
print(S);
#运行结果
#{'p', 123, 'y'}

#3.移除S中元素x,如果x不在集合S中，产生KeyError异常
try:
    S.remove("t");
except KeyError:
    print("产生KeyError异常");
#运行结果
#产生KeyError异常

#4.移除S中所有元素
S.clear();
print(S);
#运行结果
#set()

#5.随机返回S的一个元素，更新S,若S为空，产生KeyError异常
S = {"p", "y", 123};
try:
    while True:
        print(S.pop(), end="*");
except KeyError:
    print("\n产生KeyError异常");
print(S);
#运行结果
#y*123*p*
#产生KeyError异常
#set()

#6.返回集合S的一个副本
S = {"p", "y", 123};
A = S.copy();
print(A);
#运行结果
#{'y', 'p', 123}

#7.返回集合S的个数
a = len(S);
print(a);
#运行结果
#3

#8.判断S中元素x,x在集合S中，返回True,否则返回False
a = "y" in S;
b = 345 in S;
print("a={0}, b={1}".format(a, b));
#运行结果
a=True, b=False

#9.判断S中元素x,x不在集合S中，返回True,否则返回False
a = "y" not in S;
b = 345 not in S;
print("a={0}, b={1}".format(a, b));
#运行结果
a=False, b=True

#10.将其他类型变量x转变为集合类型
a = "Hello World";
S = set(a);
print(S);

#运行结果
#{'o', 'e', 'r', 'd', 'W', ' ', 'l', 'H'}

4. 集合类型应用场景

包含关系比较

a = {"p", "y"} >= {"p", "y", 123};
print(a);

#运行结果
#False

数据去重：集合类型所有元素无重复

ls = ["p", "p", "y", "y", 123];
S = set(ls);#利用了集合无重复元素的特点
print(S);
lt = list(S);#还可以将集合转换为列表
print(lt);

#运行结果
#{'p', 123, 'y'}
#['p', 123, 'y']