python基础六

字典

1.以python内置的数据结构之一，与列表一样是一个可变序列
2.以键值对的方式存储数据，字典是一个无序的序列
scores = {‘张三’ : 100, ‘李四’ : 98, ‘王五’ : 45}
scores是字典名，{}是花括号
: 左边的值是键值（key），右边的值是值（value）
字典的存储，key值要先带入hash函数，计算值（位置）

规定

放在字典中的对，必须是不可变序列（否则字典内的值具有可变性）
列表和字典都是可变序列
（str）字符串是不可变序列

字典的实现原理

字典的实现原理与查字典类似，查字典是先根据部首或拼音查找汉字对应的页码，python中的字典是根据key查找value所在的位置

字典的创建

1.最常用的方式：使用花括号
scores = {‘张三’: 100, ‘李四’: 98, ‘王五’: 45}
2.使用内置函数dict()
dict{name = ‘jack’, age = 20}

# 第一种创建方式使用{}创建字典
scores = {'张三': 100, '李四': 98, '王五': 45}
print(scores)   # {'张三': 100, '李四': 98, '王五': 45}
print(type(scores))     # <class 'dict'>

# 第二种创建方式使用dict()函数
student = dict(name='jack', age=20)
print(student)  # {'name': 'jack', 'age': 20}

# 空字典
d = {}
print(d)    # {}

字典的常用操作

一.字典中元素的获取
1.[] -> 举例：scores[‘张三’]
2.get()方法 -> 举例：scores.get(‘张三’)
二.[]取值与使用get()取值的区别
1.[]如果字典中不存在指定的key，抛出keyError异常
2.get()方法取值，如果字典中不存在指定的key，并不会抛出KeyError而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回

# 获取字典的元素
scores = {'张三': 100, '李四': 98, '王五': 45}
# 第一种方法，使用[]
print(scores['张三'])     # 100
# print(scores['陈六'])     # KeyError: '陈六'

# 第二种方式，使用get()方法
print(scores.get('张三'))     # 100
print(scores.get('陈六'))     # None
print(scores.get('麻七', 99))     # 99是在查找'麻七'所对的value不存在时，提供的一个默认值

字典的常用操作

一.key的判断
1.in -> 指定的key在字典中存在返回True -> ‘张三’ in scores
2.not in -> 指定的key在字典中不存在返回True -> ‘Marry’ not in scores
二.字典元素的删除
del scores[‘张三’]
三.字典元素的新增
scores[‘jack’] = 90

# key的判断
scores = {'张三': 100, '李四': 98, '王五': 45}
print('张三' in scores)   # True
print('张三' not in scores)   # False

del scores['张三']    # 删除指定的key-value对
# scores.clear()    #清空字典的元素
print(scores)   # {'李四': 98, '王五': 45}
scores['陈六'] = 98   # 新增元素
print(scores)

scores['陈六'] = 100  # 修改元素
print(scores)

字典的常用操作

获取字典视图的三个方法
1.keys() -> 获取字典中所有key
2.values() -> 获取字典中所有value
3.items() -> 获取字典中所有key，value对

scores = {'张三': 100, '李四': 98, '王五': 45}
# 获取所有的key
keys = scores.keys()
print(keys)     # dict_keys(['张三', '李四', '王五'])
print(type(keys))   # <class 'dict_keys'>
print(list(keys))   # ['张三', '李四', '王五'] 将所有的key组成的视图转成列表

# 获取所有的value
values = scores.values()
print(values)   # dict_values([100, 98, 45])
print(type(values))     # <class 'dict_values'>
print(list(values))     # [100, 98, 45]

# 获取所有的key-value对
items = scores.items()
print(items)    # dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(type(items))  # <class 'dict_items'>
print(list(items))  # 元组（）[('张三', 100), ('李四', 98), ('王五', 45)] 转换之后的列表是由元组组成

字典的常用操作

字典元素的遍历
for item in scores
print(item)

scores = {'张三': 100, '李四': 98, '王五': 45}
# 字典元素的遍历
for item in scores:
    print(item, scores[item], scores.get(item))

字典的特点

1.字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
2.字典中的元素是无序的
3.字典中的key必须是不可变对象 # int 和 str
4.字典也可以根据需要动态地伸缩
5.字典会浪费较大的内存，是一种使用空间换时间的数据结构

d = {'name': '张三', 'name': '李四'}    # key不允许重复
print(d)    # {'name': '李四'}

d = {'name': '张三', 'nikename': '张三'}    # value可以重复
print(d)    # {'name': '张三', 'nikename': '张三'}

lst = [10, 20, 30]
lst.insert(1, 100)
print(lst)  # [10, 100, 20, 30]
# d = {lst: 100}
# print(d)    # TypeError: unhashable type: 'list'

字典生成式

items = [‘Fruits’, ‘Books’, ‘Others’]
prices = [96, 78, 85]

变为下面的情况

{‘FRUITS’: 96, ‘BOOKS’: 78, ‘OTHERS’: 85}

items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85, 100, 120]
d = {item.upper(): price for item, price in zip(items, prices)}
print(d)    # {'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85} 以短的为主

内置函数zip()

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表
d = {item.upper(): price for item, price in zip(items, prices)}
item.upper() 表示字典key的表达式
price 表示字典value的表达式
item 自定义表示key的变量
price 自定义表示value的变量
zip(items, prices) 可迭代对象