Python学习第七课-元组&字典&集合

最新推荐文章于 2021-08-15 13:01:55 发布

MIANHUA_007

最新推荐文章于 2021-08-15 13:01:55 发布

阅读量249

点赞数

分类专栏： Python学习课程文章标签： python

本文链接：https://blog.csdn.net/mianhua_007/article/details/116102588

版权

Python学习课程专栏收录该内容

15 篇文章 2 订阅

订阅专栏

本文详细介绍了Python中的元组、字典和集合的使用，包括它们的创建、操作、遍历、增删改查等。元组是不可变序列，适合存储不可变数据；字典是一种映射数据结构，提供快速查找功能；集合是无序且不重复的元素集合，支持多种集合运算。此外，还讨论了浅拷贝和深拷贝的区别。

摘要由CSDN通过智能技术生成

一.元组

1.1元组简介

元组表现形式tuple
元组是一个不可变序列(一般当我们不希望数据不改变时，我们使用元组,其
他情况下基本都用列表)
元组使用小括号 ( )，列表使用方括号 [ ]
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
元组不是空元组至少有一个逗号(,)当元组不是空元组时括号可以省略
元组解包指将元组当中的每一个元素都赋值给一个变量

#元组tuple()的创建
tuple1=()#空元组
print(type(tuple1))
'''<class 'tuple'>'''

tuple1=(1,True,None,[])#空元组
print(type(tuple1))
print(tuple1)
print(tuple1[2]) #元组元素的调用
'''
<class 'tuple'>
(1, True, None, [])
None
'''

tuple2=10,#创建元组时可以省略括号，但是需要添加逗号
print(type(tuple2),tuple2)
'''
<class 'tuple'> (10,)
'''

#去掉逗号时，会自动默认成赋值运算，类型就变成了整型
tuple2=10
print(type(tuple2),tuple2)
'''
<class 'int'> 10
'''

1.2元组的拆包

#元组的拆包 数量与元组内值数量一致时，自动那照顺序赋值
tuple1=(1,2,3)
a,b,c=tuple1
print(a)
print(b)
print(c)
'''
1
2
3
'''

tuple1=(1,2,3,4)
a,b,c=tuple1
print(a)
print(b)
print(c)
'''
ValueError: too many values to unpack (expected 3)
#当元组内，数据大于外部变量时会报错，结果办法是可以对单一变量使用通配符*
'''

tuple1=(1,2,3,4)
a,b,*c=tuple1 #*是一个通配符，使用通配符后，通配符所在变量，数组类型会变成列表
print(a)
print(b)
print(c)
'''
1
2
[3, 4]
'''

tuple1=(1,2,3,4,5,6)
a,*b,c,d=tuple1 #通配符可以赋值且只能赋值给一个变量
print(a)
print(b)
print(c)
print(d)
'''
1
[2, 3, 4]
5
6
'''

tuple1=(1,2,3,4,5,6)
a,*b,*c,d=tuple1 #*是一个通配符
print(a)
print(b)
print(c)
print(d)
'''
SyntaxError: two starred expressions in assignment
'''
#两个通配符会出现该错误

注意：无法实现赋值两个变量通配符，给两个变量平均分配剩余元素

1.3字符串拆包

#字符串拆包
s='abcdefghigk'
a,*b,c=s
print(a)
print(b)
print(c)
'''
a
['b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'g']
k
'''

1.4列表的拆包

list1=[1,2,3,4,5,6]
a,*b,c=list1
print(a)
print(b)
print(c)
'''
1
[2, 3, 4, 5]
6
'''

1.5拆包练习

#简单序列赋值
# simple sequence assignment

a, b = 1, 2  #整数赋值
print('a={},b={}'.format(a,b))
'''
a=1,b=2
'''

a, b = ['green', 'blue'] #列表赋值            # list asqignment
print('a={},b={}'.format(a,b))
'''
a=green,b=blue
'''

a, b = 'XY'    #字符串赋值                      # string assignment
print('a={},b={}'.format(a,b))
'''
a=X,b=Y
'''

a, b = range(1,5,2) #可迭代类型赋值 # any iterable will do
print('a={},b={}'.format(a,b))
'''
a=1,b=3
'''

