8_python笔记-元组-字典-集合

博客cpen_web

知识点1 容器类型 - 列表 回顾

知识点2 练习

有一个列表[‘python’, ‘Java’, ‘C’ ]
·向列表中追加一个元素：‘我是追加’
·删除第一个元素和最后一个元素
·判断”Cali”是否在列表里
·知道列表元素的总数
·插入一个子列表[‘liu’，‘cali’，123,456]到父列表的第2个元素位置

示例

lst = ['python', 'Java', 'C']
# 追加
lst.append("我是追加")
# 删除
del lst[0]
del lst[-1]
# 判断
if "Cali" in lst:
    print('"Cali"在列表里')
else:
    print('"Cali"不在列表里')
# 元素总数
print(f"元素总数：{len(lst)}")
# 插入子列表
lst.insert(1,['liu','cali',123,456])

知识点3 元组（tuple）

什么是元组
·元组是处理一组有序项目的数据结构
·元组和字符串一样是不可变的 , 即你不能修改元组
·元组可以包含任何类型的对象：字符串、数字甚至其他列表
·适应场景：性别选择，数据库的查询结果
·Example: 表示一个购物清单
·goods= (‘牛奶’、‘运动鞋’、‘咖啡’、‘手机’、‘羊肉’、‘葡萄’、‘桔子’)

示例

>>> a = ()
>>> type(a)
<class 'tuple'>

>>> a = (1)			#（注：括号还可以代表集合）
>>> type(a)
<class 'int'>

元组中只有一个元素的时候，需要在元素后面加个，区分这个括号是表示结合还是表示元组

>>> a = (1,)			#（注：元组中只有1个元素时，需要加逗号(,)表示元组）
>>> type(a)
<class 'tuple'>

知识点4

>>> a = tuple()		（注：定义空元组）
>>> type(a)
<class 'tuple'>
>>> a
()

知识点5 元组基本操作

·索引
·切片
·统计
·查下标
·遍历
·成员关系

知识点6 元组基本操作 - 索引

索引
·通过下标访问列表中的元素，下标从0开始计数，可取出一个元素
·正索引、负索引
·注意：下标不能越界（IndexError: list index out of range）

示例：下标不能越界，越界会报错

>>> a = ("a",1,1.2,True,print)
>>> a[5]
	Traceback (most recent call last):
  	File "<stdin>", line 1, in <module>
	IndexError: tuple index out of range

示例：索引

>>> a = ("a",1,1.2,True,print)
>>> a[4]
<built-in function print>
>>> a[3]
True

知识点7 元组基本操作 - 切片

切片
·切片是通过下标访问元组中的元素，切片可以取出一个子元组
·格式：sample[start🔚step]
·起止区间：[ start, end )
·step : 默认=> 1
·start: 默认=> step为正时，start为0；step为负时, start为-1
·end : 默认=> step为正时，end为列表结尾；step为负时, end为列表开始
·注意：三个值都为选填项
·正切片
·负切片
·起始位置有误时，切出来会是空(不会报错)
·切片对象(slice函数)
slice函数的用途：生成一个slice对象，相当于可以给要切的内容取个名字。

示例：切片

>>> a = ("a",1,1.2,True,print)
>>> a[1:3]
(1, 1.2)

知识点8 元组基本操作 - 不可变性

示例：不可变性

>>> a
('a', 1, 1.2, True, <built-in function print>)
>>> a[0] = 1					#（注：报错）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

>>> tu1 = (1,2)
>>> tu2 = (3,4)
>>> tu3 = tu1 + tu2
>>> tu3
(1, 2, 3, 4)

知识点9 元组包含列表时 列表可以改变

元组里面包含列表，列表可以改变
只要列表的内存地址没变，对于元组来说 没有变化

示例

>>> a = ()
>>> b = [1,2,3]			#（注：b 列表）
>>> a = (1,2,3)			#（注：a 元组）
>>> a = (1,2,3,b)			#（注：元组里包含列表）
>>> a
(1, 2, 3, [1, 2, 3])
>>> a[3][0]				#（注：元组第4个元素，该元素下第1个子元素）
1						#（注：[1, 2, 3]）
>>> a = (1,2,3)
>>> b = ["a","b","c"]
>>> a = (1,2,3,b)
>>> a
(1, 2, 3, ['a', 'b', 'c'])
>>> a[3][0]
'a'
>>> a[3][0] = "x"			#（注：元组里的 列表 发生替换  元组本身不变）
>>> a
(1, 2, 3, ['x', 'b', 'c'])

