Python-数据结构之dict（字典*****）

阅读目录：

　　1、字典dict

　　2、字典dict定义，初始化　　

　　3、字典元素的访问

　　4、字典增加和修改

　　5、字典删除

　　6、字典的遍历

　　7、字典遍历 和 移除

　　8、字典的key

　　9、defaultdict （缺省字典）

　　10、OrderedDict　有序字典

1、字典dict

　　key_value 键值对的数据的集合

　　可变，无序，key不重复，非线性

2、字典dict定义，初始化

　　d = dict() 或者 d = {}

　　dict(**kwargs) 使用name=value 对初始化一个字典

　　dict（iterable, **kwarg）使用可迭代对象 和 name = value 对构造字典，不过可迭代对象的元素必须是一个二元结构。

# d = dict((('k','1'),)) # 正确
# d1 = dict((('k','1'))) # 报错 ValueError: dictionary update sequence element #0 has length 1; 2 is required
# d1 = dict(((1,'a')))   # TypeError: cannot convert dictionary update sequence element #0 to a sequence

# d1 = dict([[1,'a']])   # 正确
# d1 = dict(([1,'a']))   #  TypeError: cannot convert dictionary update sequence element #0 to a sequence

# d1 = dict([(1,'a')])   # 正确

 

　　　　d = dict(((1,'a'),(2,'b'))) 或者 d = dict(([1,'a'],[2,'s']))

　　dict(mapping, **kwarg)) 使用一个字典构造另一个字典 # 注意引用类型

　　d = {'a':1, 's':2, 'd':None,'f':[1,2,3]}

　　类方法：dict.fromkeys(iterable,value) # 注意引用类型　　　

a = dict([(122,1)],a = 1) # 122: 1, 'a': 1}
b = dict(a=1,b =3)
c = dict([(1,1),('a',2)],a = 1,b = 2) # {1: 1, 'a': 1, 'b': 2} # 后面的 a 把前面的去重了
d = dict([(1,1),('a',2),(1,[1])],a = 1,b = 2) #{1: [1], 'a': 1, 'b': 2}
    ------> 后面的是**kwarg  只能放到后面，格式规定


d = dict([(1,1),('a',2),(1,[1])],a = 1,b = 2) #{1: [1], 'a': 1, 'b': 2}
f = dict(d, a = 19) #有引用类型，所以使用的时候一定要注意，如下：
d[1].append(2)

d,f # ({1: [1, 2], 'a': 1, 'b': 2}, {1: [1, 2], 'a': 19, 'b': 2})



a = dict([(122,1)],a = 1) # 122: 1, 'a': 1}
b = dict(a=1,b =3)
c = dict([(1,1),('a',2)],a = 1,b = 2) # {1: 1, 'a': 1, 'b': 2} # 后面的 a 把前面的去重了
d = dict([(1,1),('a',2),(1,[1])],a = 1,b = 2) #{1: [1], 'a': 1, 'b': 2}
#     ------> 后面的是**kwarg  只能放到后面，格式规定g


g = dict.fromkeys(range(4))
h = dict.fromkeys(range(4),0)
g # {0: None, 1: None, 2: None, 3: None}
h # {0: 0, 1: 0, 2: 0, 3: 0}
l = dict.fromkeys((1,2,3,4),1)
l # {1: 1, 2: 1, 3: 1, 4: 1}


注：
m = dict.fromkeys(range(4),[2])
m[1].append(3)
m # {0: [2, 3], 1: [2, 3], 2: [2, 3], 3: [2, 3]}

 

str1 = "k:1|k1:2|k2:3|k4:4"
lst1 = str1.split('|')
dic1 = {}
for k in range(len(lst1)):   
    dic = dict(    [lst1[k].split(':')]   )
    dic1.update(dic)
print(dic1)

for i in lst1:
    k,v = i.split(':')
    dic1[k] = v
print(dic1)
 

 

3、字典元素的访问

　　d[key]:返回key对应的值value，key不存在怕熬出KeyError异常

　　get(key [, default]) ： 返回key对应的值value，可以不存在返回缺省值，如果没有设置缺省值，就返回None

　　setdefault（key  [, default]）:返回key对应的值value，key不存在，添加kv 对，value设置为default，并返回default，如果default没有设置，缺省为None

l = {1: 1, 2: 1, 3: 1, 4: 1}
l.get(5,0) # 0
l.get(2)# 1 

l.setdefault(6) # 返回None
l.setdefault(7,100) # 返回100
l # {1: 1, 2: 1, 3: 1, 4: 1, 6: None, 7: 100}

l.setdefault(2,100)  # 返回 1
l # {1: 1, 2: 1, 3: 1, 4: 1, 6: None, 7: 100}

 

4、字典增加和修改
　　d[ke] = value

　　　　将key 对应的值修改为value

　　　　key 不存在添加新的 K-V对

　　update([other])  ---> None

　　　　使用另一个字典的K-V对更新本字典

　　　　key 不存在，就添加

　　　　key 存在，覆盖已经存在的key 对应的value

　　　　就地修改

l = {1: 1, 2: 1, 3: 1, 4: 1, 6: None, 7: 100}
l[2] = 10
l[9] = 11
l # {1: 1, 2: 10, 3: 1, 4: 1, 6: None, 7: 100, 9: 11}
h ={0: 0, 1: 0, 2: 0, 3: 0}

# l.update(h) #1: 0, 2: 0, 3: 0, 4: 1, 6: None, 7: 100, 9: 11, 0: 0}
# l
h.update([[1,2]])
h # {0: 0, 1: 2, 2: 0, 3: 0}

