Python字典的常用方法总结

1.字典介绍

①字典是另一种可变容器模型，且可存储任意类型对象（值存储），如字符串、数字、元组……  

②字典的每个键值 key--value 对用冒号 : 分割；每个键值对之间用逗号 , 分割；整个字典包括在花括号 {} 中。

③字典中的键一般是唯一的，值不需要唯一；如果键重复那么最后的一个键值对会替换前面的。

④字典优点：取值方便，速度快

dict = {'a': 1, 'b': 2, 'b': '3'}
>>> dict['b']
'3'

>>> dict
{'a': 1, 'b': '3'}

2.创建字典

1、创建空字典

dic = {}

dic = dict()

type (dic)
#output:<type 'dict'>

2、直接赋值创建字典

dic = {'aaa':1, 'bbb':2, 'ccc':3}

3、通过 dict() 函数将二元数组列表创建为字典

list = [('aaa', 1), ('bbb', 2), ('ccc', 3)]
dic = dict(list)

#  :{'aaa': 1, 'bbb': 2, 'ccc': 3}  #可以通过 list(dic.items())得到上面的list

4、通过 dict() 函数和关键字参数（指的等式例如： spam = 1 ）创建包含指定键值对的字典

list = dict(aaa=1, bbb=2, ccc=3)

#output:{'aaa': 1, 'bbb': 2, 'ccc': 3}

5、 dict() 函数和 zip() 函数相结合创建字典；【注意】但是这两个函数组合使用的硬性要求： zip() 函数的入参可迭代对象必须为两个，不可少于两个或者多于两个入参对象

dic = dict(zip('abc', [1, 2, 3]))

#output:{'a': 1, 'c': 3, 'b': 2}

print(dict(zip((1, 2, 3), ('a', 'b', 'c'))))  # {1: 'a', 2: 'b', 3: 'c'}

print(zip((1, 2, 3), ('a', 'b', 'c'), ('e', 'f', 'g')))  # <zip object at 0x0000028F7F64F840>

print(list(zip((1, 2, 3, 4), ('a', 'b', 'c', 'd'), ('e', 'f', 'g', 'f'))))  # [(1, 'a', 'e'), (2, 'b', 'f'), (3, 'c', 'g'), (4, 'd', 'f')]

print(dict(zip((1, 2, 3, 4), ('a', 'b', 'c', 'd'), ('e', 'f', 'g', 'f'))))
# Traceback (most recent call last):
#   File "C:\Users\liangshu.hu\PycharmProjects\practice\2.py", line 7, in <module>
#     print(dict(zip((1, 2, 3, 4), ('a', 'b', 'c', 'd'), ('e', 'f', 'g', 'f'))))
# ValueError: dictionary update sequence element #0 has length 3; 2 is required

【注意】 zip()函数用于将可迭代的对象作为参数(此时zip函数单独使用，所以此时的函数入参必须大于或等于1个)，将所有入参对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

#  zip函数只有一个入参的实例

print(zip((1, 2, 3, 'a', 'b')))  # <zip object at 0x0000017AE7FC1A00>

print(list(zip((1, 2, 3, 'a', 'b'))))  # [(1,), (2,), (3,), ('a',), ('b',)]

例如：

a = [1,2,3]

b = [4,5,6]

zipped = zip(a,b)

[(1,  4), (2, 5), (3, 6)]

可迭代的对象：Python中可迭代对象(Iterable)并不是指某种具体的数据类型，它是指存储了元素的容器对象，且容器中的元素可以通过__iter__( )方法或__getitem__( )方法访问。

①__iter__方法的作用是让对象可以用for … in循环遍历，getitem()方法是让对象可以通过“实例名[index]”的方式访问实例中的元素。这两个方法的目的是Python实现一个通用的外部可以访问可迭代对象内部数据的接口。

②一个可迭代对象是不能独立进行迭代的，Python中，迭代是通过for … in来完成的。凡是可迭代对象都可以直接用for… in…循环访问，这个语句其实做了两件事：第一件事是调用__iter__()获得一个可迭代器，第二件事是循环调用__next__()。

常见的可迭代对象包括：
a) 集合数据类型，如list、tuple、dict、set、str等；
b) 生成器(generator)，包括生成器和带yield的生成器函数(generator function)，下节专门介绍。

如何判断一个对象是可迭代对象呢？可以通过 collections 模块的 Iterable 类型判断，具体判断方法如下：

from collections import Iterable #导入Iterable 模块

isinstance(变量, Iterable) #判断一个变量是否为可迭代对象返回True表明是可迭代对象

6、通过字典推导式创建

dic = {i:2*i for i in range(3)}
#output: {0: 0, 1: 2, 2: 4}

7，通过 dict.fromkeys()创建，通常用来初始化字典；该创建方式会设置value的默认值（key没有默认值，value有默认值）