知识点10 元组基本操作 - 统计

统计

示例：统计

>>> a = ('a','b','c')
>>> print(len(a))
3

知识点11 元组基本操作 - 遍历元组

遍历元组

示例：遍历元组

>>> a = [1,2,3]
>>> for i in enumerate(a):
...     print(i)
... 
(0, 1)		#（注：返回值 是 元组）
(1, 2)
(2, 3)

>>> for i,j in enumerate(a):
...     print(f"{i}---{j}")		#（注：用两个参数 来接收 返回值）
... 
0---1
1---2
2---3

知识点12 元组基本操作 - 成员关系

成员关系： in , not in

示例

>>> a = ("a","b","c")
>>> "a" in a
True
>>> "d" not in a
True

知识点13 列表与元组的异同

相同点

·序列的两个主要特点是索引操作符和切片操作符
·索引操作符让我们可以从序列中抓取一个特定项目。
·切片操作符让我们能够获取序列的一个切片，即一部分序列。
不同点
·list : 可变对象
·tuple: 不可变对象，不能增加修改删除
·tuple中嵌套list时，list是可修改的

列表与元组的异同

相同点：
1、都是一组有序项目数据结构
2、都可以包含任意类型数据对象
不同点：
1、列表是可变数据类型
2、元组是不可变数据类型。元组一旦被定义，就不能做修改
3、元组中包含列表，列表中的值是可以被修改的

知识点14 列表与元组 的 相互转换

list和tuple的相互转换

示例

>>> a = (1,2,3)
>>> b = list(a)		#（注：元组转列表）
>>> b
[1, 2, 3]
>>> c = tuple(b)		#（注：列表转元组）
>>> c
(1, 2, 3)

字符串转元组

>>> a = tuple('abc')	#（注：字符串转元组）
>>> a
('a', 'b', 'c')

练习15 用户检测小工具

用户检测小工具
·欢迎语：”欢迎使用用户检测系统“
·定义一个用户列表，包含用户名密码：[(‘root’, ‘123456’), (‘admin’, ‘admin’),]
·键盘输入用户名、密码
·判断并验证用户密码，并给予相应提醒

示例

print("欢迎使用用户检测系统")
lst = [('root', '123456'), ('admin', 'admin')]
username = input("请输入用户名：")
passwd = input("请输入密码：")
if (username, passwd) in lst:		#（注：* ）
    print("登录成功！")
else:
    print("登录失败！")

知识点16 字典 dict

（注：一一对应的关系 用字典保存）

什么是字典( dict )

·字典是Python中一个键值映射的数据结构 （注：{key:value}）
·字典是无序的 （注：不能通过切片去获取）
·字典是可变对象
·key必须是唯一的, 天生去重
·example:
singer = { key1:value , key2:value }
singer = {“李圣杰”: ‘痴心绝对’, ‘张韶涵’: ‘阿刁’, ‘汪峰’:‘普通迪斯高’}

知识点17 字典的定义

字典的定义
·字典通过花括号中用键/值对用冒号分割，而各个对 用逗号分割
·定义空字典

示例

# 方法1：
>>> a = {}		#（注：定义空字典）
# 方法2：
>>> b = dict()	#（注：定义空字典，工厂函数）
>>> type(a)
<class 'dict'>
>>> type(b)
<class 'dict'>

>>> c = [('root','123456'),('admin','admin')]
>>> d = dict(c)		#（注：列表转换成字典） （注：工厂函数）
>>> d
{'root': '123456', 'admin': 'admin'}

>>> e = [1,2,3]
>>> e
[1, 2, 3]
>>> dict(e)			#（注：注：转换的对象要有 键值映射 的格式）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot convert dictionary update sequence element #0 to a sequence

知识点18 字典是无序的

Python3.6之后,字典的存储做了优化
[root@localhost ~]# python3

>>> a = {'a':1, 'b':2, 'c':3}                                                                                                
>>> a
{'a': 1, 'b': 2, 'c': 3}
>>> 