h.update({'b':1})
h # {0: 0, 1: 2, 2: 0, 3: 0, 'b': 1}

 

5、字典删除：

　　pop( key [, default] )

　　　　key 存在，移除，并返回None　　

　　　　key 不存在，返回给定的 default

　　　　default 未设置，key不存在则抛出KeyError异常

　　popitem():

　　　　随意移除并返回一个K-V对

　　　　字典为空，抛出异常

　　clear（）

　　del 语句 

　　　　注：理论上删除的是对象的引用，而不是对象。

l = {1: 1, 2: 10, 3: 1, 4: 1, 6: None, 7: 100, 9: 11}
l.pop(1,3000) # 1 
l.pop(44,3000) # 3000

l.popitem() # (9, 11) 元组,k-v一般都是元组表示
l # {2: 10, 3: 1, 4: 1, 6: None, 7: 100}

 

a = True
b = [6]
d = {'b':b,'c':[1,3,4]}
del a
del d['c']
del b
d # 'b': [6]} 即便删了b，但是[6] 还是存在的，而且被d['b']引用，放的是地址，而不是b 这个标识符

c = b
del c
del b

del a['c'] # 看着像删除了一个对象，本质上减少了一个对象引用，del实际上删除的是名称，而不是对象

 

　　

6、字典的遍历：

　　for ... in dict

　　　　遍历key  #  list(d) ---得到的是key的列表

　　　　　　for  k in d:

　　　　　　　　print(k)

　　　　　　for k in d.keys():

　　　　　　　　print(k)

　　　　遍历value  

　　　　　　for k in d:

　　　　　　　　print(d[k])

　　　　　　for k in d.keys():

　　　　　　　　print(d[k])

　　　　　　for v in d.values():

　　　　　　　　print(v)

　　　　遍历K-V 对 item

　　　　　　for item in d.items():

　　　　　　　　print(item)

　　　　　　for k, v in d.items():

　　　　　　　　print(k,v)

　　　　　　for k, _  in d.items():

　　　　　　　　print(k)

　　　　总结：

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

　　　　 　  　　Dictionary view 对象 ，可以使用len() ,iter() , in 操作

　　　　　　　　字典的entry的动态的视图，字典变化，试图将反映出这些变化。（entry就是 item）

　　　　　　　　keys返回一个类set对象，也就是可以看做一个set 集合，如果valuse 都可以hash，那么items 也可以看做是类 set 对象

 

　　　　　 Python 2 中，上面的方法会返回一个新的列表，占据新的内存空间，索引Python2 中建议使用iterkeys. itervalues,iteritems版本，返回一个迭代器，而不是一个copy

7、字典遍历 和 移除：

　　如何在遍历的时候移除元素（结论是，字典不能再遍历本身的时候删除）

正确的做法：现将需要的 keys 取出来，在迭代keys ，从而删除 pop(key) 
d = dict(a=1,b=2,c=3)
keys = []
for k, v in d.items():
    if isinstance(v, str):
        keys.append(k)

for k in keys:
    d.pop(k)
print(d)

 

 

8、字典的key

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

　　　　set 的元素 可以 就是看做 key，set可以看到 dict的简化版。

　　　　hashable 可哈希才可以作为key，可以使用hasn() 测试。

　　　　d = { 1:0 , 2.0:3, 'abc': None}

 

9、defaultdict （缺省字典）　　　

d = {}
for i in 'abcde':
    for j in range(3):
        if i not in d.keys():
            d[i] = []
        d[i].append(j)
print(d)
# ---------------------------->

from collections import defaultdict

d = defaultdict(list) # 构造出自己想要的类型
for i in 'abcde':
    for j in range(3):
        d[i].append(j)
print(d) # defaultdict(<class 'list'>, {'a': [0, 1, 2], 'b': [0, 1, 2], 'c': [0, 1, 2], 'd': [0, 1, 2], 'e': [0, 1, 2]})


for i in 'abcde':
    d[i]  = i
print(d) # defaultdict(<class 'list'>, {'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd', 'e': 'e'})

 

10、OrderedDict　有序字典

from collections import OrderedDict

d = OrderedDict()
d[1] = 1
d['2'] = 2
d['c'] = 'c'
d [21] = 's'
d # OrderedDict([(1, 1), ('2', 2), ('c', 'c'), (21, 's')])
# 按照录入的顺序 会记录下来，即便后面再怎么打乱顺序，都不变

from collections import OrderedDict
import random

d = {'a':1,'c':'c',1:'d',10:'d'}

keys = list(d)
random.shuffle(keys)
print(keys)

od = OrderedDict()

for key in keys:
    od[key] = d[key]
print(od)
print(od.keys())

结果：（每执行一次，keys顺序改变，但是最后的有序字典都不变）
# [1, 'a', 'c', 10]
# OrderedDict([(1, 'd'), ('a', 1), ('c', 'c'), (10, 'd')])
# odict_keys([1, 'a', 'c', 10])

 

　　　　OrderedDict：作用：

　　　　　　　　有序字典可以记录元素插入的顺序，打印的时候也是按照这个顺序输出打印

　　　　　　　　3.6 版本的Python 的字典就是记录key插入的顺序（IPython不一定有效）　　

　　　　应用场景：

　　　　　　　　假如使用字典记录了N 个产品，这些产品使用ID 由小到大加入字典中

　　　　　　　　除了使用字典检索的遍历，有时候需要取出ID ，但是希望按照输入的顺序，因为输入顺序是有序的。