Python-09 核心数据结构(二)

最新推荐文章于 2024-07-11 18:01:45 发布

遥遥無期

最新推荐文章于 2024-07-11 18:01:45 发布

阅读量127

点赞数

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/weixin_42970285/article/details/87973202

版权

Python 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

核心数据结构(二)

四、字典

映射类型数据结构介绍
在字典存放的每个元素都是以一对儿键值对。
在 Python 中字典通常被称为 dict，键称为 key，值称为 value
字典中不可以存在相同的 key，但是 value 可以。
高效创建字典
空字典

In [7]: d1 = {}

In [8]: type(d1)
Out[8]: dict
字典中元素是无序的

In [1]: d2 = {'shark': '鲨鱼', 'ey': '鳄鱼'}

In [2]: d2
Out[2]: {'ey': '鳄鱼', 'shark': '鲨鱼'}

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

zip() 并行迭代
zip() 函数可以对多个序列进行并行迭代

en =['a', 'b', 'c', 'd']

nums = ['1', '2', '3', '4']

for word, num in zip(en, nums):
    print(word, num)
利用 zip() 函数可以对具有相同数量的元素的序列进行配对，返回的值不是元组，也不是列表，而是一个整合在一起的可迭代变量。

In [36]: en = 'a','b','c',

In [37]: nums = '1' , '2', '3'

In [38]: zip(en, nums)
Out[38]: <zip at 0x1052c7f08>

In [39]: type(zip(en, nums))
Out[39]: zip

In [40]: list(zip(en, nums))
Out[40]: 
    
In [41]: dict(zip(en, nums))
Out[41]:

哪些数据可以作为字典的 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])

获取 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

示例
info_dict = {"name": 'yangge', 'age': 18}
na = info_dict['name']
print(na)

naa = info_dict['dd']

age = info_dict.get('age')
print(age)

age2 = info_dict.get('asdf')
print(type(age2),age2)

age3 = info_dict.get('adaf', '')
print(type(age3),age3)

age4 = info_dict.get('adaf', 28)
print(type(age4),age4)

获取字典所有的 key

dict_obj.keys()

info_dict = {"name": 'yangge', 'age': 18}
d_keys = info_dict.keys()
print(d_keys)
print(list(d_keys))

获取字典所有的 value

dict_obj.values()

info_dict = {"name": 'yangge', 'age': 18}
d_vals = info_dict.values()
print(d_vals)
print(list(d_vals))
9. 同时获取字典的 key 和 value
dict_obj.items()

info_dict = {"name": 'yangge', 'age': 18}
item = info_dict.items()
print(item)
print(list(item))

修改或更新字典

可以使用等号对字典的 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]}
字典同样支持引用赋值

In [68]: d5 = {'a': 1, 'b': 2, 'li': [1, 3, 5]} 

In [69]: d6 = d5

In [70]: d6 is d5
Out[70]: True

In [71]: d7 = d5.copy()

In [73]: d7 is d5
Out[73]: False

In [74]: d7 == d5   # 双等号 是用来判断 等号两边的对象的值是否相等
Out[74]: True
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)

成员判断 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

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

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]
popitem()
删除字典中的键值对，并返回这个键和值


item = d6.popitem()

print(item)
print(d6)

"""
('li', [1, 3, 5])
{'b': 2, 'c': '3', 'd': 'new key'}
"""

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

arg = 1

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",
}
data.get(arg, "nothing")

扩展知识： setdefault 处理缺失的键

dict_obj.setdefatult(‘key’, ‘value’)

key 不存在，添加 key: value 到字典中,并且返回字典中的 value 对象，也就是说返回的 value 和刚添加到字典中的 value 是同一个对象；
key 存在, 返回对应的 value，原字典不变
分类统计实例

data = [
        ("ip", "192.168.1.100"),
        ("ip", "192.168.1.200"),
        ("port", 22),
        ("user", "yangge"),
        ("user", "shark")
    ]
bad

groups = {}
for (key, value) in data:
    # 判断 key 是否在于字典中
    if key in groups.keys():
        # key 存在字典中，则把 value 添加到 key 对应的 value 中
        # value 是一个列表，是在下面定义的
        groups[key].append(value)
    else:
        # key 不存在字典中，把键值对添加到此字典中
        # 此时，key 对应的 value 是一个列表类型
        groups[key] = [value]

print(groups)
good

groups = {}
for (key, value) in data:
    groups.setdefault(key, []).append(value)
    # li = groups.setdefault(key, [])
setdefault 的作用是：
如果 key 存在于字典中，那么直接返回对应的值，等效于 get 方法
如果 key 不存在字典中，则会设置此键值对，key 的 value 就是 setdefault 中的第二个参数，之后再返回该值。
你以为结束了？ 扩展知识
思考

下面字典的最终结果是 ？

{True: 'yes', 1: 'no', 1.0: 'maybe'}
['no', 'yes'][True]
当一个新的值与字典的键关联的时候，python的字典不会更新键对象本身

In [66]: y = {1.0: 'no'}

In [67]: y[True] = 'yes'

In [68]: y
Out[68]: {1.0: 'yes'}
    
# 如果键被认为是相同的，那么为什么要花时间更新原来的？
Python字典中的键 是否相同（只有相同才会覆盖）取决于两个条件：

1、两者的值是否相等（比较__eq__()方法)

2、比较两者的哈希值是否相同（比较___hash__()hash方法）

In [69]: (hash(True), hash(1), hash(1.0))
Out[69]: (1, 1, 1)

五、集合
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 [11]: s2 = {12,3,4,5,6,}

In [12]: s2.add('n')

In [13]: s2
Out[13]: {12, 3, 4, 5, 6, 'n'}

b. 指定删除某个元素

In [15]: s2.remove('n')

In [16]: s2
Out[16]: {4, 5, 6, 12}

c. 随机干掉一个

In [14]: s2.pop()
Out[14]: 3

4 集合运算
a. & 交集

获取两个集合都有的元素

In [55]: s1 = {"192.168.1.51", "192.168.1.45"}

In [56]: s2 = {"192.168.1.55", "192.168.1.51"}

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.55'}

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.55'}

^异或运算

获取两个集合的分别独有的元素，组合为一个新的集合对象。

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.55'}

大型数据结构应用场景

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])

遥遥無期

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python-09 核心数据结构(二)

核心数据结构(二)四、字典映射类型数据结构介绍在字典存放的每个元素都是以一对儿键值对。在 Python 中字典通常被称为 dict，键称为 key，值称为 value字典中不可以存在相同的 key，但是 value 可以。高效创建字典空字典In [7]: d1 = {}In [8]: type(d1)Out[8]: dict字典中元素是无序的In [1]: d...
复制链接

扫一扫