python 常用数据结构-字典

python 常用数据结构-字典

Dict 字典

• 字典定义与使用
• 字典常用方法
• 字典推导式
• 实例

字典定义

• 字典是无序的键值对集合
• 字典用大括号{}包围
• 每个键/值对之间用一个逗号分隔
• 各个键与值之间用一个冒号分隔
• 字典是动态的

字典使用：创建

• 创建字典
• 使用大括号填充键值对
• 通过构造方法 dict()
• 使用字典推导式

“”“字典使用：创建”“”
#1、使用大括号填充键值对
dc = {‘name’: ‘Harry Potter’, ‘age’: 18}
print(type(dc), dc)

#2、使用字典构造方法
dc1 = dict() # 空字典
dc2 = dict(name=“Harry Potter”, age=18) # 关键字参数赋值
print(type(dc2), dc2)
dc3 = dict([(“name”, “Harry Potter”), (“age”, 18)])
print(type(dc3), dc3)

#3、使用字典推导式
dc4 = {k: v for k, v in [(“name”, “Harry Potter”), (“age”, 18)]}
print(type(dc4), dc4)
输出结果为：
<class ‘dict’> {‘name’: ‘Harry Potter’, ‘age’: 18}
<class ‘dict’> {‘name’: ‘Harry Potter’, ‘age’: 18}
<class ‘dict’> {‘name’: ‘Harry Potter’, ‘age’: 18}
<class ‘dict’> {‘name’: ‘Harry Potter’, ‘age’: 18}

字典使用：访问元素

• 访问元素
• 与字典也支持中括号记法[key]。
• 字典使用键来访问其关联的值。
• 访问时对应的 key 必须要存在

“”“字典使用：访问元素”“”
dc = {“name”: “Harry Potter”, “age”: 18}
#1、访问存在的key
print(dc[“name”]) # 打印 Harry Potter
print(dc[“age”]) # 打印 18

#2、访问不存在的key，会报KeyError错误
print(dc[‘hobby’]) # 打印报错 KeyError: ‘hobby’

字典使用：操作元素

• 语法：dict[key] = value
• 添加元素
• 键不存在
• 修改元素
• 键已经存在

“”“字典使用：操作元素”“”
dc = {“name”: “Harry Potter”, “age”: 18}
#1、修改年龄，改为20
dc[‘age’] = 20
print(dc) # 打印 {‘name’: ‘Harry Potter’, ‘age’: 20}

#2、新增hobby字段
dc[‘hobby’] = ‘Magic’
print(dc) # 打印 {‘name’: ‘Harry Potter’, ‘age’: 20, ‘hobby’: ‘Magic’}

字典使用：嵌套字典

• 嵌套字典
• 字典的值可以是字典对象

“”“字典使用：嵌套字典”“”
dc = {“name”: “Harry Potter”, “age”: 18, “course”: {“magic”: 90, “python”: 80}}
#1、获取课程Magic的值
print(dc[‘course’][‘magic’]) # 打印 90

#2、把python分数改成100分
dc[‘course’][‘python’] = 100
print(dc) # 打印 {‘name’: ‘Harry Potter’, ‘age’: 18, ‘course’: {‘magic’: 90, ‘python’: 100}}

字典方法

• keys()
• values()
• items()
• get()
• update()
• pop()

字典方法 keys()

• keys()
• 返回由字典键组成的一个新视图对象。
• 入参：无

“”“字典方法 keys()”“”
dc = {“name”: “Harry Potter”, “age”: 18}
keys = dc.keys()
print(type(keys), keys)
print(dc.values())

#1、遍历查看所有的键
for key in keys:
print(key)
#2、将视图对象转成列表
print(list(keys))
print(list(dc.values()))
输出结果为：
<class ‘dict_keys’> dict_keys([‘name’, ‘age’])
dict_values([‘Harry Potter’, 18])
name
age
[‘name’, ‘age’]
[‘Harry Potter’, 18]

字典方法 values()

• values()
• 返回由字典值组成的一个新视图对象。

“”“字典方法 values()”“”
dc = {“name”: “Harry Potter”, “age”: 18}
values = dc.values()
print(type(values), values) # 打印 <class ‘dict_values’> dict_values([‘Harry Potter’, 18])

