Python运维自动化之字典Dict

字典Dict(哈希表)

Dict即Dictionary，也称为mapping。
Python中，字典由任意个元素构成的集合，每一个元素称为Item，也称为Entry。这个Item是由(key, value)组成的二元组。
字典是可变的、无序的、key不重复的key-value键值对集合。

初始化

• dict(**kwargs) 使用name=value对初始化一个字典
• dict(iterable, kwarg) 使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个二元结构**
• dict(mapping, **kwarg) 使用一个字典构建另一个字典

字典的初始化方法都非常常用，都需要会用

d1 = {}
d2 = dict(),dict({}),dict([]),dict(())
d3 = dict(a=100, b=200)  #{'a': 100, 'b': 200}
d4 = dict(d3) # 构造另外一个字典 #{'a': 100, 'b': 200}
d5 = dict(d4, a=300, c=400)
d6 = dict([('a', 100), ['b', 200], (1, 'abc')], b=300, c=400) #b=300 会重新赋值
d7 = dict({'a':1,'b':100,1:'abc'},a=2,c=300)

# 类方法dict.fromkeys(iterable, value)
d = dict.fromkeys(range(5))   #{0: None, 1: None, 2: None, 3: None, 4: None}
d = dict.fromkeys(range(5), 0) #{0: 0, 1: 0, 2: 0, 3: 0, 4: 0}d1 = dict.fromkeys('abcde', [1]) #{'a': [1], 'b': [1], 'c': [1], 'd': [1], 'e': [1]}
d1['d'] = 4
d1['b'][0] = 2 #{'a': [2], 'b': [2], 'c': [2], 'd': 4, 'e': [2]}

元素访问

• d[key]

  • 返回key对应的值value

  • key不存在抛出KeyError异常

• get(key[, default])

  • 返回key对应的值value

  • key不存在返回缺省值，如果没有设置缺省值就返回None

• setdefault(key[, default])

  • 返回key对应的值value

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

d1 = {'a':1,'b':'abc','c':False}
d1['c'] #False   hash定位原理
d1.get('d',[1,2,3]) #[1, 2, 3]
d1 #{'a': 1, 'b': 'abc', 'c': False}
d1.setdefault('d',[1,2,3]) #[1, 2, 3]
d1 #{'a': 1, 'b': 'abc', 'c': False, 'd': [1, 2, 3]}

新增和修改

• d[key] = value
  • 将key对应的值修改为value
  • key不存在添加新的kv对
• update([other]) -> None
  • 使用另一个字典的kv对更新本字典
  • key不存在，就添加
  • key存在，覆盖已经存在的key对应的值
  • 就地修改

d = {}
d['a'] = 1
d.update(red=1)
d.update(['red', 2])
d.update({'red':3})d1 = {'a': 100, 'b': 300, 1: 'abc', 'c': 400} #{'a': 100, 'b': 300, 1: 'abc', 'c': 400}
d1.update([('a',123),['b',222]],a=433,d=900,c=12345) #{'a': 433, 'b': 222, 1: 'abc', 'c': 12345, 'd': 900}

删除

• pop(key[, default])
  • key存在，移除它，并返回它的value
  • key不存在，返回给定的default
  • default未设置，key不存在则抛出KeyError异常
• popitem()
  • 移除并返回一个任意的键值对
  • 字典为empty，抛出KeyError异常
• clear()
  • 清空字典
• del

d1 = {'a': 100, 'b': 300, 1: 'abc', 'c': 400}
del a[1] #{'a': 100, 1: 'abc', 'c': 400}d1.pop('c')
12345d1.clear()

遍历

1、遍历Key

d1 = {'a': 100, 'b': 300, 1: 'abc', 'c': 400}输入：for k in d1.keys():print(k)输出：ab1c    

2、遍历Value

d1 = {'a': 100, 'b': 300, 1: 'abc', 'c': 400}
输入：for k in d1.values():print(k)输出：100300abc400   输入：for k in d1.keys():print(d1[k],d1.get(k))
输出：100 100300 300abc abc400 400     

