集合 set
集合是可变的容器集合内部的数据都是唯一的（不能重复多次的）
集合是无序的存储结构，集合中的数据没有先后顺序关系
集合内的元素必须是不可变对象
集合是可迭代对象
集合是相当于只有键没有值的字典（键则是集合的数据）
创建空集合：
set()创建非空集合
s={1, 2, 3, 4}集合的构造函数 set
set() 创建一个空的集合对象(不能用{}来创建空集合)set(iterable) 用可迭代对象创建一个新的集合
示例：
s = set() # 空集合
s = {3, 5, 7, 9}
s = set('abc') # s = {'a', 'b', 'c'}
s = set('hello') # s = {'h', 'e', 'l', 'o'}
s = set({1: '1', 2: '2', 5: '5'}) # s = {1, 2, 5}
s = set(range(1:10:3)) # s = {1, 4, 7}
s = set(['abc', '123', True]) # s = {'abc', '123',True}
s = set(('abc', '123', True)) # s = {'abc', '123',True}集合的运算：
运算符：
& | - ^ < <= > >= == != in not in
交集(&), 并集(|), 补集, 子集, 超集
& 生成两个集合的交集(共有的部分)
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 & s2 #{2, 3}| 生成两个集合的并集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 | s2 # {1, 2, 3, 4}- 生成两个集合的补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} # 生成属于 s1 但不属于 s2 的所有元素的集合^ 生成两个集合的对称补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 ^ s2 #{1, 4} > 判断一个集合是另一个集合的超集
< 判断一个集合是另一个集合的子集
{1, 2, 3} > {1, 2} #True
{2, 3, 1} > {3,2} #True
{2, 3, 4} < {1, 2, 3, 4} #True
== / != 集合相同和不同
{1, 2, 3} == {3, 2, 1,} #True
{1, 2, 3} != {2, 3, 4,} #Truein / not in 运算符
in 等同于字典的in，用于集合中当某个值存在于集合中返回True，否则返回Falsenot in 与 in 返回值相反
集合的in / not in 运算符的速度快于序列
能用于集合的函数
len(x)
max(x)
min(x)
sum(x)
any(x)
all(x)
#! /usr/bin/python3
'''
经理有：曹操，刘备，周瑜
技术员有：曹操，周瑜，张飞，赵云
用集合求：
1、既是经理又是技术员的有谁？
2、是经理但不是技术员的有谁？
3、是技术员，但不是经理的都有谁你？
4、张飞是经理吗？
5、身兼一职的人都有谁？
6、经理和技术员共有几人？
'''
jl = {'曹操', '刘备', '周瑜'}
jsy = {'曹操', '周瑜', '张飞', '赵云'}
print('既是经理又是技术员的是', jl & jsy)
print('是经理不是技术员的是', jl - jsy)
print('是技术员，但不是经理的都有', jsy - jl)
print('张飞','是' if '张飞' in jl else '不是','经理',sep='')
print('身兼一职的人为', jl ^ jsy)
print('经理和技术员共有%d人' % len(jl | jsy))python3 集合中的常用方法
| 方法 | 意义 |
|---|---|
| S.add(e) | 在集合中添加一个新的元素e；如果元素已经存在，则不添加 |
| S.remove(e) | 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误 |
| S.discard(e) | 从集合S中移除一个元素e; |
| S.clear() | 清空集合内的所有元素 |
| S.copy() | 将集合进行一次浅拷贝 |
| S.pop() | 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常 |
| S.update(s2) | 用 S与s2得到的全集更新变量S |
| 以下内容可以用运算符操作代替 | |
| S.difference(s2) | 用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合 |
| S.difference_update(s2) | 等同于 S = S - s2 |
| S.intersection(s2) | 等同于S & s2 |
| S.intersection_update(s2) | 等同于S = 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 |
| S.union(s2) | 生成 S 与 s2的全集 |
集合推导式
集合推导式使用可迭代对象生成集合的一种方式语法：
{表达式 for 变量 in 可迭代对象[if 真值表达式]}
注：[] 内的内容可以省略
示例：
>>> numbers=(1, 2, 3, 2, 2, 3, 3, 4, 5)
>>> s = {x for x in numbers} # 去除重复的元素
>>> s
{1, 2, 3, 4, 5}固定集合 frozenset
固定集合是不可变的，无序的，含有不重复元素的集合作用：
固定集合可以作为字典的键，还可以作为集合的值
创建空的固定集合
fs = frozenset()创建非空的固定集合：
frozenset(iterable) 用可迭代对象创建新的固定集合示例：
>>> fz = frozenset([2, 3, 5, 7])
>>> fz
frozenset({2, 3, 5, 7})固定集合的方法：
相当于集合的全部方法（去掉修改集合的方法）
| 方法 | 意义 |
|---|---|
| S.copy() | 将集合进行一次浅拷贝 |
| 以下内容可以用运算符操作代替 | |
| S.difference(s2) | 用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合 |
| S.intersection(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.union(s2) | 生成 S 与 s2的全集 |
列表、字典、集合对象的优缺点：
1、都为可变
2、列表的尾部插入速度比较快，查中间插入和头插数据速度慢
3、列表有序
4、字典添加，删除，修改速度快于列表
5、集合的添加，删除快于列表，且不能存储重复数据
练习：#! /usr/bin/python3
'''
1、输入一段字符串打印所有输入过的字符，但重复的只打印一次
（不要求打印的顺序与输入顺序是否一致）
输入：abcdabcaba
'''
s=input('请输入字符串：')
for i in set(s):
print(i,end=' ')
else:
print()
l=[]
for i in s:
if i not in l:
l.append(i)
for i in l:
print(i,end=' ')
#! /usr/bin/python3
'''
2、输入一段字符串，打印这个字符串中出现过的字符及出现过的次数：
如：
输入：abcdabcaba
打印：
a：4次
b：3次
c：2次
d: 1次
注：不要求打印顺序
'''
# 方法一
s=input('请输入字符串：')
set=set(s)
for i in set:
print('%s:%d次'%(i,s.count(i)))
#方法二
s=input('请输入字符串：')
d={}
for i in s:
#先判断字典d例有没有c对应的字符
if i in d:
#如果处在于字典中，经次数做加一操作
d[i]+=1
#否则把c作为键加入到字典中
else:
d[i]=1
print(d)
for k in d:
print('%s:%d次'%(k,d[k]))版权声明：本文为zhaoweipo原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。