嵌套序列赋值
nested sequence assignment

(a,b), c = "XY", "Z"                 # a = 'X', b = 'Y', c = 'Z'
print('a={},b={}，c={}'.format(a,b,c))
#print(type((a,b)),type(c))
'''
a=X,b=Y，c=Z
'''


(a,b), c = "XYZ"           # ERROR -- too many values to unpack
print('a={},b={}，c={}'.format(a,b,c))
'''
ValueError: too many values to unpack (expected 2)
赋值顺序，先对(a,b)赋值'XYZ'，报错'有多余的值未拆包'(预期 2) 有两个值就够了，给多了拆不完
'''

(a,b), c = "XY"
print('a={},b={}，c={}'.format(a,b,c))
'''
ValueError: not enough values to unpack (expected 2, got 1)
#报错'没有足够的值用来拆包'(预期 2，得到1 ) 还需要再加一组值
'''

(a,b), c, = [1,2],'this'
print('a={},b={}，c={}'.format(a,b,c))
'''
a=1,b=2，c=this
'''


(a,b), (c,) = [1,2],'this'
print('a={},b={}，c={}'.format(a,b,c))
'''
ValueError: too many values to unpack (expected 1)
#报错'有多余的值未拆包'(预期1) 有1个值就够了 'this'有四个值
'''

# 扩展序列拆包
# extended sequence unpacking

a, *b = 1,2,3,4,5
print('a={},b={}'.format(a,b))
'''
a=1,b=[2, 3, 4, 5]
'''

*a, b = 1,2,3,4,5
print('a={},b={}'.format(a,b))
'''
a=[1, 2, 3, 4],b=5
'''

a, *b, c = 1,2,3,4,5
print('a={},b={}，c={}'.format(a,b,c))
'''
a=1,b=[2, 3, 4]，c=5
'''

a, *b = 'X'
print('a={},b={}'.format(a,b))
'''
a=X,b=[]
'''

*a, b = 'X'
print('a={},b={}'.format(a,b))
'''
a=[],b=X
'''

a, *b, c = "XY"
print('a={},b={}，c={}'.format(a,b,c))
'''
a=X,b=[]，c=Y
'''

a, *b, c = "X...Y"
print('a={},b={}，c={}'.format(a,b,c))
'''
a=X,b=['.', '.', '.']，c=Y
'''

a, b, *c = 1,2,3
print('a={},b={}，c={}'.format(a,b,c))
'''
a=1,b=2，c=[3]
'''

a, b, c, *d = 1,2,3
print('a={},b={}，c={},d={}'.format(a,b,c,d))
'''
a=1,b=2，c=3,d=[]
'''

a, *b, c, *d = 1,2,3,4,5
print('a={},b={}，c={},d={}'.format(a,b,c,d))
'''
SyntaxError: two starred expressions in assignment
#语法错误：有两个通配符*在赋值语句中
'''

(a,b), c = [1,2],'this'
print('a={},b={}，c={}'.format(a,b,c))
'''
a=1,b=2，c=this
'''

(a,b), *c = [1,2],'this'
print('a={},b={}，c={}'.format(a,b,c))
'''
a=1,b=2，c=['this']
'''

二.字典的简介

2.1介绍

在这里插入图片描述

字典属于-种新的数据结构称为映射(mapping)
字典的作用和列表类似，都是用来存储对象的容器
列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定
的元素
这个唯一的名字我们称之为key通过key，可以快速查询value也可以称之为
值
字典我们也称之为键值对(key-value)结构
每个字典中都可以有多个键值对,而每一个键值对我们称其为一项(item)
创建一个有数据的字典语法{key:value}
字典的值可以是任意对象字典的键可以是任意的不可变对象(int str bool
tuple…).
字典的键是不能重复的，如果出现重复的后面的会替换前面的

2.2操作

字典支持的主要操作如下：