（注：python3.6后 做了小优化。但还是无序的）
[root@localhost ~]# python2

>>> a = {'a':1, 'b':2, 'c':3}
>>> a
{'a': 1, 'c': 3, 'b': 2}

知识点19 字典的定义

字典的key必须是可hash对象 （注：不可变数据类型）
python中所有字符串、数字、元组、布尔值、None都是可hash对象
字典的value可以是任何值

可hash对象一般指不可变数据类型

>>> a = {True:2}
>>> a
{True: 2}
>>> a = {True:2,"ab":2}
>>> a = {True:2,"ab":2,3:4}
>>> a
{3: 4, True: 2, 'ab': 2}
>>> a = {True:2,"ab":2,3:4,[1,2]:5}	#（注：列表不是可hash对象，不能作为key）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

总结

字典、列表不能作为key
函数也可以作为key

>>> a = {True:2,"ab":2,3:4,(3,4):6,print:4}

重复定义key，只会取最后一次定义的数值

>>> b = {"a":1,"b":2,"a":3}
>>> b
{'a': 3, 'b': 2}

知识点20 字典基本操作

查看
新增
删除
遍历
统计长度
成员关系

知识点21 字典基本操作 - 取值

取值
用法1：dicts[key] => 当key不存在时，会报错

• 用法2：dict.get(key,default) => 当key不存在时，返回default值

示例

>>> a = {"a":4,"b":2}
>>> a['a']=3			#（注：修改key=”a”的 value 值）
>>> a
{'a': 3, 'b': 2}
>>> a['c']=4			#（注：增加键值对）
>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a['c']			#（注：取值）
4
>>> a['d']			#（注：key不存在，报错）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'd'

推荐：
用法2 dict.get(key,default)
获取key的值，获取不到就返回默认default的值
容错率高
推荐使用get
获取到d 把d的值输出
获取不到d的值 输出默认值

示例

>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a.get('d')		#（注：不报错）
>>> c = a.get('d')
>>> print(c)
None					#（注：默认值没有设置）

（注：获取到d 把d的值输出
获取不到d的值 输出默认值）

>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> c = a.get('d',0)
>>> c
0					#（注：返回默认值）
>>> c = a.get('a',0)
>>> c
3					#（注：获取到a，输出a的值）

知识点22 字典基本操作 - 增加/修改

增加/修改
用法1：dicts[key] = value
·当key不存在时，表示增加一个键值对
·当key存在时， 表示修改对应的value值
示例如下：

示例：修改

>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a['a'] = 5
>>> a
{'a': 5, 'b': 2, 'c': 4}

示例：新增

>>> a['d'] = False
>>> a
{'a': 5, 'b': 2, 'c': 4, 'd': False}

知识点23 字典基本操作 - 删除

删除
·用法1：dicts.pop(key)
·用法2：dicts.popitem()
示例如下：

示例：dicts.pop(key)

>>> a = {'a':5,'b':2,'c':4,'d':False}
>>> a.pop('a')		（注：删除 key=‘a’ 的元素）
5					（注：pop有返回值）
>>> c = a.pop('b')		（注：获取返回值）
>>> c
2
>>> a
{'c': 4, 'd': False}

示例：dicts.popitem()

·python3里面删除的是最后一个

>>> a = {"x":1,"y":2,"z":3}
>>> a.popitem()
('z', 3)
>>> a.popitem()
('y', 2)
>>> a.popitem()
('x', 1)			

（注：python3.6后做了优化，python3输入的是什么样子，存放在内存里面就什么样子，但还是无序的）
（注：python3里面删除的是最后一个）
字典 不属于有序集合，不能使用索引切片

示例：python2 dicts.popitem()

>>> a = {"x":1,"y":2,"z":3,"p":4,"s":2,"o":1}
>>> a
{'o': 1, 'p': 4, 's': 2, 'y': 2, 'x': 1, 'z': 3}
>>> a.popitem()     #（注：python2类似于随机删除）
('o', 1)
>>> a.popitem()
('p', 4)
>>> a.popitem()
('s', 2)
>>> a.popitem()
('y', 2)
>>> a.popitem()
('x', 1)
>>> a.popitem()
('z', 3)

知识点24 字典基本操作 - 合并字典

