8_python笔记-元组-字典-集合
- 知识点1 容器类型 - 列表 回顾
- 知识点2 练习
- 知识点3 元组(tuple)
- 知识点4
- 知识点5 元组基本操作
- 知识点6 元组基本操作 - 索引
- 知识点7 元组基本操作 - 切片
- 知识点8 元组基本操作 - 不可变性
- 知识点9 元组包含列表时 列表可以改变
- 知识点10 元组基本操作 - 统计
- 知识点11 元组基本操作 - 遍历元组
- 知识点12 元组基本操作 - 成员关系
- 知识点13 列表与元组的异同
- 知识点14 列表与元组 的 相互转换
- 练习15 用户检测小工具
- 知识点16 字典 dict
- 知识点17 字典的定义
- 知识点18 字典是无序的
- 知识点19 字典的定义
- 知识点20 字典基本操作
- 知识点21 字典基本操作 - 取值
- 知识点22 字典基本操作 - 增加/修改
- 知识点23 字典基本操作 - 删除
- 知识点24 字典基本操作 - 合并字典
- 知识点24.2 **a
- 知识点25 **a 的使用
- 知识点26 字典基本操作 - 成员关系
- 知识点27 字典基本操作 - 遍历字典
- 练习28 字典练习
- 练习29 用户检测
- 知识点30 集合( set )
- 知识点31 集合的定义
- 知识点32 集合转换
- 知识点33 去重(set)
- 知识点34 dict() 转换成字典
- 知识点35 集合基本操作 - 添加
- 知识点36 集合基本操作 - 移除
- 知识点37 集合基本操作 - 集合操作
- 练习38 set()函数自动去重
- 知识点39 集合基本操作 - 集合操作
博客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}
(注:除了交集 的部分)