python数据结构学习整理-字典

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

• 字典的使用-创建

1. 使用大括号填充键值对

# 1. 使用大括号填充键值对
dict1 = {"name": "xiaoming", "age": 18}
print(type(dict1), dict1)
# 空字典
dict2 = {}
print(type(dict2), dict2)

2. 使用字典构造方法

# 2. 使用字典构造方法
# 空字典
dict3 = dict()
print(type(dict3), dict3)
# 从一个元组列表中获取元素
dict4 = dict([("name", "xiaohong"), ("age", 18)])
print(type(dict4), dict4)

3. 使用字典推导式

# 3. 使用字典推导式
dict5 = {k:v for k ,v in [("name", "xiaolan"), ("age", 18)]}
print(type(dict5), dict5)

• 字典的使用-访问元素

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

"""字典使用：访问元素"""
dict6 = {"name": "xiaowang", "age": 17}
# 1. 访问存在的key
print(dict6["name"])
# 2. 访问不存在的key，会报KeyError错误
#print(dict6["hobby"])

 

• 字典的使用-操作元素

"""字典的使用-操作元素
- 语法： dict[key] = value
- 添加元素：
    - 键不存在
    - 键已经存在
"""

"""字典的使用：操作元素"""
dict7 = {"name": "xiaowang", "age": 22}
# 1. 修改年龄，改为25
dict7['age'] = 25
print(dict7)
# 2. 新增hobby字段
dict7['hobby'] = 'Sing'
print(dict7)

• 字典的使用-嵌套字典

"""字典的使用：嵌套字典
- 嵌套字典
- 字典的值可以是字典对象
"""

dict8 = {"name": "xiaowang", "age": 22, "course": {"math": 90, "python": 80}}
# 获取课程math的值
print(dict8['course']['math'])
# 修改python的分数为100
dict8['course']['python'] = 100
print(dict8)

• 字典方法-keys()、values()、items()

"""字典方法keys()
- keys()
- 返回由字典键组成的一个新视图对象
- 入参：无
- 返回
"""

"""字典方法values()
- values()
- 返回由字典值组成的一个新视图对象
"""

"""字典方法items()
- items()
- 返回由字典项（(键，值)对）组成的一个新视图对象
"""

"""keys(), values(), items()"""
dict9 = {"name": "xiaowang", "age": 22}
print(dict9.keys())
print(dict9.values())
print(dict9.items())

print("....将视图对象转成列表....")
print(list(dict9.keys()))
print(list(dict9.values()))
print(list(dict9.items()))

• 字典方法-get()

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

"""get()"""
dict10 = {"name": "xiaowang", "age": 22}
# 1. 访问存在的key
print(dict10.get('name'))
print(dict10.get('age'))

# 2. 访问不存在的key, 不报错，返回None
print(dict10.get('hobby'))

• 字典方法-update()

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

"""update()"""
dict11 = {"name": "xiaowang", "age": 22}
# 修改age的值和新增hobby字段
data = {"age": 27, "hobby": "Sing"}
dict11.update(data)
print(dict11)

• 字典方法-pop()

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

"""pop()"""
dict12 = {"name": "xiaowang", "age": 22}
# 1. 删除已存在的key,返回对应的value值
val = dict12.pop('name')
print(dict12,val)

# 2. 删除不存在的key, 引发KeyError
dict12.pop('hobby')

 

• 字典推导式

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

实例1-推导式创建字典

# 实例1-推导式创建字典
dict13 = {k:v for k, v in [("name", "xiaowang"), ("age", "19")]}
print(type(dict13),dict13)

实例2： 给定一个字典对象{'a': 1, 'b': 2, 'c': 3}找出其中所有大于1的键值对，同时value值进行平方运算

# 实例2： 给定一个字典对象{'a': 1, 'b': 2, 'c': 3}找出其中所有大于1的键值对，同时value值进行平方运算
# 未使用字典推导式的写法
dc = {'a': 1, 'b': 2, 'c': 3}
data = dict()
for k, v in dc.items():
    if v > 1:
        data[k] = v ** 2
print(data)

# 使用字典推导式
dc1 = {'a': 1, 'b': 2, 'c': 3}
data2 = {k: v ** 2 for k, v in dc1.items() if v > 1}
print(data2)

 

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

"""实例3
给定一个字典对象，请使用字典推导式，将它的key和value分别进行交换，也就是key变成值，值变成key
输入： {'a': 1, 'b': 2, 'c': 3}
输出： { 1: 'a', 2: 'b', 3: '3'}
"""
data_3 = {'a': 1, 'b': 2, 'c': 3}
result = {v: k for k, v in data_3.items()}
print(data_3)
print(result)