https://www.jianshu.com/p/7c31cfc024cc
一、 字典
1 映射类型数据结构介绍
- 在字典存放的每个元素都是以一对儿键值对。
- 在 Python 中 字典通常被称为 dict，键 称为 key，值称为 value
- 字典中不可以存在相同的 key，但是 value 可以。
2 高效创建字典
空字典
In [7]: d1 = {}
In [8]: type(d1)
Out[8]: dict
3. dict() 转换为字典
接收一个序列类型的参数，这个序列类型中的每个元素必须是成对儿出现的。
In [14]: d_tpl = [('a','1'),('b','2'),('c','3')]
In [15]: dict3 = dict(d_tpl)
In [17]: d_tpl2 = ['a1','b2','c3']
In [18]: dict4 = dict(d_tpl2)
In [21]: dict3 is dict4
Out[21]: False
In [22]: dict3 == dict4
Out[22]: True
4. 哪些数据可以作为字典的 kye
key 通常是 字符串
它可以是 Python 中任意不可变类型
比如：
- 布尔型 True 1 False 0
- 整型 100 200
- 浮点型 1.0 3.415
- 元组 （1,） （1, 2, 3）
- 字符串 'host_name'
关于字典的 key
在 Python 内部用一个哈希表来维护字典中的 key 到 value 的映射关系。
所以 key 必须是可哈希的。
判断一个对象是否可哈希，可以使用 hash() 函数
返回一个整数，就是可哈希，反之会抛出 TypeError 异常
hash(1)
hash('name')
hash((1,2,3))
# 列表是可变的数据类型，所有不可以被 hash，当然也就不能作为 字典的 key
hash([1,2,3])
5. 获取 key 对应的 value
dict_obj = {'a': 1, 'b': 2}
dict_obj['a'] # key 必须存在，不存在，抛出异常
dict_obj.get('a') # 获取到 'a' 对应的值(value)
dict_obj.get('c') # key 不存在字典中，则返回 None
dict_obj.get('c', '5') # key 不存在，返回指定的 value
6. 获取字典所有的 key
dict_obj.keys()
info_dict = {"name": 'yangge', 'age': 18}
d_keys = info_dict.keys()
print(d_keys)
print(list(d_keys))
循环字典所有 的 key
for key in d_keys:
print(key)
7. 获取字典所有的 value
dict_obj.values()
info_dict = {"name": 'yangge', 'age': 18}
d_vals = info_dict.values()
print(d_vals)
print(list(d_vals))
循环字典所有 的 value
for val in d_vals:
print(val)
8. 同时获取字典的 key 和 value
dict_obj.items()
info_dict = {"name": 'yangge', 'age': 18}
item = info_dict.items()
print(item)
print(list(item))
循环字典的 key 和 value
for k, v in info_dict.items():
print(k, v)
9. 使用 = 修改或更新字典
可以使用 等号 对字典的 key 进行直接赋值操作。
假如 key 不存在与字典中，这个 key 和 对应值也会被创建到字典中。
In [50]: d5 = {}
In [51]: d5['a'] = 1
In [52]: d5['b'] = 2
In [53]: d5
Out[53]: {'a': 1, 'b': 2}
In [54]: d5['li'] = [1,3,5]
In [55]: d5
Out[55]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}
10. 使用 update() 更新字典
把一个已经存在的字典中的键值对，添加到另一个字典中。
In [59]: d5
Out[59]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}
In [60]: d6 = {'a': 2,'d': 2,'e': 5}
In [61]: d5.update(d6)
In [62]: d5
Out[62]: {'a': 2, 'b': 2, 'd': 2, 'e': 5, 'li': [1, 3, 5]}
注意： 更新时，相同的
key，它的值会被新的值替代，这个特性同样适用与=号方式的更新.
python3.5+
x = {'a': 1, 'b': 2} y = {'c': 1, 'd': 2} z = {**x,**y} print(z)
11. 成员判断
in
In [63]: 'a' in d5 # 默认就是判断 'a' 是否存在于字典中的 keys()
Out[63]: True
In [63]: 'a' in d5.keys()
Out[63]: True
In [75]: 'a' not in d5.keys()
Out[75]: False
12. 删除和清空字典
删除指定的键值对
dict_obj = {'a': 1}
del dict_obj['a'] # 从字典中删除指定 key 的键值对
del dict_obj # 删除字典本身，字典自身就不存在于内存中了
清空
dict_obj={}
dict_obj.clear() # 字典本身还在内存中，只是内容没了
pop()
从字典中删除指定 key 的键值对，并返回这个 key 对应的值
In [49]: d6 = {'b': 2, 'c': '3', 'd': 'new key', 'li': [1, 3, 5]}
In [50]: li = d6.pop('li')
In [51]: print(li)
Out [51]: [1, 3, 5]
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")
建议使用下面的代码实现
arg = input(">>:")
data = {
"0": "zero",
"1": "one",
"2": "two",
}
data.get(arg, "nothing")
二、集合
1 集合特性介绍
在 python 中集合看起来像是只有 key 的字典
{'disk','cpu','memory','motherboard'}
在 python 解释器中表现为 set
集合内的元素不允许重复
2 高效创建集合和转换
set()
In [96]: s1 = set()
In [97]: s1
Out[97]: set()
转换
In [99]: set('disk')
Out[99]: {'d', 'i', 'k', 's'}
In [100]: set(['disk','cpu','memory'])
Out[100]: {'cpu', 'disk', 'memory'}
In [101]: set(('disk','cpu','memory'))
Out[101]: {'cpu', 'disk', 'memory'}
In [102]: set({'disk': '560G','cpu': '4'})
Out[102]: {'cpu', 'disk'}
3 集合运算
a. & 交集
获取两个集合都有的元素
In [55]: s1 = {"192.168.1.51", "192.168.1.45"}
In [56]: s2 = {"192.168.1.51", "192.168.1.78", }
In [57]: s1 & s2
Out[57]: {'192.168.1.51'}
b. |并集
把两个集合的元素合并在一起，产生一个新的集合
In [60]: s1 | s2
Out[60]: {'192.168.1.45', '192.168.1.51', '192.168.1.78'}
c. -差集
返回第一个集合中独有的元素。
就是只保留在第一个集合中出现并且不在第二个集合中出现的元素。
In [55]: s1 = {"192.168.1.51", "192.168.1.45"}
In [56]: s2 = {"192.168.1.55", "192.168.1.51"}
In [61]: s1 - s2
Out[61]: {'192.168.1.45'}
In [62]: s2 - s1
Out[62]: {'192.168.1.78'}
^异或运算
获取两个集合的分别独有的元素，组合为一个新的集合对象。
In [55]: s1 = {"192.168.1.51", "192.168.1.45"}
In [56]: s2 = {"192.168.1.55", "192.168.1.51"}
In [63]: s1 ^ s2
Out[63]: {'192.168.1.45', '192.168.1.78'}
大型数据结构应用场景
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[0])
print(host_info[0].get('192.168.1.11').get('disk')[0])
作业练习
员工查询系统开发
需求
用户通过输入员工姓名的拼音全拼 , 查询员工信息。
假如系统中有此员工，则询问用户想要查询什么信息，比如 地址 、电话等。
并提示用户查询的信息类型如 提示：请输入查询的信息类型 [ p 查询电话，addr 查询地址 ]输入正确后，返回对应的信息
假如不存在，则提示查询的员工信息未录入系统。
系统一旦运行，保持运行状态，用户输入 b 返回到到上一层，输入 q 退出系统。