#1、遍历查看所有的值
for value in values: # 打印 Harry Potter
print(value) # 18

#2、将视图对象转成列表
print(list(values)) # 打印 [‘Harry Potter’, 18]

字典方法 items()

• items()
• 返回由字典项 ((键, 值) 对) 组成的一个新视图对象。

“”“字典方法 items()”“”
dc = {“name”: “Harry Potter”, “age”: 18}
items = dc.items()
print(type(items), items)

#1、遍历查看所有的项
for item in items:
print(item)

#2、将视图对象转成列表
print(list(items))
输出结果为：
<class ‘dict_items’> dict_items([(‘name’, ‘Harry Potter’), (‘age’, 18)])
(‘name’, ‘Harry Potter’)
(‘age’, 18)
[(‘name’, ‘Harry Potter’), (‘age’, 18)]

字典方法 get()

• get(key)
• 获取指定 key 关联的 value 值。
• 入参：
• key： 字典的键，必传。
• 返回：
• 如果 key 存在于字典中，返回 key 关联的 value 值。
• 如果 key 不存在，则返回 None。
• 此方法的好处是无需担心 key 是否存在，永远都不会引发 KeyError 错误。

“”“字典方法 get()”“”
dc = {“name”: “Harry Potter”, “age”: 18}

#1、访问存在的key
name = dc[‘name’]
print(name) # 打印 Harry Potter

#2、访问不存在的key
hobby = dc.get(‘hobby’)
print(hobby) # 打印 None

字典方法 update()

• update(dict)
• 使用来自 dict 的键/值对更新字典，覆盖原有的键和值。
• 入参：
• dc：字典对象，必传
• 返回：None

dc = {“name”: “Harry Potter”, “age”: 18}
dc.update({“age”: 20, “hobby”: “magic”})
print(dc) # 打印 {‘name’: ‘Harry Potter’, ‘age’: 20, ‘hobby’: ‘magic’}

字典方法 pop()

• pop(key)
• 删除指定 key 的键值对，并返回对应 value 值。
• 入参：
• key：必传
• 返回：
• 如果 key 存在于字典中，则将其移除并返回 value 值
• 如果 key 不存在于字典中，则会引发 KeyError 。

“”“字典方法 pop()”“”
dc = {“name”: “Harry Potter”, “age”: 18}

#1、弹出
item = dc.pop(“age”)
print(dc, item) # 打印 {‘name’: ‘Harry Potter’} 18

#2、删除不存在的key
#dc.pop(“hobby”) # 报错KeyError: ‘hobby’

字典推导式

• 字典推导式：可以从任何以键值对作为元素的可迭代对象中构建出字典 。

实例1：
dc11 = {k:v for k,v in [(“name”,“yu”),(“age”,18)]}
print(type(dc11),dc11) # 打印 <class ‘dict’> {‘name’: ‘yu’, ‘age’: 18}

实例2：
{‘a’: 1, ‘b’: 2, ‘c’: 3}，找出其中所有大于 1 的键值对，同时 value 值进行平方运算。
#未使用字典推导式的写法
dc = {‘a’: 1, ‘b’: 2, ‘c’: 3}
d_old = dict() # 空字典
for k, v in dc.items(): # 遍历键值对
if v > 1:
d_old[k] = v ** 2 # 键值对应的值=原值的平方
print(d_old) # 打印 {‘b’: 4, ‘c’: 9}

#使用字典推导式
d_new = {k : v ** 2 for k,v in dc.items() if v > 1 }
print(d_new) # 打印 {‘b’: 4, ‘c’: 9}

实例

“”"
给定一个字典对象，请使用字典推导式，将它的key和value分别进行交换。也就是key变成值，值变成key。
输入: {‘a’: 1, ‘b’: 2, ‘c’: 3}
输出: {1: ‘a’, 2: ‘b’, 3: ‘c’}
“”"

old = {‘a’: 1, ‘b’: 2, ‘c’: 3}
print(type(old),old) # 打印 <class ‘dict’> {‘a’: 1, ‘b’: 2, ‘c’: 3}

new = {v:k for k,v in old.items()}
print(type(new),new) # 打印 <class ‘dict’> {1: ‘a’, 2: ‘b’, 3: ‘c’}