Python-字典和集合

#一、 字典
###1. 映射类型数据结构介绍

• 在字典存放的每个元素都是以一对儿键值对存在的。
• 在 Python 中 字典 通常被称为 dict ，键 称为 key，值 称为 value 。
• 字典中不可以存在相同的 key，但是可以存在相同的 value 。

###2. 高效创建字典
空字典

>>> d1 = {}
>>> type(d1)
<class 'dict'>

###3. dict()转换为字典
接收一个序列类型的参数，这个序列类型中的每个元素必须是成对儿出现的。

>>> li1 = [('a', '1'), ('b', '2'), ('c', '3')]
>>> dt1 = dict(li1)
>>> dt1
{'a': '1', 'b': '2', 'c': '3'}

>>> li2 = ['a1', 'b2', 'c3']
>>> dt2 = dict(li2)
>>> dt2
{'a': '1', 'b': '2', 'c': '3'}

>>> dt1 is dt2     #是否为一个对象
False
>>> dt1 == dt2     #是否为一个对象的值
True

###4. 哪些数据可以作为字典的 key
key通常是 字符串
它可以是 Python 中任意不可变类型
例：

• 布尔型True 1 False 0
• 整型100 200
• 浮点型1.1 2.345
• 元组(1,) (1, 2, 3)
• 字符串“host_name”

#####关于字典的 key

• 在 Python 内部用一个哈希表来维护字典中的 key 到 value 的映射关系。
• 所以 key 必须是可哈希的。
• 判断一个对象是否可哈希，可以使用 hash()函数
• 返回一个整数，就是可哈希，反之会抛出 TypeError 异常

>>> hash(1)
1

>>> hash('name')
-9073832892601246073

>>> hash((1, 2, 3))
2528502973977326415

>>> hash([1, 2, 3])     # 列表是可变的数据类型，所有不可以被 hash，当然也就不能作为 字典的 key
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

###5. 获取 key 对应的 value

>>> dt1 = {'a': '1', 'b': '2', 'c': '3'}
>>> dt1
{'a': '1', 'b': '2', 'c': '3'}

>>> dt1['a']
'1'
>>> dt1['A']     # key 必须存在，不存在，抛出异常 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'A'

>>> dt1.get('a')     # 获取到 'a' 对应的值(value)
'1'

>>> c = dt1.get('A')     # key 不存在字典中，则为 None
>>> type(c)
<class 'NoneType'>

>>> dt1.get('A', '8')     # key 不存在，返回指定的 value
'8'

###6. .keys()获取字典所有的 key

>>> dt1 = {'a': '1', 'b': '2', 'c': '3'}
>>> dt1
{'a': '1', 'b': '2', 'c': '3'}

>>> d = dt1.keys()
>>> print(d)
dict_keys(['a', 'b', 'c'])

>>> print(list(d))
['a', 'b', 'c']


# 循环字典所有的 key
>>> for k in d:
...     print(k)
... 
a
b
c
>>>

###7. .values()获取字典所有的 value

>>> dt1 = {'a': '1', 'b': '2', 'c': '3'}
>>> dt1
{'a': '1', 'b': '2', 'c': '3'}

>>> v = dt1.values()
>>> print(v)
dict_values(['1', '2', '3'])
>>> print(list(v))
['1', '2', '3']

# 循环字典所有的 value
>>> for c in v:
...     print(c)
... 
1
2
3
>>>

###8. .items()同时获取字典的 key 和 value

>>> dt1 = {'a': '1', 'b': '2', 'c': '3'}
>>> dt1
{'a': '1', 'b': '2', 'c': '3'}

>>> dt1.items()
dict_items([('a', '1'), ('b', '2'), ('c', '3')])

>>> i = dt1.items()
>>> print(i)
dict_items([('a', '1'), ('b', '2'), ('c', '3')])
>>> print(list(i))
[('a', '1'), ('b', '2'), ('c', '3')]

# 循环字典的 key 和 value
>>> for k, v in dt1.items():
...     print(k, v)
... 
a 1
b 2
c 3
>>>

###9. 使用 =修改或更新字典
可以使用 等号 对字典的 key 进行直接赋值操作。
假如 key 不存在与字典中，这个 key 和 对应值也会被创建到字典中。

>>> d1 = {}
>>> d1
{}

>>> d1['a'] = 1
>>> d1
{'a': 1}

>>> d1['a'] = 3
>>> d1
{'a': 3}

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

###10. 使用update()更新字典
把一个已经存在的字典中的键值对，添加到另一个字典中

>>> d1 = {'a': '1', 'b': '2'}
>>> d1
{'a': '1', 'b': '2'}

>>> d2 = {'b': '666', 'c': '3', 'd': '4'}
>>> d2
{'b': '666', 'c': '3', 'd': '4'}

>>> d1.update(d2)
>>> d1
{'a': '1', 'b': '666', 'c': '3', 'd': '4'}
>>> d2
{'b': '666', 'c': '3', 'd': '4'}
>>>

注意： 更新时，相同的 key ，它的值会被新的值替代，这个特性同样适用与 = 号方式的更新

