python基础——数据类型(七)字典

如有兴趣了解更多请关注我的个人博客https://07xiaohei.com/

（一）概述：

字典（dictionary）是python语言中唯一的标准映射类型，是python中除了列表以外最灵活的数据类型。

字典是一种无序的、可变的序列，元素以"键值对"的形式进行存储，是可变的容器，容量是无限的。

字典的键值是hashable值，即所有不可变类型的值（基于对象标识而非值进行比较的对象），可变类型不能用作键，且键值一定是唯一的，不能出现多次，否则只会保留最后出现的一个键值对。

注意：数字类型用作键时遵循数字比较的一般原则：即两个近似数值相等的值会被用来作为一个键值索引同一条字典条目。（因此不建议把浮点数作为字典的键）

字典的值可以是任何数据类型，并无太多要求。（可以是标准的对象，也可以是用户定义的类型对象）

同一字典的不同键值对的键和值的类型均可以不同。（不过一般都是放同类型的数据）

（二）创建与形式：

python中用{}来主要表示字典，但对元素格式有要求，否则会被认为是集合。（但空的{}表示的是空字典）

形式为：字典名= {键1:值1 , 键2:值2 , 键三:值3 , … , 键n:值n }

键对应key，值对应value，keyk : valuek表示第k个键值对，作为一个元素item存在。

" : “用于分割键对和值对，” , "用于分割元素，均放在{}中。

除了通过赋值的形式用{}直接创建字典外，还可以dict.fromkeys方法创建字典。（dict是python内置的字典类型关键字）

形式为：dictname = dict.fromkeys(list，value=None)

dictname是方法的返回值所付赋给的变量名。

list参数是要创建的字典中所有的键组成的列表。

value参数是要创建的字典的元素的值的默认值，所有元素的值均为此默认值，不写时默认为空值None。

其他创建主要是通过关键字dict来进行创建：

1. dictname=dict()：也是空字典
2. dictname=dict(key1=value1 , key2=value2 , … , keyn= valuen)，通过dict和其参数创建字典，会将=换为:，另外，key1作为字符串时在此处不能加""或者’'。
3. dictname=dict(listname)，通过列表创建字典，但要求列表的元素是有两个元素的元组。
4. dictname=dict(zip(listname1,listname2))，通过关键字dict和zip创建字典，参数是两个列表，第一个列表内的元素是键，第二个列表内的元素是值，生成的字典元素个数为两个列表中较短的一个。

a1 = {}
a3 = {'a':1,'b':2,'c':3}
a4 = dict.fromkeys(['aa','bb','cc','dd'])
a5 = dict.fromkeys(['aa','bb','cc','dd'],"okok")
a2 = dict()
a6 = dict(a=1,b=2,c=3)
a7 = dict([("a",1),("b",2),("c",3),("d",4)])
a8 = dict(zip(["a","b","c","d"],[1,2,3,4]))
print(a1,a2,a3,a4,a5,a6,a7,a8,sep='\n')
# 运行结果：
# {}
# {}
# {'a': 1, 'b': 2, 'c': 3}
# {'aa': None, 'bb': None, 'cc': None, 'dd': None}
# {'aa': 'okok', 'bb': 'okok', 'cc': 'okok', 'dd': 'okok'}
# {'a': 1, 'b': 2, 'c': 3}
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}

（三）字典的特性：

1. 访问：

• 通过键(key)访问值(value)：

  形式：dictname[key]

  键是必须存在的，否则会抛出异常。

• 通过get方法访问指定键(key)对应的值：

  形式：dictname.get(key,default)

  key参数是指定的键，不存在时不会抛出异常。

  default参数是指查询的键不存在时，返回的默认值，不手动指定会返回None。

• 通过setdefault方法访问指定键(key)对应的值：

  形式：dictname.setdefault(key,default)

  和get形式功能类似，但是唯一的区别是如果键不存在于字典中，会添加该键并将值设置为default。

a = {'a':1,'b':2,'c':3,'d':4,'e':5}
print(a['a'])
# print(a['f']) 此句会执行失败
print(a.get('b',"不存在"))
print(a.get('f',"不存在"))
print(a.setdefault('c',"不存在"))
print(a)
print(a.setdefault('f',"不存在"))
print(a)
# 运行结果：
# 1
# 2
# 不存在
# 3
# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# 不存在
# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': '不存在'}

2. 删除：

python自带垃圾回收机制，已创建的字典如不再使用，将会被编译器自动回收，不会产生内存垃圾。

如果需要可以手动删除，使用del 关键字手动删除字典。

形式为： del dictname

a = {'a':1,'b':2,'c':3,'d':4,'e':5}
del a
print(a) #此句无法输出，因为a已经被删除了，a变量处于未定义状态

3. 多维字典：

python中允许创建多维字典，将其他字典当做字典的元素放在一个列表当中，也就是字典的嵌套。

要注意的是，在手动创建时，如果直接使用类似 dictionary[‘a’][‘b’][‘c’]=1的格式时，必须保证已经在键值a中创建了键值b，这样才能进行键值对的赋予——也就是多维的键值对创建时必须保证前面的键已经存在。