运算操作	描述
class dict(other)	创建字典（other可以是字典、(key, value)对的迭代器或关键字参数）
dict.fromkeys(seq[, value])	创建字典：用序列seq中的元素作为键，值全为value（未指定，则默认为None）
len(d)	-返回字典d的长度（即d中元素的个数）
d[key]	-如果键key在字典d中，则返回其中key对应的值；否则抛出KeyError异常
d[key] = value	设置d[key]的值为value（存在则修改，不存在则添加）
del d[key]	如果键key在字典d中，则从字典d中删除d[key]；否则抛出KeyError异常
key in d	如果key在字典d中，返回True；否则，返回False
key not in d	如果key在字典d中，返回False；否则，返回True
iter(d)	同iterkeys()
d.clear()	删除字典d中的所有元素
d.copy()	返回字典d的浅拷贝
d.get(key[, default])	如果key在字典d中，则返回d[key]；否则返回default（未指定，则默认为None）
d.has_key(key)	同key in d（推荐使用key in d）
d.items()	返回包含字典d中的(key, value)对的列表
d.iteritems()	迭代版的items()：返回迭代器
d.iterkeys()	迭代版的keys()：返回迭代器
d.itervalues()	迭代版的values()：返回迭代器
d.keys()	返回包含字典d中的键的列表
d.pop(key[, default])	如果key在字典d中，则返回并删除d[key]；否则返回default（未指定，则抛出KeyError异常）
d.popitem()	返回并删除字典d中的任意一个元素（如果d为空，则抛出KeyError异常）
d.setdefault(key[, default])	如果key在字典d中，则返回d[key]；否则执行d[key] = default，并返回default（未指定，则默认为None）
d.update([other])	将other中的(key, value)对添加到字典d中（other可以是字典、(key, value)对的迭代器或关键字参数）
d.values()	返回包含字典d中的值的列表
d.viewitems()	返回字典d的元素视图
d.viewkeys()	返回字典d的键视图
d.viewvalues()	返回字典d的值视图

三.字典的使用

#通过{}创建字典
dict1={}
print(type(dict1))
'''
<class 'dict'>
'''

#字典的键和值成对出现
dict1={'name':'杨过','age':'18','gender':'男'}
print(type(dict1))
print(dict1)
'''
<class 'dict'>
{'name': '杨过', 'age': '18', 'gender': '男'}
'''

#创建字典的三种方法
dict1={'name':'杨过','age':'18','gender':'男'}
dict2=dict(name='杨过',age='18',gender='男')
dict3=dict([('name','杨过'),('age','18'),('gender','男')])
print(dict1)
print(dict2)
print(dict3)
'''
{'name': '杨过', 'age': '18', 'gender': '男'}
{'name': '杨过', 'age': '18', 'gender': '男'}
{'name': '杨过', 'age': '18', 'gender': '男'}
'''

#基本格式 推荐使用该种方式创立字典数据，方便检查，以及字典值的调用方法
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
print(dict1)
print(dict1['gender'])
'''
{'name': '杨过', 'age': '18', 'gender': '男', 'skill': '黯然销魂掌'}
男
'''

#当字典中出现两个相同键时，后面的值会覆盖前面的值
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌',
       'name':'龙骑士',}
print(dict1)
print(dict1['name'])
'''
{'name': '龙骑士', 'age': '18', 'gender': '男', 'skill': '黯然销魂掌'}
龙骑士
'''

#双值子序列， 
#双值:元组('name','杨过')，
#子序列[('name','杨过')],
#双值子序列[('name','杨过'),('age','18'),('gender','男')] 
#双值子序列可以通过dict()转换为字典                      
dict3=dict([('name','杨过'),('age','18'),('gender','男')])                                                                
print(dict3)

四.字典的增删改查

4.1len()方法

描述
字典(Dictionary) len() 函数计算字典元素个数，即键的总数。
语法

#len()方法语法：
len(dict)

参数
dict – 要计算元素个数的字典。
返回值
返回字典的元素个数。

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}

print(len(dict1))
'''
4
'''

4.2in 操作符

描述
Python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。
而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。
语法

#in 操作符语法：
key in dict

参数
key – 要在字典中查找的键。
返回值
如果键在字典里返回true，否则返回false。

#in or not in 以key为准
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}

print('name' in dict1)
print('杨过' in dict1)
'''
True
False
'''

4.3get() 方法

描述
Python 字典 get() 函数返回指定键的值。
语法

#get()方法语法：
dict.get(key, default=None)