合并字典
用法1：dict1.update(dict2) => 将dict2合并到dict1
用法2：dict(dict1, **dict2) => 将dict1与dict2合并生成一个新字典

示例：dict1.update(dict2)

>>> a = {"x":1,"y":3}
>>> b = {"q":2,"w":3}
>>> a.update(b)	#（注：a自带的属性）
>>> a
{'x': 1, 'y': 3, 'q': 2, 'w': 3}
>>> b
{'q': 2, 'w': 3}

示例：dict(dict1, **dict2)

>>> a = {"x":1,"y":3}
>>> b = {"q":2,"w":3}
>>> dict(a,**b)	#（注：工厂函数，返回一个字典  a和b的合并）
{'x': 1, 'y': 3, 'q': 2, 'w': 3}
>>> a	#（注：a本身没有改变）
{'x': 1, 'y': 3}
>>> dict()
{}
>>> c = dict(a,**b)
>>> c
{'x': 1, 'y': 3, 'q': 2, 'w': 3}

知识点24.2 **a

>>> a = {"x":1,"y":3}
>>> d = {3:'a',4:'b'}
>>> dict(a,**d)	#（注：key为 字符串和数字 混合  会报错）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings
>>> a.update(d)	#（注：key为 字符串和数字 混合  不会报错）
>>> a
{'x': 1, 'y': 3, 3: 'a', 4: 'b'}

解释：
因为用dict去定义，相当于生成1个新字典

d = {3:'a',4:'b'}
dict(a,**d)
dict(a,3='a',4='b')

**d的含义：
**d ==> 3=‘a’,4=‘b’
标识符不能数字开头

示例

>>> dict(a,str1 = 2)
{'x': 1, 'y': 3, 3: 'a', 4: 'b', 'str1': 2}

同样的：
元组的定义不符合标识符的定义

>>> e = {(1,2):"元组"}
>>> dict(a,**e)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

知识点25 **a 的使用

**a 的使用

>>> a = {"name":"wen","age":18}
>>> print("my name is {name}, my age is {age}".format(name='wen',age=18))
my name is wen, my age is 18

>>> print("my name is {name}, my age is {age}".format(name=a["name"],age=a["age"]))
my name is wen, my age is 18

>>> print("my name is {name}, my age is {age}".format(**a))
my name is wen, my age is 18

总结

**a作为一个参数传进去
**a ==> name=”wen”,age=18
Python里面的 unpack操作 （解包操作）
解包操作 字典—{“a”:1,“b”：2}——> a=1，b=2 一般作为形参

示例

def dict_test(x,y):                 # 传x, y两个参数
    print(f"x is {x}, y is {y}")

a = {"x":"xxxxx","y":"yyyyyyy"}
dict_test(x="123",y="456")	# x is 123, y is 456
dict_test(x = a['x'],y = a['y'])	# x is xxxxx, y is yyyyyyy
dict_test(**a)      # ** 解包字典	# x is xxxxx, y is yyyyyyy

dict_test(1,2)	# x is 1, y is 2

b = [3,4]
dict_test(1,2)	# x is 1, y is 2
dict_test(*b)       # * 解包列表	# x is 3, y is 4
dict_test(3,4)	# x is 3, y is 4

c = ('a','b')
dict_test(*c)        # 解包元组	# x is a, y is b

x is 123, y is 456
x is xxxxx, y is yyyyyyy
x is xxxxx, y is yyyyyyy
x is 1, y is 2
x is 1, y is 2
x is 3, y is 4
x is 3, y is 4
x is a, y is b

知识点26 字典基本操作 - 成员关系

成员关系
用法：
item in dicts
item not in dicts
默认的成员关系 对比的是key值
想对比value值 用.values()去获取

示例

>>> a = {"x":1,"y":2,"z":3}
>>> a
{'x': 1, 'y': 2, 'z': 3}
>>> 'x' in a		#（注：in  默认 对比的是key值）
True
>>> 2 in a
False
>>> 2 in a.values()		#（注：a.values()对比的是value值）
True

知识点27 字典基本操作 - 遍历字典

遍历字典
默认遍历的是 key

示例

>>> a
{'x': 1, 'y': 2, 'z': 3}

示例：遍历key值

# 示例：遍历key值
>>> for i in a:
...     print(i)
... 
x              #（注：遍历key值）
y
z

