Python -- 字典及操作

字典

定义及特性

• key-value键值对的数据的集合
• key必须可hash
• 可变的、无序的、key不重复

字典dict定义 初始化

• d =dict() 或者 d ={} 空字典
• d1 = {1:1, ‘2’:2, ‘a’:3, ‘b’:True, ‘c’:[1, 2, ,3]}
• d2 = dict([(1,2), [‘a’,[300] ,{‘b’, 400}])
  打印结果为{1 : 2 , ‘a’ : 300 , 400 : ‘b’}，注意这里的{‘b’ , 400}为set，所以输出也有可能把 ‘b’当做key
• dict(**kwargs) 使用name=value对初始化一个字典
• d3 = dict (a=1 , b=2 , c=3)
  打印结果为 {‘a’ : 1 , ‘b’ : 2 , ‘c’ : 3}，注意这里的标识符输出的结果类型为字符串，比较特殊
• d4 = dict(d3)，输出的结果与d3一致，一般认为id地址不一致，除非特殊情况。
• 当key有重复时，去重默认后面覆盖前面
• dict(iterable，**kwargs)使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个 二元结构

类方法 dict.fromkeys(iterable, value)

• dict.fromkeys(range(3))
  打印结果为{0:None, 1:None, 2:None}，默认value为None
• dict.fromkeys(range(3),‘a’)
  打印结果为{0:‘a’, 1:‘a’, 2:‘a’}

字典元素的访问

• d[key]

1. 返回key对应的值value
2. key不存在，抛出keyError异常

• get(key[, default])

1. 返回key对应的值value
2. key不存在返回缺省值，如果没有设置缺省值就返回None
   例：d1 = {‘a’:1,‘b’:2,‘c’:3}
   d1.get(‘d’)，当没有对应的key，返回值为None
   d1.get(‘d’ , 4) ，当没有对应的key，设置了value，则返回value值
   d1.get(‘a’ , 200) ，当有对应的key，则返回原有key对应的value值
   可通过返回值是否为None来判断kv对是否存在

• setdefault(key[, default])

1. 返回key对应的值value
2. key不存在，添加kv对，value设置为default，并返回default，如果default没有设置，缺省为None
   例：d1 = {1:1, ‘2’:2, ‘a’:3, ‘b’:True}
   d1.setdefault(1, 200)，返回原有key对应的value值
   d1.setdefault(4, 200) ,当key不存在时，返回新创建的value值，并且在原有的字典里新增对应的kv对，即d1={1:1, ‘2’:2, ‘a’:3, ‘b’:True,4:200}

字典的增加和修改

• d[key] = value
  将key对应的值修改为value
  key不存在添加新的kv对
  例：d1={‘a’:1,‘b’:2,‘c’:3} ，输入d1[4] =30，则d1={‘a’:1,‘b’:2,‘c’:3,4:30}
• update([other]) -> None 更新
  使用另一个字典的kv对更新本字典
  key不存在，就添加
  key存在，覆盖已经存在的key对应的值
  就地修改
  d.update(red=1)
  d.update(((‘red’,2),))
  d.update({‘red’:3})
  例：
  当d1={‘a’:1, ‘b’:2, ‘c’:3, 4:4} ，输入d1.update({‘a’:5, ‘b’ :6})，即d1={‘a’:5, ‘b’:6, ‘c’:3, 4:4}
  当d1={‘a’:1,‘b’:2,‘c’:3, 4:4}，输入d1.update(a=300),即d1={‘a’:300,‘b’:2,‘c’:3, 4:4}，注意，如果输入d1.update(4=200)，则会报错，再使用谁等于谁时，标识符必须为字母或下划线开头
  当d1={‘a’:1,‘b’:2,‘c’:3, 4:4}，输入d.update(((‘a’,2),))，即d1={‘a’:2,‘b’:2,‘c’:3, 4:4}，注意当二原结构使用元祖时，单个元祖的表达形式为((a,b),)
  当d1={‘a’:1,‘b’:2,‘c’:3, 4:4}，输入d.update(((‘a’,2),d=50)),即d1={‘a’:2,‘b’:2,‘c’:3, 4:4,‘d’:50}

字典删除

• pop(key[, default])
  key存在，移除它，并返回它的value
  key不存在，返回给定的default
  default未设置，key不存在则跑出KeyError异常
• popitem()
  移除并返回一个任意的键值对
  字典为空，抛出KeyError异常
• clear()
  清空字典
• del语句
  删除指定的kv对，key不存在则跑出KeyError异常
  del实际上删除的是名称，而不是对象

字典遍历

• for … in dict

遍历key

d1={'a':1,'b':2, 4:4}
for k in d1:
#for k in d1.keys() # 同等上面
	print(k)

打印结果对应的key值为

  a  
  b  
  4

遍历value

 d1={'a':1,'b':2, 4:4}
 for v in d1.values()
 	print(v)

打印结果对应的value值为

1  
2  
4

使用key来找value值

d1={'a':1,'b':2, 4:4}
for k in d1.keys()
	print(d1[k]) # print(d1.get(k)) 同等

遍历item

• item即kv对，或者称为entry
• 用法1

d1={'a':1,'b':2, 4:4}
for item in d1.items():
   print(item) 

打印结果为kv对，二元组

('a', 1)
('b', 2)
(4, 4)

• 用法2

d1={'a':1,'b':2, 4:4}
for item in d1.items():
   print(item[0],'~~~',item[1]) 

打印结果

a ~~~ 1
b ~~~ 2
4 ~~~ 4

• 用法3
  直接两层解构，必须要保证每一项结构一致。

d1={'a':1,'b':2, 4:4}
for k,v in d1.items():
	print(k,v) 

打印结果

a 1
b 2
4 4

• 方法4
  不需要value值或key，可使用下划线代替

d1={'a':1,'b':2, 4:4}
for k,_ in d1.items(): # for _,v in d1.items():
	print(k)  # print(v)

打印结果

a
b
4

字典遍历总结

• Python3中，keys、values、items方法返回一个类似一个生成器的可迭代对象，不会把函数的返回结果复制到内存中

1. 返回Dictionary view对象，可以使用len()、iter()、in操作
2. 字典的entry的动态的视图，字典变化，视图将反映出这些变化
3. keys返回一个类set对象，也就是可以看做一个set集合
4. 如果values都可以hash，那么items也可以看做是类set对象

• Python2中，上面的方法会返回一个新的列表，占据新的内存空间。所以Python2建议使用itereys、itervalues、iteritems版本，返回一个迭代器，而不是返回一个copy
• 注意：在使用keys、values、items进行遍历时，可修改values值，但不可直接使用pop等修改dict的size。

遍历修改值：

d1={'a':1,'b':2, 4:4}
for k in d1:
	d1[k] = 100
print(d1)

输出结果：

{'a': 100, 'b': 100, 4: 100}

遍历删除：

d1={'a':1,'b':2, 4:4}
keys =[]
for k,v in d1.items():
	if v > 3:
		keys.append(k)
for k in keys:
	d1.pop(k)
print(d1)

输出结果：

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

字典的key

• key的要求和set的元素要求一致

1. set的元素可以就是看做key，set可以看做dict的简化版
2. hashable 可哈希才可以作为key，可以使用hash()测试
3. d ={1:0, 2.0:3, “abc”:None, (‘hello’,‘woeld’,‘python’):“string”,b’abc’:‘135’}

defaultdict 缺省字典

• collections.defaultdict([default_factory[, …]])
  使用
  from collections import defaultdict
  import random
  导入模块

1. 第一个参数是default_factory，缺省是None，它提供一个初始化函数。当key不存在的时候，会调用这个工厂函数来生成key对应的value
2. 构造一个字典，values是列表，为其添加随机个元素

写法1：

import random

d1={}
for k in 'abcde':
    for v in range(random.randint(1,5)):
        if k not in d1.keys():
            d1[k] = list() #[]
        d1[k].append(v)
print(d1)

打印结果

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

方法2：

import random

d1={}
for k in 'abcde':
    for v in range(random.randint(1,5)):
        d1.setdefault(k, []).append(v) #d1..setdefault(k, [])返回值为[]
print(d1)

打印结果

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

工厂方法-list：

from collections import defaultdict
import random

d1=defaultdict(list) #[] 函数名称
for k in 'abcde':
    for v in range(random.randint(1,5)):
        d1[k].append(v) # d1[k] = list() 函数名称后面加一个括号就是调用
print(d1)

打印结果

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

解析：当访问某个key时，如果发现不存在，将会调用工厂方法，创建kv对，即可访问d1[k]
工厂方法-set：

from collections import defaultdict
import random

d1=defaultdict(set) #set()
for k in 'abcde':
    for v in range(random.randint(1,5)):
        d1[k].add(v) # d1[k] = set()
print(d1)

打印结果

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

OrderedDict 有序字典

• collections.OrderenDict([items])
• key 并不是按照加入的顺序排列，可以使用OrderedDict记录顺序

from collections impoet OrderedDict
impoet random
d = {'b':3, 'a':4, 'p':5, 'o':2}
print(d)
keys = list(d.keys())
random.shuffle(keys) #将列表顺序打乱
print(keys)
od = OrderedDict()
for key in keys:
	od[key] = d[key]
print(od)
print(od.keys())

• 有序字典可以记录元素插入的顺序，打印的时候也是按照这个顺序输出打印
• 3,6版本的Python的字典就是记录key插入的顺序（IPython不一定有效果）
• 应用场景：
  假如使用字典记录了N个产品，这些产品使用ID由小到大加入到字典中
  除了使用字典检索的遍历，有时候需要取出ID，但是希望是按照输入的顺序，因为输入顺序的有序的
  否则还需要重新把遍历到的值排序