Python之字典操作

字典类型的容器在编程中的重要性不再言谈，通过现有典型互联网企业及传统企业专门部署redis集群服务器可知字典的编程、业务应用方面的重要性。

字典定义及初始化

字典是非线性结构容器
字典的key-value键值对的数据集合
字典是可变的，无须的，key不重复
字典的key值必须可hash

d1 = dict()
d2 = dict(a=1,b=2)
d3 = {'a':1,'b':2}
d4 = dict(([1,'a'],[2,'b']))
d5 = dict.fromkeys(range(5),0)

{0: 0, 1: 0, 2: 0, 3: 0, 4: 0}

字典元素的访问

d[key]

返回key对应的值value
key不存在抛出KeyError异常

d = dict(a=1,b=2)
d['a']
# d['c']   # KeyError

1

get(key[, default])

返回key对应的值value
key不存在返回缺省值，如果没有设置缺省值就返回None

d = dict(a=1,b=2)
d.get('a',0)
d.get('c',0)
print(d)

{'a': 1, 'b': 2}

setdefault(key[, default])

返回key对应的值value
key不存在，添加kv对， value设置为default，并返回default，如果default没有设置，缺省为None

d = dict(a=1,b=2)
d.setdefault('a',0)    
d.setdefault('c',10)
print(d)

{'a': 1, 'b': 2, 'c': 10}

字典增加和修改

d[key] = value

将key对应的值修改为value
key不存在添加新的kv对

update([other]) -> None

使用另一个字典的kv对更新本字典
key不存在，就添加
key存在，覆盖已经存在的key对应的值
就地修改

d = dict(a=0,b=2)
d.update(a=1)
d.update((('a',2),))
d.update({'a':3})
print(d)

{'a': 3, 'b': 2}

字典删除

pop(key[,default])

如果key在字典中，删除它并返回他对应的值，
否则返回默认值，
如果默认值没有给定和key不在字典中则抛出错误

d = dict(a=1,b=2)
d.pop('a')
d.pop('a',0)
#d.pop('a')   # KeyError

0

popitem()

移除和删除任意一个键值对
如果字典为空则抛出一个KeyError 异常

d = dict(a=1,b=2)
d.popitem()
d.popitem()
# d.popitem()  # KeyError

('a', 1)

del语句

从字典中删除一个值，若这个值不在字典中则抛出错误异常

d = dict(a=1,b=2)
del d['a']
# del d['a']   # KeyError

clear()

清空字典

d = dict(a=1,b=2)
d.clear()
print(d)

{}

字典KEY遍历

字典的初始化，和取值方式

d = dict(a=1,b=2,c=3)
keys = d.keys()
values = d.values()
print(keys)       
print(values)    

for i in d:
    print(i,end=' ')  

print()
for j in keys:
    print(j,end=' ')

dict_keys(['a', 'b', 'c'])
dict_values([1, 2, 3])
a b c 
a b c 

字典key的遍历有三种方式遍历，

第一种直接遍历字典

d = dict(a = 1,b = 2,c = 3 )
for i in d:
    print(i,end=' ')

a b c 

第二种通过类下的方法keys()进行遍历

d = dict(a = 1,b = 2,c = 3)
for i in d.keys():
    print(i,end=' ')

a b c 

第三种通过将迭代出来的列表转换为迭代器

d = dict(a = 1,b = 2,c = 3)
keys = iter(d.keys())

print(type(keys))
next(keys)
next(keys)
next(keys)

<class 'dict_keyiterator'>





'c'

字典value值的遍历

字典value值的遍历可以通过遍历key获取到key值，然后通过d[key],get[key]访问对应的value值或者直接通过class类方法

通过key值，d[key]方法访问value

d = dict(a = 1,b = 2,c = 3)
for k in d:
    print(d[k],end=' ')

1 2 3 

通过key值，get方法访问value值

d = dict(a = 1,b = 2,c = 3)
for k in d:
    print(d.get(k),end=' ')