可以通过函数化简创建形式（此处略），否则只能一步步创建。

a = {'a':1,'b':2,'c':3,'d':4,'e':5}
a['f']=6  #正确
# a['a']['b']=1 错误，不能直接创建
a['a']={'bb':1}
a.update({'b':{'cc':7}}) #需要这样创建
print(a)
# 运行结果：
# {'a': {'bb': 1}, 'b': {'cc': 7}, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

4. 字典的主要操作：

• 添加和查询键值对：

  python中是不能修改字典的键的名字的，只能够修改值。添加只能添加和之前的键均不同的键。

  1. 直接给key赋值即可，如果不存在键值python会自动生成新的键值对，如果有相同的键则将其值覆盖原有的值。

     形式：dictname[key] = value

  2. 使用update方法：

     形式：dictname1.update(dictname2)

     可以将dictname2的键值对更新到dictname1，如果被更新的字典已经包含对应的键值对（实际上就是相同的键），那么原有的键值对会被覆盖，如果不包含则添加该键值对。

  a = {'a':1,'b':2,'c':3,'d':4,'e':5}
  a['c']=33
  a['f']=6
  a.update({'a':111})
  a.update({'g':7})
  print(a)
  # 运行结果：
  # {'a': 111, 'b': 2, 'c': 33, 'd': 4, 'e': 5, 'f': 6, 'g': 7}
  

• 删除键值对：

  1. 用del语句删除：

     形式：del dictname[key]

     将key对应的键值对删除，不能删除不存在的键，否则会报错。

  2. 用popitem方法删除：

     形式：dictname.popitem()

     返回并删除字典中最后一组的键值对（也就是你输出或者定义的最后一个），返回类型为元组。

  3. 用pop方法删除：

     形式：dictname.pop(key)

     删除指定键对应的键值对并返回值，返回类型根据值决定，不能删除不存在的键，否则会报错。

  4. 用clear删除全部删除：

     形式：dictname.clear()

     清除全部元素成为空字典。

  a = {'a':1,'b':2,'c':3,'d':4,'e':5}
  b = {'a':1,'b':2,'c':3,'d':4,'e':5}
  c = {'a':1,'b':2,'c':3,'d':4,'e':5}
  a.clear()
  x = b.popitem()
  del c['b']
  y = c.pop('a')
  print(a)
  print(b)
  print(c)
  print(x)
  print(y)
  # 运行结果：
  # {}
  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
  # {'c': 3, 'd': 4, 'e': 5}
  # ('e', 5)
  # 1
  

• 查询键值对：

  1. 判断某个键值对是否存在：

     使用 in 和 not in来查询是否包括指定键对应的键值对（也就是基于key来判断）。

     形式略（见代码）。

     如果是python2.x版本也可以使用has_key方法：

     形式：dictname.has_key(key)

     若有这个键返会True，否则返回False。（我是3.x，不做演示了）

  2. 查询全部键值对：

     使用方法items()

     形式：dictname.items()

     返回全部的键值对，以列表形式返回，每个元素均为元组的键,值对元组。

  3. 查询全部键：

     使用方法keys()

     形式：dictname.keys()

     返回全部的键，以列表形式。

  4. 查询全部值：

     使用方法values()

     形式：dictname.values()

     返回全部的值，以列表类型。

  a = {'a':1,'b':2,'c':3,'d':4,'e':5,6:'f'}
  print('b' in a)
  print('c' not in a)
  print(a.items())
  print(a.keys())
  print(a.values())
  # 运行结果:
  # True
  # False
  # dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), (6, 'f')])
  # dict_keys(['a', 'b', 'c', 'd', 'e', 6])
  # dict_values([1, 2, 3, 4, 5, 'f'])
  

5. 字典的其他操作：

比较经典的内容，如len()求长度，max()求最大值，min()求最小值，sorted排序等等，前面已经讲解过，不再重复，但是要注意：所有的操作是对键的操作，比如排序排的是键，不考虑值。

字典同样设计浅拷贝和深拷贝，区别和方法和列表类似，也不再重复。

此处唯一要讲的是字典的生成式：

格式：dictname1 = { x:y for x,y in dictname2.items() }

x对应键，y对应值，遍历时获得两者组合成一个元素。

只对x遍历是键遍历，y是值遍历。

也可以对keys和values分别遍历得到键和值。

a = {'a':1,'b':2,'c':3,'d':4,'e':5}
b = {x for x,y in a.items()}
bb = {x for x in a.keys()}
c = {x:y for x,y in a.items()}
d = {y for x,y in a.items()}
dd = {y for y in a.values()}
print(b)
print(bb)
print(c)
print(d)
print(dd)
# 运行结果：
# {'b', 'e', 'c', 'a', 'd'}
# {'b', 'e', 'c', 'a', 'd'}
# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# {1, 2, 3, 4, 5}
# {1, 2, 3, 4, 5}