参数
key – 字典中要查找的键。
default – 如果指定的键不存在时，返回该默认值。
返回值
返回指定键的值，如果键不在字典中返回默认值 None 或者指定的默认值。

#通过key来获取value
#获取的方法
#dict.get(key)
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}

print(dict1.get('skill'))
print(dict1.get('黯然销魂掌'))
'''
黯然销魂掌
None
'''

4.4修改字典

-语法

dict[key]=value

参数
key – 要在字典中查找的键。键必须是唯一的，但值则不必。
value-- 值可以取任何数据类型，但键必须是不可变的，如字符串，数字
要点
- value 存在的，更新value，不存在的添加key/value键值对

#修改字典
#dict[key]=value
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
dict1['name']="小龙女"
print(dict1)
'''
{'name': '小龙女', 'age': '18', 'gender': '男', 'skill': '黯然销魂掌'}
'''

修改字典
dict[key]=value
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
dict1['lover']="小龙女"
print(dict1)
'''
{'name': '杨过', 'age': '18', 'gender': '男', 'skill': '黯然销魂掌', 'lover': '小龙女'}
#不存在是插入key：value
'''

4.5 setdefault() 方法

描述
Python 字典 setdefault() 方法和 get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。
语法

#setdefault()方法语法：
dict.setdefault(key, default=None)

参数
key – 查找的键值。
default – 键不存在时，设置的默认键值。
返回值
如果 key 在字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。

#添加方法
#dict.setdefault(key)
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
res=dict1.setdefault('name','小龙女')#当key存在的时候不会对字典做任何修改，而是会返回value值
print(res)
print(dict1)
'''
杨过
{'name': '杨过', 'age': '18', 'gender': '男', 'skill': '黯然销魂掌'}
'''

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
res=dict1.setdefault('lvoer','小龙女')#当key不存在时，添加剪纸对 并且返回value值
print(res)
print(dict1)
'''
小龙女
{'name': '杨过', 'age': '18', 'gender': '男', 'skill': '黯然销魂掌', 'lvoer': '小龙女'}
'''

4.6 update() 方法

描述
字典 update() 函数更新字典里面的 key/value(键/值)。
语法

#update() 方法语法：
dict.update(dict2)

参数
key – 查找的键值。
default – 键不存在时，插入键值对。
-返回值
该方法没有任何返回值。

#键不存在时，设置默认键值。
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
dict1.update({'1':1,'2':2})
print(dict1)
'''
{'name': '杨过', 'age': '18', 'gender': '男', 'skill': '黯然销魂掌', '1': 1, '2': 2}
'''

#键存在时，设置的默认键值。
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
dict1.update({'name':'龙骑士'})
print(dict1)
'''
{'name': '龙骑士', 'age': '18', 'gender': '男', 'skill': '黯然销魂掌'}
'''

4.7 del dict[I]删除关键字

能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令

注意：del删除的是key，不能对value进行删除

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
del dict1['name']
print(dict1)
del dict1['黯然销魂掌']
print(dict1)
'''
{'age': '18', 'gender': '男', 'skill': '黯然销魂掌'}
KeyError: '黯然销魂掌'
'''

4.8 clear清空字典

# 清空字典
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
dict1.clear()  # 清空字典
print(dict1)
'''
{}
'''

4.9 del dict 删除字典对象

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
del dict1  # 清空字典
print(dict1)
'''
NameError: name 'dict1' is not defined
'''

4.10 pop() 方法

描述
字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。
语法

#pop()方法语法：
pop(key[,default])

参数
– key: 要删除的键值
– default: 如果没有 key，返回 default 值
返回值
返回被删除的值。

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
res=dict1.pop('name')
print(res)
print(dict1)
'''
杨过
{'age': '18', 'gender': '男', 'skill': '黯然销魂掌'}
'''

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
res=dict1.pop('lover','lover键不存在') #要删除的键不存在是，返回默认值
print(res)
print(dict1)
'''
lover键不存在
{'name': '杨过', 'age': '18', 'gender': '男', 'skill': '黯然销魂掌'}
'''

4.11 popitem() 方法

描述
字典 popitem() 方法返回并删除字典中的最后一对键和值。
如果字典已经为空，却调用了此方法，就报出 KeyError 异常。
语法

#popitem()方法语法：
popitem()

