字典的处理

字典的基础

• 字典是另一种可变容器模型，且可存储任意类型对象。使用花括号{}。
• 键key：值value 可以把key和value关联，便于查找和定位
• 键的类型必须是不可以变的，字符串、整数、浮点数、布尔类型也不可变，因此可定义为键，而列表list[]属于可变数据类型，不可以定义为键，要使键有能包含多个元素，可以使用元组()定义为字典的键，注意元组不可以变，即无删除、增加等修改。
• 可变：字典{}、列表[]
• 不可变：元组()、字符串、整数、浮点数、布尔类型

d = {key1 : value1, key2 : value2, key3 : value3 }

#创建空字典
d1={}  # 使用{}
d2=dict()  # dict()
print(d1)  # {}
print(d2)  # {}

创建字典、添加[]、存在in、长度len()

a = {'a': 1, 'b': 2, 'c': 3, 'z': 6}
print(a)  # {'a': 1, 'b': 2, 'c': 3, 'z': 6}

d={}
d['a']=100 # 往字典添加键为a、值为100的元素
print(d)  # {'a': 100}
d['b']=200
print(d)  # {'a': 100, 'b': 200}

# 判断某键是否存在字典里
contacts = {"路":"123","陆":"456","鹿":"789"}
print("路" in contacts)   # True

# 查看字典的长度
print(len(contacts))  # 3

字典键的特性

1. 键必须具有唯一性

• 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

d = {'name': '憨憨', 'name': '甘甘'}
print(d)  # {'name': '甘甘'}

2. 键必须不可变

• 键可以是数字、字符串、元组，但是不可以用列表

d={99:'数字','name':'字符串','(1,2)':'元组',[99]:'不能是列表'}
print(d)  # TypeError: unhashable type: 'list'

创建字典里的值

d = {'lulu': 100, 'lily': 99, 'Amy': 88}
print(d['lulu'])  # 100
#如果字典键不存在，则返回错误

l = ['宝宝', '憨憨', '小可爱', '宝宝', '饺子', '西瓜']
d = {}
for x in l:
    d[x] = ''
print(d)  # {'宝宝': '', '憨憨': '', '小可爱': '', '饺子': '', '西瓜': ''}
# 修改的键，若存在的则修改；不存在的则添加
print(list(d))  # ['宝宝', '憨憨', '小可爱', '饺子', '西瓜']  默认取字典里的键

实例：提取产品最后的记录

• 运用到dict()的"若存在的则修改"实现值为最新

import xlrd
from xlutils.copy import copy
wb=xlrd.open_workbook('获奖名单.xls')
ws=wb.sheet_by_name('统计表')
r=0
d={}
while r<ws.nrows-1:
    key=ws.cell_value(r,0)  # 注意：(0,0)即第1行第A列
    value=ws.cell_value(r,1)
    d[key]=value
    r+=1
print(d)

• 创建字典储存个人信息，并将信息打印出来

friend = {'name':'lulu','age':18,'city':'foshan'}
print('姓名：' + friend['name'])
print('年龄：' + str(friend['age']))   # 注意整数要换成字符串str()
print('城市：' + friend['city'])
'''
姓名：lulu
年龄：18
城市：foshan
'''

字典的转换

dict()

d1 = dict(a=1, b=2)  # 创建方法1
print(d1)  # {'a': 1, 'b': 2}
'''
((,),(,))  ([,],[,])  元组里面的元素可以是列表，可以是元组
[(,),(,)]  [[,],[,]]  列表里面的元素可以是列表，可以是元组
'''
d2 = dict((('a', 1), ('b', 2)))  # 创建方法2
print(d2)  # {'a': 1, 'b': 2}
d3 = dict((['a', 1], ['b', 2]))  # 创建方法3
print(d3)  # {'a': 1, 'b': 2}
d4 = dict([('a', 1), ('b', 2)])  # 创建方法4
print(d4)  # {'a': 1, 'b': 2}
d5 = dict([['a', 1], ['b', 2]])  # 创建方法5
print(d5)  # {'a': 1, 'b': 2}

d6 = dict(zip(['a', 'b', 'c'], [1, 2, 3]))    # 创建方法6
print(d6)  # {'a': 1, 'b': 2, 'c': 3}

zip()