Python3.5+版本可以这样操作

>>> x = {'a': 1, 'b': 2}
>>> y = {'c': 1, 'd': 2}
>>> z = {**x,**y}
>>> print(z)
{'a': 1, 'b': 2, 'c': 1, 'd': 2}

###11. in成员判断

>>> d1 = {'a': '1', 'b': '2'}     # 默认就是判断 'a' 是否存在于字典中的 keys()
>>> d1
{'a': '1', 'b': '2'}

>>> 'a' in d1
True

>>> 'a' in d1.keys()
True

>>> 'a' not in d1.keys()
False

###12. 删除和清空字典
#####删除指定的键值对

>>> d1 = {'a': '1', 'b': '2'}
>>> d1
{'a': '1', 'b': '2'}

>>> del d1['a']     # 从字典中删除指定 key 的键值对
>>> d1
{'b': '2'}

>>> del d1    # 删除字典本身，字典自身就不存在于内存中了
>>> d1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'd1' is not defined

#####清空：字典本身还在内存中，只是内容没了

>>> d1 = {'a': '1', 'b': '2'}
>>> d1
{'a': '1', 'b': '2'}
>>> d1={}
>>> d1
{}

>>> d1 = {'a': '1', 'b': '2'}
>>> d1
{'a': '1', 'b': '2'}
>>> d1.clear()
>>> d1
{}
>>>

#####pop()从字典中删除指定 key 的键值对，并返回这个 key 对应的值

>>> d1 = {'a': '1', 'b': '2', 'c': '3'}
>>> d1
{'a': '1', 'b': '2', 'c': '3'}

>>> d2 = d1.pop('b')
>>> d2
'2'
>>> d1
{'a': '1', 'c': '3'}

>>> d1.pop('a')
'1'
>>> d1
{'c': '3'}

###13. 用字典实现 switch … case 语句
Python 中没有 switch … case 语句，这个问题Python之父龟叔表示这个语法过去没有，现在没有，以后也不会有。因为Python简洁的语法完全可以用 if … elif 实现。如果有太多的分支判断，还可以使用字典来代替。

arg = input(">>:")

if arg == "0":
    print('zero')
elif arg == "1":
    print('one')
elif arg == "2":
    print("two")
else:
    print("nothing")

# 建议使用下面的代码实现
data = {
    "0": "zero",
    "1": "one",
    "2": "two",
}

arg = input(">>:")

n = data.get(arg, "nothing")
print(n)

#二、集合
###1. 集合特性介绍

• 在 python 中集合看起来像是只有 key 的字典
• 在 python 解释器中表现为 set
• 集合内的元素必须是可哈希的
• 集合内的元素不允许重复

>>> s1 = {1, 1, 2, 3}
>>> s1
{1, 2, 3}

###2. 高效创建集合和转换 set()

>>> s1 = set()     # 创建空集合
>>> s1
set()
>>> type(s1)
<class 'set'>

>>> s1 = {1, 2, 3}
>>> s1
{1, 2, 3}
>>> type(s1)
<class 'set'>

转换

>>> set('disk')     #转换字符串为集合
{'d', 's', 'k', 'i'}

>>> set(['disk', 'cpu', 'memory'])     #转换列表为集合
{'cpu', 'memory', 'disk'}

>>> set(('disk', 'cpu', 'memory'))     #转换元组为集合
{'cpu', 'memory', 'disk'}

>>> set({'disk': '512G', 'cpu': 'i7'})     #转换集合为集合
{'cpu', 'disk'}
>>> 

###3. 集合运算

• #####&交集
  获取两个集合都有的元素

>>> s1 = {'1', '2'}
>>> s2 = {'2', '3'}

>>> s1 & s2
{'2'}

• #####|并集
  把两个集合的元素合并在一起，产生一个新的集合

>>> s1 = {'1', '2'}
>>> s2 = {'2', '3'}

>>> s1 | s2
{'3', '1', '2'}

• #####-差集
  返回第一个集合中独有的元素。
  就是只保留在第一个集合中出现并且不在第二个集合中出现的元素。

>>> s1 = {'1', '2'}
>>> s2 = {'2', '3'}

>>> s1 - s2
{'1'}

>>> s2 - s1
{'3'}

• #####^异或运算
  获取两个集合的分别独有的元素，组合为一个新的集合对象。

>>> s1 = {'1', '2'}
>>> s2 = {'2', '3'}

>>> s1 ^ s2
{'3', '1'}

---

#####大型数据结构应用场景

host_info = []

host_info.append(
    {'192.168.1.11':
{'cpu':['Intel(R) Core(TM) i5-5350U CPU @ 1.80GHz',4,1],
'memory':['16','4','2'],
'disk':['1T','2T']}}
)

host_info.append({'192.168.1.12':
{'cpu':['Intel(R) Core(TM) i5-5350U CPU @ 1.80GHz',4,1],
'memory':['16','4','2'],
'disk':['1T','2T']}})

取到 1T

>>> print(host_info[1]['192.168.1.12']['disk'][0])
1T

>>> print(host_info[1].get('192.168.1.12').get('disk')[0])
1T