参数
无
返回值
返回一个键值对(key,value)形式。

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
res=dict1.popitem() #不需要传递参数，默认删除最后一组健值对
print(res)
print(dict1)
'''
('skill', '黯然销魂掌')
{'name': '杨过', 'age': '18', 'gender': '男'}
'''

5.浅拷贝和深拷贝

5.1 前导

#copy()
a ='abcd'
b ='abcd'
print(id(a))
print(id(b))
b=b.upper()
print(b)
print(id(b))
'''
140275589289008
140275589289008
ABCD
140275612306224
#字符串是不可变类型，值不可变，id不可变
#值改变 id就改变，值不变，id就不变
'''

#可变类型:变的是id
a=[1,2,3]
b=[1,2,3]
c=[1,2,3]
d=[1,2,3]
print(id(a))
print(id(b))
print(id(c))
print(id(d))
'''
140557058348224
140557058348736
140557027059648
140557027087680
'''

5.2 浅拷贝

#copy()浅拷贝 ，拷贝后新旧对象id不一致
import copy
dict1={'name': '杨过', 'age': '18', 'gender': '男','data':[1,2,3]}
dict2=copy.copy(dict1)
print(id(dict1))
print(id(dict2))
'''
140376570100672
140376570100736
'''

import copy
#copy()浅拷贝，更新原有字典，新字典的值不变
dict1={'name': '杨过', 'age': '18', 'gender': '男','data':[1,2,3]}
dict2=copy.copy(dict1)
dict1['name']=456
print(dict1)
print(dict2)
print(id(dict1))
print(id(dict2))
'''
{'name': 456, 'age': '18', 'gender': '男', 'data': [1, 2, 3]}
{'name': '杨过', 'age': '18', 'gender': '男', 'data': [1, 2, 3]}
140684901776320
140684901776384
'''

import copy
#copy()浅拷贝
dict1={'name': '杨过', 'age': '18', 'gender': '男','data':[1,2,3]}
#[1,2,3]是引用到字典中的，浅拷贝，拷贝数据类型的第一层数据，然后存储，不能拷贝第二层以及更多层的数据
dict2=copy.copy(dict1)
dict1['data'][1]=456
print(dict1)
print(dict2)
print(id(dict1['data']))
print(id(dict2['data']))
print(id(dict1))
print(id(dict2))
'''
{'name': '杨过', 'age': '18', 'gender': '男', 'data': [1, 456, 3]}
{'name': '杨过', 'age': '18', 'gender': '男', 'data': [1, 456, 3]}
140256536595392
140256536595392
140256512342976
140256512343040
'''

import copy
#deepcopycopy()深拷贝
dict1={'name': '杨过', 'age': '18', 'gender': '男','data':[1,2,3]}
#deepcopycopy()深拷贝能够拷贝所有的数据，更新旧字典中的二层数据，新字典中的二层数据不更新
dict2=copy.deepcopy(dict1)
dict1['data'][1]=456
print(dict1)
print(dict2)
print(id(dict1['data']))
print(id(dict2['data']))
print(id(dict1))
print(id(dict2))
'''
{'name': '杨过', 'age': '18', 'gender': '男', 'data': [1, 456, 3]}
{'name': '杨过', 'age': '18', 'gender': '男', 'data': [1, 2, 3]}
140443619201600
140443619202880
140443595078528
140443595078912
'''

6.字典的遍历

6.1 keys() 方法

描述
Python3 字典 keys() 方法返回一个可迭代对象，可以使用 list() 来转换为列表。
注意：Python2.x 是直接返回列表
语法

#keys()方法语法：
dict.keys()

参数
NA。
返回值
返回一个迭代器。

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
print(dict1.keys())
print(type(dict1.keys()))
print(list(dict1.keys()))
'''
dict_keys(['name', 'age', 'gender', 'skill'])
<class 'dict_keys'>
['name', 'age', 'gender', 'skill']
'''

6.2 通过dict.keys遍历字典

#通过dict.keys遍历
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}

for k in dict1.keys():
    print(dict1[k])

'''
杨过
18
男
黯然销魂掌
'''

6.3 values() 方法

描述
Python 字典 values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
语法

#values()方法语法：
dict.values()

