第七节-python中元组（tuple）与字典（dict）

元组（tuple）与字典（dict）

一、元组（tuple）

1、元组（tuple）的介绍

• 元组也是序列结构，但是是一种不可变序列，你可以简单的理解为内容不可变的列表。除了在内部元素不可修改的区别外，元组和列表的用法差不多。

2、元组（tuple）的创建

• 创建一个元组，只要把逗号分隔的不同的数据元素使用小括号括起来即可。

tu = (1, 'Tom', 3.14)
print(type(tu))  # <class 'tuple'>

tu1 = tuple()  # tuple(iterable) 括号中为可迭代对象
print(type(tu1))  # <class 'tuple'>

3、元组（tuple）与列表（list）相同的操作

• 使用方括号加下标访问元素
• 切片（形成新元组对象）
• tuple.count() / tuple.index()
• python内置函数：reversed(), sorted()
• 加法及乘法

tu = tuple('12345')
print(tu[1])  # 2
print(tu[2:4])  # ('3', '4') 使用切片时，注意左闭右开
print(tu[::-1])  # ('5', '4', '3', '2', '1')

tu1 = (1, 2, 2, 3, 2, 4, 5)
print(type(tu1))  # <class 'tuple'>
print(tu1.count(2))  # 3
print(tu1.index(2))  # 1 第一个2出现的索引位置为1

tu2 = (1, 2, 3, 4, 5, 6, 7, 8, 9)  # 用reversed()实现元组的逆序
print(reversed(tu2))  # <reversed object at 0x0000018EF53883C8>
print(tuple(reversed(tu2)))  # (9, 8, 7, 6, 5, 4, 3, 2, 1)
tu3 = (1, 3, 5, 7, 9, 2, 4, 6, 8, 10)  # 用sorted()实现排序
print(sorted(tu3))  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]返回的是列表

tu4 = (1, 2, 3)
tu5 = (3, 4, 5)
print(tu5 + tu4)  # (3, 4, 5, 1, 2, 3)
print(tu4*2)  # (1, 2, 3, 1, 2, 3)
print(tu5*3)  # (3, 4, 5, 3, 4, 5, 3, 4, 5)

4、元组（tuple）中不允许的操作

• 不允许修改、新增元素（一级）
• 不允许删除某个元素（但可以删除整个元组）

tu = (1, 2, 3)
# tu[0] = 4  # 元组不可修改 打印会报错
# print(tu)  # TypeError: 'tuple' object does not support item assignment
print(tu + (4,))  # (1, 2, 3, 4) 可以拼接成一个新的元组
tu1 = (1, 2, 3, ['Tom', 5])
tu1[3][0] = 4  # 不可修改只在一级存在，要看修改的值是在元组还是在别的中
print(tu1)  # (1, 2, 3, [4, 5])

• 实际上，元组没有任何会对内部元素发生修改动作的方法。例如，元组没有 remove 、append、 pop等方法。

5、元组（tuple）与列表（list）之间的转换

li = [1, 2, 3,]
print(tuple(li))  # (1, 2, 3)
tu = (1, 2 , 3)
print(list(tu))  # [1, 2, 3]

二、字典（dict）

1、字典（dict）的介绍

• Python的字典数据类型是基于hash散列算法实现的，采用键值对（key:value）的形式，根据key的值计算value的地址，具有非常快的查取和插入速度。它是一种可变对象，所以支持修改、插入、删除等操作。

2、字典（dict）的创建

• 创建字典：
  • {}
  • {key1：value1， key2： value2}

dic = {}  # 创建空字典
print(dic)  # {}
print(type(dic))  # <class 'dict'>

information_Tom = {'address': 'london', 'age': 18, 'hobbit': ['play game', 'badminton']}
print(type(information_Tom))  # <class 'dict'>'
#注意： 字典中的value为任意类型，key只能是不可变数据类型
information_Tom = {'address': 'london', 'address': 'beijing'}
print(information_Tom)  # {'address': 'beijing'} 如果重复出现key值，将会覆盖前者，保留后者
dic1 = dict()  # 创建一个空字典
print(dic1)  # {}

dic2 = dict(name='Tom', age=18)  # 利用 dict(**kwargs)创建字典
print(dic2)  # {'name': 'Tom', 'age': 18}

dic3 = dict([('name', 'Tom'), ('age', 18)])  # 利用dict(mapping)创建字典
print(dic3)  # {'name': 'Tom', 'age': 18}

• 拓展：
  • map（func,*iterable）:
    将iterable里面的元素逐个传到func里面做处理
  • zip（iter1[,iter2[…]]）:
    将iter1 iter2 中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

li = list('1234')  # 将li中每个元素转为int类型
print(list(map(int, li)))  # [1, 2, 3, 4] 将li中每个元素传到int中，再返回