3、遍历Item

d = {'a': 100, 'b': 300, 1: 'abc', 'c': 400}
输入：for item in d.items():print(item)print(item[0], item[1])    
输出： ('a', 100)a 100('b', 300)b 300(1, 'abc')1 abc('c', 400)c 400        输入：for k,v in d.items():print(k, v)     
输出：a 100b 3001 abcc 400   输入： for k,_ in d.items():print(k)
输出：ab1c    输入： for _,v in d.items():print(v)
输出：100300abc400      

Python3中，keys、values、items方法返回一个类似一个生成器的可迭代对象

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

Python2中，上面的方法会返回一个新的列表，立即占据新的内存空间。所以Python2建议使用
iterkeys、itervalues、iteritems版本，返回一个迭代器，而不是返回一个copy

遍历与删除

# 错误的做法
d = dict(a=1, b=2, c=3)
for k,v in d.items():print(d.pop(k))

在使用keys、values、items方法遍历的时候，不可以改变字典的size

 while len(d):print(d.popitem())while d:print(d.popitem())

上面的while循环虽然可以移除字典元素，但是很少使用，不如直接clear。

# for 循环正确删除
d = dict(a=1, b=2, c=3)
keys = []
for k,v in d.items():keys.append(k)
for k in keys:d.pop(k)

key

字典的key和set的元素要求一致

• set的元素可以就是看做key，set可以看做dict的简化版
• hashable 可哈希才可以作为key，可以使用hash()测试
• 使用key访问，就如同列表使用index访问一样，时间复杂度都是O(1)，这也是最好的访问元素的方式

d = {1 : 0, 2.0 : 3, "abc" : None,  ('hello', 'world', 'python') : "string", b'abc' : '135'
}

有序性

字典元素是按照key的hash值无序存储的。

但是，有时候我们却需要一个有序的元素顺序，Python 3.6之前，使用OrderedDict类可以做到，3.6开 始dict自身支持。到底Python对一个无序数据结构记录了什么顺序？

 # 3.5如下
C:\Python\Python353>python
Python 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 16:02:32) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> d = {'a':300, 'b':200, 'c':100, 'd':50}
>>> d
{'c': 100, 'a': 300, 'b': 200, 'd': 50}
>>> d
{'c': 100, 'a': 300, 'b': 200, 'd': 50}
>>> list(d.keys())
['c', 'a', 'b', 'd']
>>> exit()
C:\Python\Python353>python
Python 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 16:02:32) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> d = {'a':300, 'b':200, 'c':100, 'd':50}
>>> d
{'b': 200, 'c': 100, 'd': 50, 'a': 300}

Python 3.6之前，在不同的机器上，甚至同一个程序分别运行2次，都不能确定不同的key的先后顺序。

 # 3.6+表现如下
C:\Python\python366>python
Python 3.6.6 (v3.6.6:4cf1f54eb7, Jun 27 2018, 03:37:03) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> d = {'c': 100, 'a': 300, 'b': 200, 'd': 50}
>>> d
{'c': 100, 'a': 300, 'b': 200, 'd': 50}
>>> exit()
C:\Python\python366>python
Python 3.6.6 (v3.6.6:4cf1f54eb7, Jun 27 2018, 03:37:03) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> d = {'c': 100, 'a': 300, 'b': 200, 'd': 50}
>>> d
{'c': 100, 'a': 300, 'b': 200, 'd': 50}
>>> d.keys()
dict_keys(['c', 'a', 'b', 'd'])

Python 3.6+，记录了字典key的录入顺序，遍历的时候，就是按照这个顺序。

如果使用d = {‘a’:300, ‘b’:200, ‘c’:100, ‘d’:50}，就会造成以为字典按照key排序的错觉。

目前，建议不要3.6提供的这种字典特性，还是以为字典返回的是无序的，可以在Python不同版本中考 虑使用OrderedDict类来保证这种录入序。