python高阶（四）——集合学习

集合 set

1. 集合是可变的容器 集合内的数据对象是唯一的（不能重复多次的)
2. 集合是无序的存储结构，集合中的数据没有先后关系
3. 集合内的元素必须是不可变对象
4. 集合是可迭代的
5. 集合是相当于只有键没有值的字典(键则是集合的数据)

创建空的集合

s = set() # set() 创建一个空的集合

创建非空集合

s = {1, 2, 3} # 集合中的三个整数1,2,3

集合的构造函数 set

set() 创建空集合

set(iterable) 用可迭代对象创建一个新的集合对象

s = set("ABC")
s = set('ABCCBA')
s = set({1:"一", 2:'二', 5:'五'})
s = set([1, 3.14, False])
s = set((2,3,5,7))
# s = set([1, 2, [3.1, 3.2], 4]) # 错的[3.1, 3.2]是可变对象

 

集合的运算

交集，并集，补集，子集，超集

& ：生成两个集合的交集

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}
# 生成属于s1,但不属于s2的所有元素的集合
s3 = s1 - s2

 

^ ：生成两个集合的对称补集

s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 ^ s2 # s3 = {1, 4}
# 等同于 s3 = (s1 - s2) | (s2 -s1)

 

< ：判断一个集合是另一个集合的子集　　> ：判断一个集合是另一个集合的超集

s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True 判断子集
s1 > s2 # True 判断超集

 

== / != ：集合相同/不同

s1 = {1, 2, 3}
s2 = {2, 3, 1}
s1 == s2 # True
s1 != s2 # False # 集合的数据没有先后关系

 

in / not in 运算符

等同于字典，in 运算符用于集合中，当某个值存在于集合中，则为真，否则为假

not in 与 in 返回值相反

s = {1, 'Two', 3.14}
1 in s # True
2 in s # False
3.14 not in s # False
4 not in s # True

 

python3中可用于集合的函数

len(x) max(x), min(x), sum(x), any(x), all(x)

集合是可迭代对象

s = {1, 2, 3}
for x in s:
    print(x)

 

# 练习:
#   经理有: 曹操， 刘备， 周瑜
#   技术员有: 曹操， 周瑜， 张飞，赵云
#   用集合求:
#     1. 即是经理也是技术员的有谁?
#     2. 是经理，但不是技术员的有谁?
#     3. 是技术员，不是经理的都有谁?
#     4. 张飞是经理吗？
#     5. 身兼一职的人有谁?
#     6. 经理和技术员共有几个人?

managers = {'曹操', '刘备', '周瑜'}
techs = {'曹操', '周瑜', '张飞', '赵云'}
print("即是经理也是技术员的有", managers & techs)
print('是经理，但不是技术员的有:', managers - techs)
print('是技术员，不是经理的都有:', techs - managers)

# if '张飞' in managers:
#    print("张飞是经理")
# else:
#    print("张飞不是经理")
print("张飞", '是' if '张飞' in managers
              else '不是', '经理')
print("身兼一职的人有", managers ^ techs)
print('经理和技术员共有%d个人'
         % len(managers | techs))

 

思考：集合是可变对象，有方法能添加，删除集合的数据吗？（集合中的元素必须是不可变的，通过集合的方法不能改只能只能增加和删除）

集合的方法

 

对于不可变对象, 有时赋合赋值运算符不同于运算后再赋值（知道就行）

s1 = s1 | s2　　不等同于　　s1 |= s2
、 

s1 = {1,2,3}
s2 = {2,3,4}
s = s1

if True:  # if False
    s1 = s1 | s2  # 对于可变对象，不等同于 s1 += s2
    print(s)  # {1, 2, 3}
else:
    s1 |= s2
    print(s)  # {1, 2, 3, 4}

 

 

集合推导式

用可迭代对象来创建(生成)集合的表达式

语法：{表达式 for 变量 in 可迭代对象 [if 真值表达式]}　　[] 括号部分内容代表可省略

L = [2, 3, 5, 7, 3, 5, 7, 11]
s = {x**2 for x in L} # s={4,9,25,49,121}

 

集合推导式的嵌套规则与列表推导式相同

 

# 练习:
#   1. 模拟一个点名系统，已知全班学生名单，随机打印学生
#     的姓名进行点名，并得到此学生是否已到信息，
#     输入'y'代表已到，其它输入代表未到场
#     点名结束后打印未到者名单

names = ['tom', 'jerry', 'spike', 'tyke']

s = set(names)
L = []  # 代表未到的人的列表
for n in s:
    info = n + " 已到?(y):"
    r = input(info)
    if r != 'y':
        L.append(n)  # 把未到人的姓名加入到L列表中

print("未到人的名单如下:")
for n in L:
    print(n, end=' ')
print()

 

 问题：能用集合作为字典的键吗?——固定集合

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

作用：固定集合可以作为字典的键，也可以作为集合的值（元素)

创建空的固定集合

fs = frozenset()

创建非空的固定集合

fs = frozenset([2,3,5,7])

构造函数：frozenset()

frozenset(可迭代对象) # 同set函数一致,返回固定集合

固定集合的运算

& 交集　　| 并集　　- 补集　　^ 对称补集　　

> >= < <= == !=　　in / not in (以上运算规则等同于set中的用法)

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