python 常用数据结构-字典

Dict 字典

字典定义与使用

• 字典常用方法
• 字典推导式
• 实例

字典定义

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

字典使用：创建

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

"""字典使用：创建"""
# 1、使用大括号填充键值对
dc = {'name': 'Harry Potter', 'age': 18}
print(type(dc), dc) # <class 'dict'> {'name': 'Harry Potter', 'age': 18}

# 2、使用字典构造方法
dc1 = dict()  # 空字典
dc2 = dict(name="Harry Potter", age=18)  # 关键字参数赋值
print(type(dc2), dc2) # <class 'dict'> {'name': 'Harry Potter', 'age': 18}
dc3 = dict([("name", "Harry Potter"), ("age", 18)])
print(type(dc3), dc3) # <class 'dict'> {'name': 'Harry Potter', 'age': 18}

# 3、使用字典推导式
dc4 = {k: v for k, v in [("name", "Harry Potter"), ("age", 18)]}
print(type(dc4), dc4) # <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
• 添加元素
  • 键不存在
• 修改元素
  • 键已经存在

"""字典使用：操作元素"""
dc1 = {"name": "Harry Potter", "age": 18}
# 1、修改年龄，改为20
dc1['age'] = 20
print(dc1) # {'name': 'Harry Potter', 'age': 20}

# 2、新增hobby字段
dc1['hobby']= 'Magic'
print(dc1) # {'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()
# 查询所有的keys（键）
print(type(keys), keys) # <class 'dict_keys'> dict_keys(['name', 'age'])

# 1、遍历查看所有的键
for key in keys:
    print(key) # name、age

# 2、将视图对象转成列表
print(list(keys)) # ['name', 'age']

字典方法 values()

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

"""字典方法 values()"""
dc1 = {"name": "Harry Potter", "age": 18}
values = dc1.values()
print(type(values), values) # <class 'dict_values'> dict_values(['Harry Potter', 18])

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

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

字典方法 items()

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

"""字典方法 items()"""
dc2 = {"name": "Harry Potter", "age": 18}
items = dc2.items()
print(type(items), items) # <class 'dict_items'> dict_items([('name', 'Harry Potter'), ('age', 18)])

# 1、遍历查看所有的项
for item in items:
    print(item) # ('name', 'Harry Potter')、('age', 18)

# 2、将视图对象转成列表
print(list(items)) # [('name', 'Harry Potter'), ('age', 18)]

字典方法 get()

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

"""字典方法 get()"""
dc3 = {"name": "Harry Potter", "age": 18}

# 1、访问存在的key
name = dc3['name']
print(name) # Harry Potter

# 2、访问不存在的key
hobby = dc3.get('hobby')
print(hobby) # None

字典方法 update()

• update(dict)

• 使用来自 dict 的键/值对更新字典，覆盖原有的键和值。

• 入参：

  • dc：字典对象，必传

• 返回：None

"""字典方法 update()"""
dc4 = {"name": "Harry Potter", "age": 18}
dc4.update({"age": 20, "hobby": "magic"})
print(dc4) # {'name': 'Harry Potter', 'age': 20, 'hobby': 'magic'}

字典方法 pop()

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

"""字典方法 pop()"""
dc5 = {"name": "Harry Potter", "age": 18}

# 1、弹出
item = dc5.pop("age")
print(dc5, item) # {'name': 'Harry Potter'} 18

# 2、删除不存在的key
dc.pop("hobby")  # KeyError: 'hobby'or

字典推导式

• 字典推导式：可以从任何以键值对作为元素的可迭代对象中构建出字典。
• 实例：给定一个字典对象{'a': 1, 'b': 2, 'c': 3}，找出其中所有大于 1 的键值对，同时 value 值进行平方运算。

# 实例：给定一个字典对象`{'a': 1, 'b': 2, 'c': 3}`，找出其中所有大于 1 的键值对，同时 value 值进行平方运算。
# 未使用字典推导式的写法
dc6 = {'a': 1, 'b': 2, 'c': 3}
d_old = dict()
for k, v in dc6.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 dc6.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'}
"""