元组、字典和集合

1.元组

1.1元组是不可变的序列，是python基础数据结构的一种。元组一般用“()”号包含元素，各元素间用“,”号隔开，有些情况下“()”号也可以省略，我认为不省略“()”号程序的可读性更强。

tuple1 = (1,)
tuple2 = 1,
#tuple1和tuple2的结果完全一样为(1,)，type为元组

1.2非空元组必须要至少包含一个“,”号

tuple1 = (1,)
tuple2 = 1,2,3
#非空元组必须要至少包含一个“,”号
tuple = () #这是一个空元组

1.3元组解包，一般要求解包的变量个数和元组的元素个数相等，如果不相等，那么变量中要有且仅有一个带“*”号的变量，用来存储多个元素组成的列表。

tuple2 = 1,2,3,4
a,b,c,d = tuple2
print(a,b,c,d)#结果为1 2 3 4
a,b,*c = tuple2
print(a,b,c)#结果为1 2 [3, 4]

2.字典

2.1字典是python中映射类型的数据结构。mapping
2.2字典的特点：查询能力强，存储能力相对较弱。
2.3字典也称之为key-value结构。字典的基本语法{key1:value1,key2:value2,···}，通过key键很容易找到对应的value，key可以是任意不可变对象，如数字，字符串等，
value可以是任何对象，如字典、列表、元组、字符串、集合等。一对key-value称为一项item。

d = {'名字':'死神','类别':'动画片','制作国家':'日本'}
a = d['类别'] #a的值为'动画片'，其中'类别'为key，'动画片'为value，'类别':'动画片'为item

2.4字典的使用
- dict()，创建字典用。直接写入key-value结构，或一个包含双值子序列的序列
- get(key,默认值)，获取如果key存在获取对应的值，如果不存在获取默认值。默认值为None可以省略

d = {'名字':'死神','类别':'动画片','制作国家':'日本'}
b = d.get('名字',None)    #b的值为'死神'，等同于b=d.get('名字')
c = d.get('主人公',None) #c的值为None，c = d.get('主人公')

update()，把其他字典项添加到自己项的最后面。

d1 = {1:'one',2:'two'}
d2 = {3:'three',4:'four'}
d1.update(d2) #d1为{1: 'one', 2: 'two', 3: 'three', 4: 'four'}，d2为{3: 'three', 4: 'four'}

del删除字典的项或字典本身。

d1 = {1:'one',2:'two'}
del d1[1] #d1的值 {2:'two'}
del d1 #d1不存在了

popitem()随机删除字典中的一个item，一般删除最后一个，并以元组的形式获取删除的item。

d1 = {1:'one',2:'two',3:'three',4:'four'}
a = d1.popitem()
#d1的值为{1: 'one', 2: 'two', 3: 'three'}，a的值为(4, 'four')

pop(key,默认值)，删除字段中指定key的值，并获取删除key的值，如果默认值省略，当key不在字典时报错，如果给定默认值，key不存在时不报错，不改变字典，获取默认值。

d1 = {1:'one',2:'two',3:'three',4:'four'}
a = d1.pop(1)
#d1的值为{2: 'two', 3: 'three', 4: 'four'}，a的值为'one'
b = d1.pop(5,'key不存在')
#d1的值为{2: 'two', 3: 'three', 4: 'four'}，b的值为'key不存在'

copy()，浅复制。复制字典，但只复制字典的第一层，如果字典value中还有字典，那么二层的字典不是复制。

d1 = {1:'one',2:'two',3:'three',4:{5:'five',6:'six'}}
d2 = d1.copy()
d1[1] = 'four'
d1[4][5] = 'four'
#d1的值为{1: 'four', 2: 'two', 3: 'three', 4: {5: 'four', 6: 'six'}}
#d2的值为{1: 'one', 2: 'two', 3: 'three', 4: {5: 'four', 6: 'six'}}

2.5字典的变量
- keys()，遍历键。
- values()，遍历值。
- items()，遍历键和值。

d1 = {1:'one',2:'two',3:'three',4:{5:'five',6:'six'}}
for key in d1.keys():
    print(d1[key],end=' ')
print()
for value in d1.values():
    print(value,end=' ')
print()
for key,value in d1.items():
    print(f'{key}:{value}',end=' ')
'''
输出结果为
one two three {5: 'five', 6: 'six'} 
one two three {5: 'five', 6: 'six'} 
1:one 2:two 3:three 4:{5: 'five', 6: 'six'} 
'''

3.集合

3.1集合的特点
- 集合只能储存不可变对象。
- 集合的元素是无序的
- 集合中的元素不重复，如果有重复，自动合并。

s = {1,2,3,4,6,2,1,5}#s的值为{1, 2, 3, 4, 5, 6}
s2 = {[1,2],1}#TypeError: unhashable type: 'list'

3.2set()函数，可以将其他序列变为集合。

a = set()#空集合
b = set([1,2,3,4,1,5])#b的值为{1, 2, 3, 4, 5}
c = set('python, I love it')#c的值为{'i', 'y', ',', 'p', 'n', ' ', 'v', 'o', 't', 'l', 'I', 'h', 'e'}
d = set((1,7,2,1,4,2))#d的值为{1, 2, 4, 7}

4.作业

4.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["data"]["result"][0]["src"])
print(a["data"]["result"][1]["src"])
print(a["data"]["result"][2]["src"])

运行结果

图片.png

4.2有如下集合{11,22,33,44,55,66,77,88,99,90}，将所有大于66的值保存至字典的第一个key中，将小于66的值保存至字典的第二个key中。

s = {11,22,33,44,55,66,77,88,99,90}
l = list(s)
l1 = []#存放大于66的值
l2 = []#存放小于66的值
for each in l:
    if each > 66:
        l1.append(each)
    if each < 66:
        l2.append(each)
t1 = tuple(l1)
t2 = tuple(l2)
d = dict([(t1, '大于66的值'),(t2, '小于66的值')])
print(d,type(d))

运行结果为

图片.png