>>> a.keys()
dict_keys(['x', 'y', 'z'])

>>> a.values()
dict_values([1, 2, 3])

示例：遍历value值

>>> for i in a.values():
...     print(i)
... 
1               #（注：遍历value值）
2
3

既想获得key 也想获得value
3种方式
items返回的是元组

方式1

>>> for i in a.items():
...     print(i)
... 
('x', 1)
('y', 2)
('z', 3)

方式2

>>> for i,j in a.items():	#（注：2个参数获取返回值key,value）
...     print(f"key is {i}, value is {j}")
... 
key is x, value is 1
key is y, value is 2
key is z, value is 3

方式3

>>> for i in a.items():
...     print(f"key is {i[0]}, value is {i[1]}")	#（注：索引获取参数）
... 
key is x, value is 1
key is y, value is 2
key is z, value is 3

练习28 字典练习

字典练习
company={ ‘BOSS’:‘唐僧’,‘CTO’:‘悟空’,‘CFO’: ‘八戒’, ‘搬砖’:‘沙僧’, ‘苦力’:‘白龙马’ }
·打印CTO信息
·打印BOSS信息
·打印company中所有人物及角色，结果示例：CTO是悟空
·判断悟空和白骨精(接收用户输入)是否在company中

示例

company = {'BOSS':'唐僧','CTO':'悟空','CFO':'八戒','搬砖':'沙僧','苦力':'白龙马'}
# 1、2
print(company.get('CTO'))
print(company.get('BOSS'))
# 3
for i in company.items():
    print(f"{i[0]}是{i[1]}")

# 4
character = input("请输入人物：")
if character in company.values():
    print(f"{character}在company中")
else:
    print(f"{character}不在company中")

练习29 用户检测

用户检测(无限次)
·欢迎语：”欢迎使用用户检测系统“
·定义一个用户表，包含用户名密码：
·{‘root’:‘123456’, ‘admin’:‘admin’}
·键盘输入用户名、密码
·判断并验证用户密码，并给予相应提醒（验证成功/验证失败）
·当用户输入的值为‘quit’的时候，退出查找

示例

print("欢迎使用用户检测系统")
user_table = {'root': '123456', 'admin': 'admin'}
while True:
    username = input("请输入用户名：")
    passwd = input("请输入密码：")
    if username in user_table:
        if passwd == user_table[username]:
            print("登录成功")
            break
        else:
            print("账号错误，请重新输入！")
    exit = input("输入exit退出：")
    if exit == "exit":
        print("退出查找！")
        break

知识点30 集合( set )

什么是集合( set )

·集合是一个无序的，不重复的数据组合
·集合是一个只含有key的字典

集合的作用

·去重：把一个列表变成集合，就自动去重了
·关系测试：测试两组数据之前的交集、差集、并集等关系
·example:
singer = {“李圣杰”, ‘张韶涵’, ‘汪峰’}

知识点31 集合的定义

集合的定义
·集合通过花括号中，而各个元素用逗号分割
·定义集合
·集合元素必须是可hash对象，跟字典一样
·set和dict的唯一区别仅在于没有存储对应的value

示例：定义空集合（2种方式）

>>> a = {1,2,3}	#（注：第1种方式）
>>> type(a)
<class 'set'>
>>> a = set()	#（注：第2种方式）
>>> a
set()
>>> type(a)
<class 'set'>

知识点32 集合转换

>>> a = set("abc")	#（注：str转换成set）
>>> a
{'c', 'b', 'a'}
>>> a = set([1,2,3])	#（注：list转换成set）
>>> a
{1, 2, 3}
>>> a = set((1,2,3,4))	#（注：tuple转换成set）
>>> a
{1, 2, 3, 4}
>>> a = set({'x':1,'y':2})	#（注：dict转换成set）
>>> a
{'y', 'x'}	#（注：返回key值）

可迭代的对象，都可以转换成 集合
可以用for循环遍历的，都是可迭代的
list tuple set 都是可迭代的
集合元素必须是可hash对象，跟字典一样
set和dict的唯一区别仅在于没有存储对应的value
集合元素必须是可hash对象，跟字典一样（注：可hash 不可变数据类型）

>>> a = {"x",[1]}	#（注：；列表 可变数据类型 报错）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

