Python 集合(set) 介绍

集合 set

集合是可变的容器

集合内的数据对象都是唯一的（不能重复多次的）

集合是无序的存储结构，集合中的数据没有先后关系

集合内的元素必须是不可变对象

集合是可迭代对象（可以用for等遍历）

集合是相当于只有键，没有值的字典（键则是集合的数据）

创建空集合：

set()

创建非空集合的字面值：

s = {1,2,3}

集合的构造函数：set

set()    # 创建一个空的集合对象（不能用{}来创建空集合）
set(iterable)     # 用可迭代对象创建一个新的集合对角

# 示例：
s = set（）
s = {1,2,3,4}
s = set（"ABC"）
s = set("ABCABC") # s = {"A","B","C"}
s = set([1,0,3.14,0.618])
s = {1,2,[3,4],5}  #报错，集合内不能放列表和字典
s = {1,2,{3,4},5}  #出错集合是可变对象

集合的运算：

交集&，并集|，补集-，对称补集^ , 子集< ,超集>

# & 运算符生成两个集合的交集(两个集合的共同部分)
s1 = {1,2,3}
s2 = {2,3,4}
s3 =  s1 & s2  #s3={2,3}    
                                                                                                                                                              
# | 生成两个集合的并集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 | s2   #s3 ={1,2,3,4}

# - 生成两个集合的补集
s1 = {1,2,3}
s2 = {2,3,4}   
s3 = s1 - s2   #生成属于s1，但不属于s2的所有元素的集合

# ^ 生成两个集合的对称补集
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 ^ s2   #s3 ={1,4}   

# > 判断一个集合是另一个集合的超集
# < 判断一个集合是另一个集合的子集
s1 = {1,2,3}
s2 = {2,3}
s1 > 2s   # True, s1为s2的超集 
s2 < s1   # True，s2为s1的子集

# == != 集合相同或不同
s1 = {1,2,3}
s2 = {2,3,1}
s1 == s2 #True  相同
s1 != s1 #False 

# >= <= 超集或相同，子集或相同

练习

# 1.经理有：曹操，刘备，孙权
#   技术员有：曹操，孙权，张飞， 关羽
#   用集合求：
#    1. 即是经理也是技术员的有谁？
#    2. 是经理，但不是技术人员的都有谁？
#    3. 是技术人员，但不是经理的人都有谁？
#    4. 张飞是经理吗？
#    5. 身兼一职的人都有谁？
#    6. 经理和技术人员共有几个人？

 
l = {"曹操","刘备","孙权"}
j = {"曹操","孙权","张飞","关羽"}
print("即经理也是技术员的有:",l&j,)
print("是经理，但不是技术人员的有",l-j)
print("是技术人员，但不是经理的有",j-l)
if "张飞" in l:
　　print("是经理")
else:
　　print("张飞，不是经理")
print("身兼一职的人：",l^j)
print("经理和技术人员共有",len(l|j))

集合的方法：

# 方法                    　　    　　# 意义
S.add(e)                　　　　  　　# 在集合中添加一个新的元素e；如果元素已经存在，则不添加
S.remove(e)              　　　　 　　# 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
S.discard(e)   　　       　　    　　# 从集合S中移除一个元素e,在元素e不存在时什么都不做;
S.clear()                 　　　　　　# 清空集合内的所有元素
S.copy()                 　　　　 　　# 将集合进行一次浅拷贝
S.pop()                  　　　　 　　# 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常
S.update(s2)             　　　　 　　# 等同于 S l= s2, 用 S与s2得到的全集更新变量S
S.difference(s2)         　　　　 　　# S - s2 补集运算，返回存在于在S中，但不在s2中的所有元素的集合
S.difference_update(s2)      　  　　# 等同于 S -= s2
S.intersection(s2)  　　    　　  　　# 等同于 S & s2
S.intersection_update(s2)　　　　 　　# 等同于S &= s2
S.isdisjoint(s2)　　　　　　　　　　　　# 如果S与s2交集为空返回True,非空则返回False
S.issubset(s2)　　　　　　　　　　  　　# 如果S与s2交集为非空返回True,空则返回False
S.issuperset(...) 　　 　　 　　 　　　# 如果S为s2的超集返回True,否则返回False
S.symmetric_difference(s2)　　　　　　# 返回对称补集, 等同于 S ^ s2
S.symmetric_difference_update(s2)   # 等同于 S ^= s2, 用 S 与 s2 的对称补集更新 S
S.union(s2)       　　　　　　　　　   # 生成 S 与 s2的全集, 等同于 S 
# 集合是可迭代对象

集合推导式

集合推导式是用可迭代对象创建集合的表达式

# 语法：
#    {表达式 for 变量 in 可迭代对象 [if 真值表达式]}
# 示例：
#    s = {x**2 for x in range(1,10)}
# 集合推导式可以嵌套
# 语法用列表推导式的嵌套相同

固定集合 frozenset（原封集合）

固定集合是不可变的，无序的，含有唯一元组的集合

# 作用：
#    固定集合可以作为字典的键，还可以作为集合的值（可以放固定键）
# 创建固定集合构造函数 frozenset
frozenset（）# 创建一个空的固定集合对象
frozenset（iterable）# 用可迭代对象创建一个新的固定集合对象

fz = frozenset（）
fz = frozenset (range(10))
fz = frozenset ([1,3,8,6,9])
d = {frozenset({1,2,3}):"集合1,2,3"}

固定集合的运算：

# &交集    | 并集    -补集    ^对称补集    < 子集    >超集
# <= >= == !=
# in / not in 
# (以上运算规则等用于set中的规则)

固定集合的方法：

相当于集合的全部方法去掉修改集合的方法

python基础总结

阶段总结

# 数据类型：
#    不可变类型：
#        数字：bool，int，float，complex（复数）
#        容器：str，tulpe，frozenset，bytes（备留）
#    可变类型
#        list，dict，set，bytearray（备留）
# 值：
#    None，False，True       

# 表达式：
# 1  1 +1 
# print("hello")
# max("ABC")+min("123")
# 条件表达式：x if x > y else y 

# 全部的推导式：
#    列表，字典，集合推导式

# 语句：
#    表达式语句：
#    print("hello")
#    """ABCD""""

# 赋值语句：
# a = 100
# a = b = c = 200
# x，y = 100,200
# L[1] = 200
# d["key"] = "键"

# del语句（删除）
# if 语句（如果）elif else:
# while语句(循环)
# for 语句（固定循环）
# break语句（结束循环）
# continue语句（重新执行循环）
# pass语句 

内建函数

# 容器相关
len（x），max（x），min（x），sum（x），any（x），all（x）

# 构造函数：
bool(x)    int(x)    float(x)    complex(r=0.0,i = 0.0) 
str(x)    list(x)    tuple(x)    dict(x)    set(x)    frozenset(x)

# 数值型 函数:
abs(x)    round(x)    pow(x,y,z=None) 幂运算

# 字符串相关
bin(x)    oct（x）   hex（x）    chr（x） 数字    ord（x） 编码

# 可迭代对象相关
range（start,stop,step）    reversed(x)    sorted(x,reverse=False)

# 输入输出相关：
input(x)    print(...)

# 其它：
type（x）    id（x）