#一、 字典
###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