1 2 3 

通过items()方法获取value的值

d = dict(a = 1,b = 2,c = 3)
for k,v in d.items():
    print(v,end=' ')

1 2 3 

字典变量，丢弃变量访问

d = dict(a = 1,b = 2,c = 3)
for _,v in d.items():
    print(v,end=' ')

1 2 3 

字典遍历过程中移除元素

d = dict(a = 1,b = 2,c = 3)
lst = []
for k,_ in d.items():
    if k == '1':
        # d.pop(k)    
        # 在字典遍历的过程中不能改变字典的长度或大小，
        # 因此要真正的删除其key-value时，在遍历的过程中要收集好要删除的key，最后一次性删除
       lst.append(k) 
for k in lst:
    d.pop(k)
print(d)

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

字典遍历过程中构建

构建字典思路：

构建字典的思路就是首先创建一个空字典，然后再往空字典中加入key和对应的值，通常情况下key的值也可以为空，根据后续条件在添加key对应的值

import random
dic = {}
for k in 'abcdefg':
    if k not in dic.keys():
        dic[k] = []
    for i in range(random.randint(1,5)):
        dic[k].append(i)
print(dic)

{'a': [0, 1], 'b': [0, 1, 2, 3], 'c': [0, 1, 2], 'd': [0, 1, 2, 3, 4], 'e': [0, 1], 'f': [0, 1, 2], 'g': [0, 1, 2, 3]}

from collections import defaultdict
import random
d1 = defaultdict(list)
for k in 'abcdef':
    for i in range(random.randint(1,5)):
        d1[k].append(i)
    print(d1)

defaultdict(<class 'list'>, {'a': [0]})
defaultdict(<class 'list'>, {'a': [0], 'b': [0, 1, 2, 3]})
defaultdict(<class 'list'>, {'a': [0], 'b': [0, 1, 2, 3], 'c': [0, 1, 2]})
defaultdict(<class 'list'>, {'a': [0], 'b': [0, 1, 2, 3], 'c': [0, 1, 2], 'd': [0, 1, 2, 3]})
defaultdict(<class 'list'>, {'a': [0], 'b': [0, 1, 2, 3], 'c': [0, 1, 2], 'd': [0, 1, 2, 3], 'e': [0, 1, 2]})
defaultdict(<class 'list'>, {'a': [0], 'b': [0, 1, 2, 3], 'c': [0, 1, 2], 'd': [0, 1, 2, 3], 'e': [0, 1, 2], 'f': [0, 1, 2, 3, 4]})

有序字典构建

OrderedDict对象
    有序字典和常规字典一样，但它们记住插入项目的顺序。
    当迭代一个有序的字典时，这些项按照它们的键被第一次添加的顺序返回。
    返回dict子类的实例，支持通常的dict方法。
    ordereddict是一个记忆键首次插入顺序的dict。
    如果新条目覆盖现有条目，则原始插入位置保持不变。删除一个条目并重新插入它将移动到末尾。

from collections import OrderedDict
import random

d = {'a':1,'b':2,'c':3,'d':4}
print(d)
keys = list(d.keys())
random.shuffle(keys)
print(keys)

od =OrderedDict()
for k in keys:
    od[k] = d[k]

print(d.keys())
print(od)
print(od.keys())
# 打印结果
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# ['c', 'a', 'd', 'b']
# dict_keys(['a', 'b', 'c', 'd'])
# OrderedDict([('c', 3), ('a', 1), ('d', 4), ('b', 2)])
# odict_keys(['c', 'a', 'd', 'b'])

{'a': 1, 'b': 2, 'c': 3, 'd': 4}
['b', 'c', 'a', 'd']
dict_keys(['a', 'b', 'c', 'd'])
OrderedDict([('b', 2), ('c', 3), ('a', 1), ('d', 4)])
odict_keys(['b', 'c', 'a', 'd'])