数据类型详解-字典

字典也是一种数据的集合，由键值对组成的数据集合，字典中的键不能重复

字典中的键必须是不可变的数据类型，常用的键主要是：字符串，整型。。。

字典的定义

  • 字典可以通过将以逗号分隔的 键: 值 对列表包含于花括号之内来创建字典
  • 也可以通过 dict 构造器来创建

{'jack': 4098, 'sjoerd': 4127} 或 {4098: 'jack', 4127: 'sjoerd'}

  1. # 1。 使用{}定义
  2. vardict = {'a':1,'b':2,'c':2}
  4. # 2。 使用 dict(key=value,key=value) 函数进行定义
  5. vardict = dict(name='zhangsan',sex='男',age=22)
  7. # 3。 数据类型的转换  dict(二级容器类型) 列表或元组，并且是二级容易才可以转换
  8. vardict = dict([['a',1],['b',2],['c',3]])  # {'a': 1, 'b': 2, 'c': 3}
  10. # 4。zip压缩函数，dict转类型
  11. var1 = [1,2,3,4]
  12. var2 = ['a','b','c','d']
  14. # 转换的原理和上面的第三种 是一个原理
  15. vardict = dict(zip(var1,var2))  # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
  16. print(vardict)

字典的操作

  1. var1 = {'a': 1, 'b': 2, 'c': 3}
  2. var2 = {1: 'a', 2: 'b', 3: 'c', 4: 'd'}
  4. # res = var1 +  var2 # XXXX  TypeError
  5. # res = var1 * 3 # xxxx TypeError
  7. # 获取元素
  8. res = var1['a']
  10. # 修改元素
  11. res = var1['a'] = 111
  13. # 删除元素
  14. del var1['a']
  16. # 添加元素
  17. var1['aa'] = 'AA'
  19. # 如果字典中的key重复了，会被覆盖
  20. # var1['aa'] = 'aa'

成员检测和获取

  1. # 三 成员检测和获取  ,只能检测key，不能检测value
  2. res = 'AA' in var1
  3. res = 'AA' not in var1
  5. # 获取当前字典的长度 只能检测当前又多少个键值对
  6. res = len(var1)
  8. # 获取当前字典中的所有 key 键
  9. res = var1.keys()
  10. # 获取字典中所有的 value 值
  11. res = var1.values()
  12. # 获取当前字典中所有 键值对
  13. res = var1.items()

字典的遍历

  1. # 四， 对字典进行遍历
  2. # （1）在遍历当前的字典时，只能获取当前的key
  3. for i in var1:
  4.     print(i) # 只能获取 key
  5.     print(var1[i]) # 通过字典的key获取对应value
  7. #（2）遍历字典时，使用 items() 函数，可以在遍历中获取key和value
  8. for k,v in var1.items():
  9.     print(k)  # 遍历时的 key
  10.     print(v)  # 遍历时的 value
  12. print('===='*20)
  13. # (3) 遍历字典的所有key
  14. for k in var1.keys():
  15.     print(k)
  17. print('===='*20)
  18. # (4) 遍历字典的所有 value
  19. for v in var1.values():
  20.     print(v)

字典的相关函数

  1. #  字典相关函数
  3. # len(字典) #获取字典的键值对个数
  4. # dict.keys() # 获取当前字典的所有key 键，组成的列表
  5. # dict.values() # 获取当前字典的所有 value 值，组成的列表
  6. # dict.items() # 返回由字典项 ((键, 值) 对) 组成的一个新视图
  7. # iter(d) 返回以字典的键为元素的迭代器。
  9. vardict = {'a':1,'b':2,'c':3}
  11. # dict.pop(key) # 通过 key 从当前字典中弹出键值对  删除
  12. # res = vardict.pop('a')
  14. # dict.popitem()   LIFO: Last in, First out.后进先出
  15. # res = vardict.popitem()  # 把最后加入到字典中的键值对删除并返回一个元组
  17. # 使用key获取字典中不存在元素，会报错
  18. # print(vardict['aa'])
  19. # 可以使用get获取一个元素，存在则返回，不存在默认返回None
  20. # res = vardict.get('aa')
  21. # res = vardict.get('aa','abc')
  23. # dict.update(),更新字典,如果key存在，则更新，对应的key不存在则添加
  24. # vardict.update(a=11,b=22)
  25. # vardict.update({'c':33,'d':44})
  27. # dict.setdefault(key[,default])
  28. # 如果字典存在键 key ，返回它的值。
  29. # 如果不存在，插入值为 default 的键 key ，并返回 default 。
  30. # default 默认为 None。
  31. res = vardict.setdefault('aa','123')
  32. print(res)
  33. print(vardict)

字典推导式

  2. # 把字典中的键值对位置进行交换 {'a':1,'b':2,'c':3}
  3. vardict = {'a':1,'b':2,'c':3}
  5. # 普通方法实现 字典中的键值交换  {1: 'a', 2: 'b', 3: 'c'}
  6. newdict = {}
  7. for k,v in vardict.items():
  8.     newdict[v] = k
  9. # print(newdict)
  11. # 使用字典推导式完成  {1: 'a', 2: 'b', 3: 'c'}
  12. newdict = {v:k for k,v in vardict.items()}
  13. # print(newdict)
  15. # 注意：以下推导式，返回的结果是一个集合，集合推导式
  16. # newdict = {v for k,v in vardict.items()}
  17. # print(newdict,type(newdict))
  20. # 把以下字典中的是偶数的值，保留下来，并且交换键值对的位置
  21. vardict = {'a':1,'b':2,'c':3,'d':4}
  23. # 普通方式完成  {2: 'b', 4: 'd'}
  24. # newdict = {}
  25. # for k,v in vardict.items():
  26. #     if v % 2 == 0:
  27. #         newdict[v] = k
  28. # print(newdict)
  30. # 字典推导式完成  {2: 'b', 4: 'd'}
  31. newdict = {v:k for k,v in vardict.items() if v % 2 == 0}
  32. # print(newdict)