知识点33 去重（set）

去重：把一个列表变成集合，就自动去重了

示例

>>> a = [1,2,3,1,2,2]
>>> set(a)		#（注：列表的去重）
{1, 2, 3}
>>> list(set(a))		#（注：集合转换成列表）
[1, 2, 3]
>>> list(1)		#（注：list()参数不能是数字）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

>>> list({"x":1,"y":2})	#（注：取 key值）
['x', 'y']

list()函数可以传的参数有： （注：list() 工厂函数）
集合、字典、列表、字符串、元组（可迭代对象[for循环遍历]）
数字不可以传（数字不能迭代）
set()、tuple()同理
字典dict()有key，value的对应关系。需要有这样的关系，才能转化
String 也属于 容器类型 ，可迭代
str()是工厂函数，万物接可str

>>> str(True)
'True'
>>> str({"x":1})
"{'x': 1}"

现在学的容器类型 是可迭代对象

知识点34 dict() 转换成字典

字典dict()有key，value的对应关系。需要有这样的关系，才能转化

示例

>>> a = [("a",1),("b",2)]	#（注：列表里面放元组）
>>> dict(a)	#（注：转换成字典）
{'a': 1, 'b': 2}

>>> a = (("a",1),("b",2))	#（注：元组里面放元组）
>>> dict(a)	#（注：转换成字典）
{'a': 1, 'b': 2}

知识点35 集合基本操作 - 添加

添加
·用法： s.add(item) => 添加一项
·用法： s.update(someitems) => 添加多项

示例

>>> s = {1,2,3}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.update("str")	#（注：str被扩展进来，是一个一个被扩展进来的）
>>> s
{1, 2, 3, 4, 't', 'r', 's'}
>>> s.update({"x":1,"y":2})	#（注：字典  扩展的是 key值）
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 'r', 's'}

列表 的 添加 （注：同理）

>>> lst = [1,2]
>>> lst.extend((3,4))	#（注：同理）
>>> lst
[1, 2, 3, 4]
>>> lst.extend({"x":1,"y":2})	#（注：同理）
>>> lst
[1, 2, 3, 4, 'x', 'y']

知识点36 集合基本操作 - 移除

移除
·用法1： s.remove (item) => 移除一项(item不存在会报错)

• ·用法2： s.discard(item) => 移除一项(item不存在则什么也不做) （注：推荐）

示例

>>> s
{1, 2, 3, 4, 'x', 't', 'y', 'r', 's'}
>>> s.remove('r')
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 's'}
>>> s.remove('p')	#（注：“p”不存在，报错）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'p'

>>> s
{1, 2, 3, 4, 'x', 't', 'y', 's'}
>>> s.discard('o')	#（注：不存在 不报错  什么也不做）
>>> s.discard('x')
>>> s
{1, 2, 3, 4, 't', 'y', 's'}

知识点37 集合基本操作 - 集合操作

创建集合

示例

>>> set('hello')
{'e', 'o', 'l', 'h'}

注：自动去重

练习38 set()函数自动去重

查看字符串 特定字符 出现了多少次

示例

str = input("请输入字符串:")
str_set = set(str)		#（注：去重）
for i in str_set:		
    print(f"{i}出现了{str.count(i)}")

知识点39 集合基本操作 - 集合操作

并集、交集、差集、对称差集
并集：t 和 s的并集 ,返回一个新的 set 包含 s 和 t 中的每一个元素
s1 | s2
s1.union(s2)
交集: t 和 s的交集 , 返回一个新的 set 包含 s 和 t 中的公共元素
s1 & s2
差集: 返回一个新的 set 包含 s 中有但是 t 中没有的元素
s1 - s2
对称差集: 返回一个新的 set 包含 s 和 t 中不重复的元素（在t或s中，但不会同时出现在二者中）
s1 ^ s2
示例如下：

示例：并集

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 | s2
{1, 2, 3, 4}
>>> s1.union(s2)
{1, 2, 3, 4}

示例：交集

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 & s2
{2, 3}
>>> s1.intersection(s2)
{2, 3}

示例：差集

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 - s2
{1}

注：s1里面有的,s2里面没有的

>>> s2 - s1
{4}

对称差集

>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 ^ s2
{1, 4}

（注：除了交集 的部分）