k = ['a', 'b', 'c']
v = [1, 2, 3]
l = zip(k, v)
print(l)  # <zip object at 0x000001C2C4366108>
print(list(l))  # [('a', 1), ('b', 2), ('c', 3)]  将此结果代入下式，可得
print(dict(l))  # {}

print(dict(list(l)))  # {}
print(dict([('a', 1), ('b', 2), ('c', 3)]))  # {'a': 1, 'b': 2, 'c': 3}

l = [['a', 'b', 'c'], [1, 2, 3]]  #l的两个列表元素内的元素放一起的，则加 *
print(zip(*l))  # <zip object at 0x00000188FF8A6108>
print(dict(zip(*l)))  # {'a': 1, 'b': 2, 'c': 3}

dict.fromkeys()

dict.fromkeys(seq[, value])

• 以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

# fromkeys()可运用于去重
d=dict.fromkeys(['a','b','d','d','a','f'])
print(d)  # {'a': None, 'b': None, 'd': None, 'f': None}  

d0 = dict.fromkeys('a', 1)
print(d0)  # {'a': 1}
d1 = dict.fromkeys(('a', 'b'), 1)
print(d1)  # {'a': 1, 'b': 1}
d2 = dict.fromkeys(['a', 'b'], 1)
print(d2)  # {'a': 1, 'b': 1}
d3 = dict.fromkeys(['a', 'b'], [2, 3])
print(d3)  # {'a': [2, 3], 'b': [2, 3]}

实例：多列求唯一值
转换成元组，再循环字典，去重

import xlrd
import xlwt

wb = xlrd.open_workbook('业绩表.xls')
ws = wb.sheet_by_name('Sheet1')
nwb = xlwt.Workbook(encoding='')
nws = nwb.add_sheet('Sheet1')
l = [ws.col_values(0), ws.cell_values(1), ws.col_values(3)]
l1 = zip(*l)  # 转换成元组
d = dict.fromkeys(l1)  # 去重
r = 0
for k in d:  # 循环字典，默认循环键名称
    nws.write(r, 0, k[0])
    nws.write(r, 1, k[1])
    nws.write(r, 2, k[2])
    r += 1
nwb.save('结果表.xls')

字典的删除

clear

• clear() 函数用于删除字典内所有元素。

dict.clear()

d = {'name': '饺子', 'age': 28, 'salary': 9800}
d.clear()
print(d)  # {}

pop

• 删除字典给定键 key 及对应的值，返回值为被删除的值。key 值必须给出。 否则，返回 default 值。

d = {'name': '饺子', 'age': 28, 'salary': 9800}
d.pop('name')
print(d)  # {'age': 28, 'salary': 9800}

d = {'name': '饺子', 'age': 28, 'salary': 9800}
d.popitem()  # 随机删除一对，一般为最后一对
print(d)  # {'name': '饺子', 'age': 28}

del

d = {'name': '饺子', 'age': 28, 'salary': 9800}
del d['age']  # 删除一对key和对应值
print(d)  # {'name': '饺子', 'salary': 9800}
del d  # 全部清除
print(d)  # NameError: name 'd' is not defined

字典的修改

字典值的修改

d = {'name': '饺子', 'age': 28, 'salary': 9800}
d['name'] = '包子'  # 键存在，则修改
print(d)  # {'name': '包子', 'age': 28, 'salary': 9800}
d['drink'] = '奶茶'  # 键不存在，则添加
print(d)  # {'name': '包子', 'age': 28, 'salary': 9800, 'drink': '奶茶'}

字典键名的修改

d = {'name': '饺子', 'age': 28, 'salary': 9800}
# d['food'] = d['name']         # 打印：{'name': '饺子', 'age': 28, 'salary': 9800, 'food': '饺子'}  键不存在则增加
# d.pop('name')                 # 打印： {'age': 28, 'salary': 9800, 'food': '饺子'}  删除对应键和值
d['food']=d.pop('name')
print(d)                        # 打印： {'age': 28, 'salary': 9800, 'food': '饺子'}

字典的连接

update()

d1 = {'food': '饺子'}
d2 = {'drink': '奶茶'}
d1.update(d2)
print(d1)  # {'food': '饺子', 'drink': '奶茶'}

字典的查询

判断是否存在