参数
NA。
返回值
返回迭代器。

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
print(dict1.values())
print(type(dict1.values()))
print(list(dict1.values()))
'''
dict_values(['杨过', '18', '男', '黯然销魂掌'])
<class 'dict_values'>
['杨过', '18', '男', '黯然销魂掌']
'''

6.4 通过values() 方法遍历字典

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
for v in dict1.values():
    print(v)
dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
for v in dict1.values():
    print(v)
'''
杨过
18
男
黯然销魂掌
'''

6.5 items() 方法

描述
Python 字典 items() 方法以列表返回可遍历的(键, 值) 元组数组。
语法

#items()方法语法：
dict.items()

参数
NA。
返回值
返回可遍历的(键, 值) 元组数组。

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
print(dict1.items())
print(type(dict1.items()))
print(list(dict1.items()))
'''
dict_items([('name', '杨过'), ('age', '18'), ('gender', '男'), ('skill', '黯然销魂掌')])
<class 'dict_items'>
[('name', '杨过'), ('age', '18'), ('gender', '男'), ('skill', '黯然销魂掌')]
'''

6.5 通过 items() 方法遍历字典

dict1={'name':'杨过',
       'age':'18',
       'gender':'男',
       'skill':'黯然销魂掌'}
for k,v in dict1.items():
    print(k,'=',v)
'''
name = 杨过
age = 18
gender = 男
skill = 黯然销魂掌
'''

7.集合

7.1 简介

集合表现形式set集合和列表非常相似
不同点.
。集合只能存储不可变对象
。集合中存储的对象是无序的
。集合不能出现重复元素

7.2 基本操作

使用{}来创建集合
可以通过set()来将序列和字典转换成集合

#集合的创建
#set{}
set1={} #只能创建空字典，不能创建空集合
set1=set()
print(type(set1))
'''
<class 'set'>
'''

set1= {1,2,3,4,5,6}
print(set1)
'''
{1, 2, 3, 4, 5, 6}
'''

set1= {1,2,3,4,5,[1,2]}
print(set1)
'''
TypeError: unhashable type: 'list'
#不能存储可变类型：列表
'''

#集合中存储的对象是无序的，没有索引
set1= {6,8}
print(set1)
'''
{8, 6}
'''

#集合不能出现重复元素
set1= {1,1,2,3,3,4,5,4,5,7,8}
print(set1)
'''
{1, 2, 3, 4, 5, 7, 8}
'''

#可用于去重
list1=[1,1,2,3,3,4,5,4,5,7,8]
set1=set(list1)
list1=list(set1)
print(list1)
'''
[1, 2, 3, 4, 5, 7, 8]
'''

8.集合的使用

8.1 len()方法

set1={1, 2, 3, 4, 5, 7, 8}
print(len(set1))
'''
7
'''

8.2 add()像集合中添加元素

不返回值，参数需需要添加的元素

set1={1, 2, 3, 4, 5, 7, 8}
set1.add(9)
print(set1)
'''
{1, 2, 3, 4, 5, 7, 8, 9}
'''

8.3 update()将一个集合中的元素添加到另一个集合当中

set1={1, 2, 3, 4, 5, 7, 8}
set2={5,6}
set2.update(set1)
print(set1)
print(set2)
'''
{1, 2, 3, 4, 5, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
'''

⚠️注意：set2={}时会报错

set1={1, 2, 3, 4, 5, 7, 8}
set2={}
set2.update(set1)
print(set1)
print(set2)
'''
{1, 2, 3, 4, 5, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
'''

8.4 pop() 方法

描述
pop() 方法用于随机移除一个元素。
语法

#pop() 方法语法：
set.pop()

参数
无
返回值
返回移除的元素。

import random
i=0
while i<10:
    random_list=random.sample(range(1,10), 5)
    set1=set(random_list)
    print(set1)
    res=set1.pop()
    print(res)
    print(set1)
    print('-------------------------')
    i+=1