li_k = ['name', 'age']  # 目标：将li_k与li_v元素一一对应起来
li_v = ['Tom', 18]
print(dict(list(zip(li_k, li_v))))  # {'name': 'Tom', 'age': 18}一一对应，多余元素不显示

3、访问字典（dict）

• 字典是集合类型，不是序列类型，因此没有谱索引下标的概念，更没有切片的说法。但是，与list类似，字典采用把相对应的键放入方括号内获取对应值的方式取值。

dic1 = {'name': 'Tom', 'age':18}
# print(dic1[0])  # 报错，dict是集合类型，没有下标说法
print(dic1['name'])  # Tom 注意：当key值不存在时，会报错

4、字典（dict）的增加与修改

• 增加就是往字典插入新的键值对。

dic1 = {'name': 'Tom', 'age':18}
dic1['address'] = 'london'  # 增加
print(dic1)  # {'name': 'Tom', 'age': 18, 'address': 'london'}

# dict.setdefault(key,[default]) 向字典中添加key-value
# 如果这个key 已经存在于字典中，则返回该字典得value，如果不存在，则会向字典中添加key和value
dic1 = {'name': 'Tom', 'age': 18}
res = dic1.setdefault('name', 'Nie')  # 这个key 已经存在于字典中，则返回该字典得value
print(res)  # Tom
print(dic1)  # {'name': 'Tom', 'age': 18}

res1 = dic1.setdefault('addr', 'Beijing')  # 不存在，则会向字典中添加key和value
print(res1)  # Beijing
print(dic1)  # {'name': 'Tom', 'age': 18, 'addr': 'Beijing'}

• 修改就是给原有的键赋予新的值。由于一个key只能对相应一个值，所以，多次对一个key赋值，后面的值会把前面的覆盖掉。

dic1 = {'name': 'Tom', 'age':18}
dic1['age'] = 20  # 将原有的age=18 重新赋值为20
print(dic1)  # {'name': 'Tom', 'age': 20}

5、字典（dict）一系列删除

• 删除字典元素：del dic[exit_key] / dic.pop(exit_key)
• 删除整合字典：del dic
• 清空整个字典：dic.clear()

dic1 = {'name': 'Tom', 'age': 18}
del dic1['name']
print(dic1)  # {'age': 18}
dic1 = {'name': 'Tom', 'age': 18}
dic1.pop('age')
print(dic1)  # {'name': 'Tom'}
dic1 = {'name': 'Tom', 'age': 18}

del dic1
print(dic1)  # 已经删除，NameError: name 'dic1' is not defined
print(dic1.clear())  # None

6、字典（dict）的常见操作

• d.get(k[,d])–>返回指定键的值，如果值不存在字典中，则返回default值

dic1 = {'name': 'Tom', 'age': 18}
print(dic1.get('age'))  # 18
print(dic1.get('address'))  # None  如果用[],则会报错,使用get()返回none

• d.items()–>以列表返回可遍历的（键，值）元组对

dic1 = {'name': 'Tom', 'age': 18}
for key, value in dic1.items():
    print(key, value)  # name Tom  age 18

• d.keys()–>以列表返回字典所有的键

dic1 = {'name': 'Tom', 'age': 18}
print(dic1.keys())  # dict_keys(['name', 'age'])

• d.values–>以列表返回字典所有的值

dic1 = {'name': 'Tom', 'age': 18}
print(dic1.values())  # dict_values(['Tom', 18])

三、作业

1、li1 = [‘name’, ‘author’, ‘introduce’] li2 = [‘NORWEGIAN WOOD’, ‘Hatuki Murakami’, ‘babababab…’] 将li1与li2以键值对的形式呈现

li1 = ['name', 'author', 'introduce']
li2 = ['NORWEGIAN WOOD', 'Hatuki Murakami', 'babababab....']
print(dict(list(zip(li1, li2))))  # {'name': 'NORWEGIAN WOOD', 'author': 'Hatuki Murakami', 'introduce': 'babababab....'}


def f_map(key, value):
    return (key, value)


print(dict(map(f_map, li1, li2)))  # {'name': 'NORWEGIAN WOOD', 'author': 'Hatuki Murakami', 'introduce': 'babababab....'}

2、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”}]}} 找到python1/python2/python3
a = {'name': '123', 'data': {'result': [{'src': 'python1'}, {'src': 'python2'}, {'src': 'python3'}]}}
# 方法一
b = a.get('data')
for i in b['result']:
    print(i.get('src'))
# 方法二
b = a.get('data')
for i in b['result']:
    for key, value in i.items():
       print(value)

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

# 有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66值保存至第二个key的值中。
li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
dic = {'key1': [], 'key2': []}
for i in li:
    if i >= 66:
        dic.get('key1').append(i)
    else:
        dic.get('key2').append(i)
print(dic)