Python基础（字典）

什么是字典

• Python内置的数据结构之一，与列表一样是一个可变序列
• 以键值对的方式存储数据，字典是一个无序的序列

scores={'张三':100,'李四':98,'王五':45}

字典名：scores

‘张三’ 键 ； 100 值

第一个放进字典的键不一定是放在第一个位置，位置是通过hash值来决定的

理解什么是不可变序列和可变序列

举例子：不可变序列：整数 和字符串

可变序列：目前学的：列表和字典

字典的实现原理

• 字典的实现原理与查字典类似，查字典是先根据不受或者拼音查找相应的页码，Python中的字典是根据key查找value所在的位置

字典的创建

• 最常见的方式：使用花括号

  • '''
    使用{}创建字典
    '''
    scores={'张三':100,'李四':98}
    print(scores)
    print(type(scores))
    

  • 输出：

  • {'张三': 100, '李四': 98}
    <class 'dict'>
    

• 第二种方式： dict()

  • '''
    第二种方式dict()
    '''
    student= dict(name='jack',age=20)
    print(student)
    print(type(student))
    

    输出：

    {'name': 'jack', 'age': 20}
    <class 'dict'>
    

字典的常见操作

字典元素的获取

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

输出：

-----------获取字典的元素----------
100
    print(scores['陈六'])
KeyError: '陈六'

第二种：

'''第二种方式'''
print(scores.get('张三'))
print(scores.get('陈六')) #None 这种不会报错
print(scores.get('麻七',99))  #99是获取不到时的替代品

输出：

100
None
99

字典元素的增删改查

key的判断

​ key的判断：

• in 指定的key在字典里存在返回True -> ‘张三’ in scores
• not in 指定的key在字典中不存在返回True -> ‘Marry’ not in scores

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

输出：

-----key的判断----
True
False

字典元素的删除

• del scores[‘张三’]

del scores['张三'] #删除指定的key-value 对
print(scores)

输出：

{'李四': 98, '王五': 45}

张三没了

字典的晴空

scores.clear()

print('-----字典的清空----')
print(scores)
scores.clear()
print(scores)

输出：

-----字典的清空----
{'李四': 98, '王五': 45, '陈六': 112}
{}

字典元素的新增

• scores[‘Jack’]=90

print(scores)
scores['陈六'] = 115
print(scores)

输出：

{'李四': 98, '王五': 45}
{'李四': 98, '王五': 45, '陈六': 115}

字典元素的修改

scores[‘陈六’]=112

print('----修改元素----')
print(scores)
scores['陈六']=112
print(scores)

输出：

----修改元素----
{'李四': 98, '王五': 45, '陈六': 115}
{'李四': 98, '王五': 45, '陈六': 112}

获取字典视图的三个方法

获取字典视图

• keys() 获取字典中所有key

  print('----字典的视图操作----')
  scores={'张三':100,'李四':99,'王五':88}
  #获取所有的key
  keys=scores.keys()
  print(keys)
  print(type(keys))
  aa= list(keys) #将所有keys组成的视图转换成列表并赋值给aa
  print(type(aa))
  print(aa)
  

  输出:

  ----字典的视图操作----
  dict_keys(['张三', '李四', '王五'])
  <class 'dict_keys'>
  <class 'list'>
  ['张三', '李四', '王五']
  

• values() 获取字典中的所有value

  print('----获取字典的所有value----')
  values= scores.values()
  print(values)
  print(type(values))
  print(list(values))
  

  输出：

  ----获取字典的所有value----
  dict_values([100, 99, 88])
  <class 'dict_values'>
  [100, 99, 88]
  

• items() 获取子弹中所有的key,value对

  print('----获取所有的key-value对')
  items=scores.items()
  print(items)
  print(list(items))  #转换之后列表元素是由元祖组成
  

  输出：

  ----获取所有的key-value对
  dict_items([('张三', 100), ('李四', 99), ('王五', 88)])
  [('张三', 100), ('李四', 99), ('王五', 88)]
  

​

字典元素的遍历

for item in scores:

​ print(item)

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

输出：

----字典元素的遍历----
张三 100 100
李四 99 99
王五 88 88

字典的特点

• 字典中的所有严肃都是一个key-value对，key 不允许重复，value可以重复

  print('----字典的特点----')
  d={'name':'张三','name':'李四'}
  print(d)
  

  输出：

  ----字典的特点----
  {'name': '李四'}
  

• d={'name':'lisi','bigname':'lisi'}
  print(d)
  

  输出：

  {'name': 'lisi', 'bigname': 'lisi'}
  

  证明value可以重复

• 字典中的元素是无序的

  靠hash值决定位置

• 字典中的键必须是不可变对象

  • lst=[10,20,30]
    d1={lst:100}
    print(d1)
    

    报错：

        d1={lst:100}
    TypeError: unhashable type: 'list'
    

  因为这个lst是可变对象，不允许计算hash值

• 字典也可以根据需要动态地伸缩

  • 使用之前不需要分配多大空间，会根据大小自动分配空间

• 字典会浪费较大的内存，是一种使用空间换时间的数据结构

  • 一开始就有一定大小，刚开始不满的时候，有很多空的地方

字典的生成式

内置函数zip()

• 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元祖，返回返回由这些元祖组成的列表

  print('----字典生成式----')
  items=['Fruits','Books','Others']
  prices=[96,98,88]
  
  d = {item:price  for item,price in zip(items,prices)}
  print(d)
  

  输出：

  ----字典生成式----
  {'Fruits': 96, 'Books': 98, 'Others': 88}
  

  其实就是一个列表的元素做键，一个列表的元素做值，并且是按照顺序来