'''
{1, 4, 5, 7, 9}
1
{4, 5, 7, 9}
-------------------------
{1, 2, 3, 7, 8}
1
{2, 3, 7, 8}
-------------------------
{1, 3, 5, 6, 9}
1
{3, 5, 6, 9}
-------------------------
{1, 4, 5, 6, 7}
1
{4, 5, 6, 7}
-------------------------
{2, 3, 6, 7, 8}
2
{3, 6, 7, 8}
-------------------------
{1, 2, 3, 4, 8}
1
{2, 3, 4, 8}
-------------------------
{4, 5, 6, 7, 9}
4
{5, 6, 7, 9}
-------------------------
{1, 2, 3, 4, 5}
1
{2, 3, 4, 5}
-------------------------
{3, 5, 6, 7, 9}
3
{5, 6, 7, 9}
-------------------------
{4, 5, 6, 7, 8}
4
{5, 6, 7, 8}
-------------------------
'''

8.5 remove() 方法

描述
remove() 方法用于移除集合中的指定元素。
该方法不同于 discard() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
语法

#remove() 方法语法：
set.remove(item)

- 参数
item -- 要移除的元素
- 返回值
没有返回值。

set1={1, 2, 3, 4, 5, 7, 8}
print(set1)
set1.remove(3)
print(set1)
'''
{1, 2, 3, 4, 5, 7, 8}
{1, 2, 4, 5, 7, 8}
'''

8.6 clear()清空集合

set1={1, 2, 3, 4, 5, 7, 8}
print(set1)
set1.clear()
print(set1)
'''
{1, 2, 3, 4, 5, 7, 8}
set()
'''

8.7 集合的运算

运算操作	描述
&	交集运算
｜	并集运算
-	差集运算
^	亦或集
<=	检查-个集合是否是另一个集合的子集
<	检查-个集合是否是另一个集合的真子集
>=	检查一个集合是否是另一个集合的超集
>	检查一个集合是否是另一个集合的真超集

在这里插入图片描述

定义：如果一个集合S2中的每一个元素都在集合S1中，且集合S1中可能包含S2中没有的元素，则集合S1就是S2的一个超集，反过来，S2是S1的子集。
S1是S2的超集，若S1中一定有S2中没有的元素，则S1是S2的真超集，反过来S2是S1的真子集。

s1={1,2,3,4}
s2={3,4,5,6}
print('交集运算 s1&s2 ={}'.format(s1&s2))
print('并集运算 s1|s2 = {}'.format(s1|s2))
print('差集运算 s1-s2 = {}'.format(s1-s2))
print('差集运算 s2-s1 = {}'.format(s2-s1))
print('亦或集运算 s1^s2 = {}'.format(s1^s2))
'''
交集运算 s1&s2 ={3, 4}
并集运算 s1|s2 = {1, 2, 3, 4, 5, 6}
差集运算 s1-s2 = {1, 2}
差集运算 s2-s1 = {5, 6}
亦或集运算 s1^s2 = {1, 2, 5, 6}
'''

s1={3,4}
s2={3,4,5,6}
print(s1<=s2)#|<=|检查-个集合是否是另一个集合的子集
print(s1<s2)#|<|检查-个集合是否是另一个集合的真子集

print(s2>=s1)#|>=|检查一个集合是否是另一个集合的超集
print(s2>s1)#|>|检查一个集合是否是另一个集合的真超集
'''
True
True
True
True
'''

九.作业

9.1 查找字符串

a =
{“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},
{“src”:“python3”}]}}找到python1/python2/python3

a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},
{"src":"python3"}]}}
# print(a)
# print(type(a))
# print(a['name'])
# print(a['data'])
# print(a['data']['result'])
# print(a['data']['result'][0])
# print(a['data']['result'][1])
# print(a['data']['result'][2])
print(a['data']['result'][0]['src'])
print(a['data']['result'][1]['src'])
print(a['data']['result'][2]['src'])
'''
python1
python2
python3
'''

9.2 字典存值

有如下值列表[11,22,33,44,55,66,77,88,99,90],将所有大于66的值保存至字典的第一
个key的值中，将小于66值保存至第二个key的值中。

list1 = [11,22,33,44,55,66,77,88,99,90]
lista =[]
listb =[]
dict = {}
for i in list1:
    if i>66:
        lista.append(i)
    elif i<66:
        listb.append(i)
print(list1)
print(lista)
print(listb)
dict.setdefault('第一组值',lista)
dict.setdefault('第二组值',listb)
print(dict)