• in dict.keys()判断指定键名是否在字典中存在

单值查询

d = {'food': '饺子', 'drink': '奶茶', 'favor': '海苔'}
print(d['food'])  # 饺子
print(d.get('food'))  # 饺子
print(d.get('food', 'none'))  # 饺子
print(d.get('foods'))  # None  不存在的，默认返回值
print(d.get('foods', '没有'))  # 没有    可以指定返回值

多值查询

d = {'food': '饺子', 'drink': '奶茶', 'favor': '海苔'}
print(d.keys())             # dict_keys(['food', 'drink', 'favor'])  返回字典的键
print(list(d.keys()))       # ['food', 'drink', 'favor']  转为列表
print(tuple(d.keys()))      # ('food', 'drink', 'favor')  转为元组
print('food' in d.keys())   # True  判断键是否存在
print('foot' in d.keys())   # False
print(d.values())           # dict_values(['饺子', '奶茶', '海苔'])  返回字典的值
print(list(d.values()))     # ['饺子', '奶茶', '海苔']
print(tuple(d.values()))    # ('饺子', '奶茶', '海苔')
print(d.items())            # dict_items([('food', '饺子'), ('drink', '奶茶'), ('favor', '海苔')])
print(list(d.items()))      # [('food', '饺子'), ('drink', '奶茶'), ('favor', '海苔')]
print(tuple(d.items()))     # (('food', '饺子'), ('drink', '奶茶'), ('favor', '海苔'))

字典的循环

普通循环

for ···in

d = {'food': '饺子', 'drink': '奶茶', 'favor': '海苔'}
for x in d:  # 默认提取键名
    print(x)
'''
food
drink
favor
'''
for x in d.keys():  # 提取键名
    print(x)
'''
food
drink
favor
'''
for x in d.values():  # 提取值
    print(x)
'''
饺子
奶茶
海苔
'''
for x in d.items():  # 提取成对键/值（元组）
    print(x)
'''
('food', '饺子')
('drink', '奶茶')
('favor', '海苔')
'''
for x, y in d.items():  # 提取分离的键/值
    print(x, y)

'''
food 饺子
drink 奶茶
favor 海苔
'''

案例：把员工号staff_id和对应体温temperature存入字典{}，打印出温度大于38的员工号

temperature_dict = {'111': 36.1, '222':38.4, '333':37.5, '444':39.1}

# 方法一：
for staff_id, temperature in temperature_dict.items():
    if temperature >= 38:
        print(staff_id)
'''
222
444
 for循环后面跟了两个变量，因为字典名.items()在for循环时，变量会被赋值为键和值组成的元组，
 这种写法相当于把元组的第一个元素赋值给staff_id，第二个元素赋值给temperature
'''
# 方法二：
for temperature_tuple in temperature_dict.items():
    staff_id = temperature_tuple[0]
    temperature = temperature_tuple[1]
    if temperature >= 38:
        print(staff_id)
'''
222
444
'''

字典在列表中的推导

d = {'food': '饺子', 'drink': '奶茶', 'favor': '海苔'}
print([x for x in d])                   # ['food', 'drink', 'favor']
print(tuple(x for x in d))              # ('food', 'drink', 'favor')  元组形式
print([x for x in d.keys()])            # ['food', 'drink', 'favor']
print([x for x in d.values()])          # ['饺子', '奶茶', '海苔']
print([[x, y] for x, y in d.items()])   # [['food', '饺子'], ['drink', '奶茶'], ['favor', '海苔']]

字典推导式

1. 对已经存在的字典重新推导

d = {'food': '饺子', 'drink': '奶茶', 'favor': '海苔'}
d1 = {y: x for x, y in d.items()}
print(d1)                        # {'饺子': 'food', '奶茶': 'drink', '海苔': 'favor'}
d2 = {x: y + '好吃' for x, y in d.items()}  
print(d2)                        # {'food': '饺子好吃', 'drink': '奶茶好吃', 'favor': '海苔好吃'}

2. 将其它结构的数据推导为字典

l1 = ['food', '饺子', 'drink', '奶茶']
l2 = [10, 90, 40, 33]
d = {x: y+1 for x, y in zip(l1, l2)}
print(d)    # {'food': 11, '饺子': 91, 'drink': 41, '奶茶': 34}