dic = dict.fromkeys(range(3), 'x')

#dic = {0: 'x', 1: 'x', 2: 'x'}

2.访问字典中的值

1.如果写了不存在的值会报错：

print(d['key']) 

2.如果写了不存在的值，返回None；该方式取字典值的优点：取值速度快，性能好

print(d.get('key'))

3.如果找不到存在的值，返回 “not find”；【注意】此种字典取值方式如果获取不到key对应的value，则会返回一个固定的值，这个固定的值可以在代码中体现出来

print(d.get('key','not find')) 

4.获取所有的key 值，返回一个包含字典所有value值的列表的视图对象

Python 字典 key() 方法以列表形式（并非直接的列表，若要返回列表值还需调用list函数）返回字典中的所有key值

print(d.keys()) 

print(list(d.keys())) #  以列表方式返回字典中的所有key值
print(tuple(d.keys())) #  以元组方式返回字典中的所有key值

5.获取所有的value 值，返回一个包含字典所有value值的列表的视图对象
Python 字典 values() 方法以列表形式（并非直接的列表，若要返回列表值还需调用list函数）返回字典中的所有value值

print(d.values()) 

print(list(d.values())) #  以列表方式返回字典中的所有value值
print(tuple(d.values())) #  以元组方式返回字典中的所有value值

6.判断key是否存在；【注意】：不能判断一个字典是否是另一个字典的子字典（即不能类比字符串）

if 'key' in d:   
  print('key')

7. 遍历字典①
print(d.items()) #Python 字典items() 函数以列表方式返回可遍历的(键, 值) 元组数组。

print(list(d.items())) #  以列表方式返回字典中的所有key值和value值，
print(tuple(d.items())) #  以元组方式返回字典中的所有key值和value值


for k,v in d.items():
    print(k,v)

8.遍历字典②
无须使用items()函数将字典转换成list格式，此种方式遍历字典会保留了字典原有的特性。

for k in dict:
    print(k,dict[k])
    print(k,dict.get(k))   取值速度快，性能好

示例：
dic = {'a': 1, 'b': 2, 3: 'c'}
for key in dic:
    print(key, dic[key])

# 输出：
# a 1
# b 2
# 3 c

3.修改字典

d['key'] = value #  key存在即修改，key不存在即新增

d.setdefault('key',value)   #  只能在原有字典上新增一个新的键值对

d.update({k1: value1, k2: value2})  #  k1或者k2不存在则新增，存在则新增

4.删除字典元素

d.pop('key')  必须要传对应key值，因为字典是无序的；并返回被删除的key对应的value

# 实例

dct = {1: 'a', 2: 'b', 3: 'c'}
a = dct.pop(1)
print(a)  # a
print(dct)  # {2: 'b', 3: 'c'}

d.popitem()   在字典中随机删除一个键值对；返回随机删除的一组键值对，以元组的数据类型返回；如果字典已经为空，却调用了此方法，就报出KeyError异常。

# 实例

dct = {1: 'a', 2: 'b', 3: 'c'}
a = dct.popitem()

print(a)  # (3, 'c')
print(dct)  # {1: 'a', 2: 'b'}

del d['key']  python回收机制回收字典中的元素对象

d.clear()     清空整个字典

5.注意

print(dict.items())   输出一个list格式（非真正意义上的list）

print(list(dict.items()))  把字典的key 和 value转成一个多维list【列表中嵌套元组】

len(dict)：计算字典元素个数，即键的总数。

str(dict)：输出字典可打印的字符串。

type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。

字典键的特性

字典值可以没有限制地是任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1、不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'} 
print ("dict['Name']: ", dict['Name'])

以上实例输出结果：
dict['Name']:  Manni

2、键必须不可变，所以可以用数字，字符串或元组充当，但是列表不能成为字典的键，如下实例：

dict = {['Name']: 'Zara', 'Age': 7} 
print "dict['Name']: ", dict['Name']

以上实例输出结果：
Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Zara', 'Age': 7} 
TypeError: list objects are unhashable

字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述
1	cmp(dict1, dict2) 比较两个字典元素。
2	len(dict) 计算字典元素个数，即键的总数。
3	str(dict) 输出字典可打印的字符串表示。
4	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置方法：

序号	函数及描述
1	dict.clear() 删除字典内所有元素
2	dict.copy() 返回一个字典的浅复制
3	dict.fromkeys(seq[, val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4	dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5	dict.has_key(key) 如果键在字典dict里返回true，否则返回false
6	dict.items() 以列表返回可遍历的(键, 值) 元组数组
7	dict.keys() 以列表返回一个字典所有的键
8	dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2) 把字典dict2的键/值对更新到dict里
10	dict.values() 以列表返回字典中的所有值
11	pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12	popitem() 返回并删除字典中的最后一对键和值。