Python数据结构

• Z时代
• 2024-01-10
• 分类：综合

目录

• Python内置的数据结构

  • 序列Sequence
  • 映射Mapping
  • 集合Sets

Python语言简洁明了，可以用较少的代码实现同样的功能。这其中Python内置的数据结构（可以统称为容器container）功不可没，主要是序列、映射以及集合三类主要的容器，最常用的为以下四个子类：

• list
• tuple
• dict
• set

序列Sequence

• list：列表，有序的 可变 序列

• tuple：元组，有序的 不可变 序列

• str：字符组成的 有序的 不可变 序列,字符可使用编码来理解
• bytes：字节组成的 有序的 不可变 序列

  • (区别:字符串是字符组成的序列,以一个字符为单位;字节序列是字节组成的序列,以字节为单位)

• bytearray：字节组成的 有序的 可变 序列

小技巧：查看一个类的内置方法

python">for _def in dir(list):
    if "__" in _def:   # 内部方法跳过
        continue
    else:
        print(_def)

对比list和tuple的结果如下：

PS：元组只不过是可读的列表，并由[]改为()

# 定义
empty_list = []
num_list = [1,2,3,4,5,6,7,8,9,10]
mix_list = [1,"str",[1,2],[3,4]]
empty_tuple = ()
num_tuple = (1,2,3,4,5,6,7,8,9,10)
mix_tuple = (1,"str",(1,2),[3,4])
# 增
empty_list.append("a")       # 插入元素，默认末端插入
empty_list.append("b")
empty_list.insert(0,"e")     # 指定位置插入元素
empty_list.insert(-1,"e")
empty_list.extend(["c","d"]) # 扩展，在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
empty_list.append(["c","d"])
# 拼接
print(num_list + mix_list)   # 拼接两个list
print(num_list * 3)          # 拼接三个相同的list
# 删
empty_list.remove("e") # 指定元素删除，# 移除列表中某个值的第一个匹配项
empty_list.pop()       # 弹栈，删除末端的一个元素
del(empty_list[-1])    # 非list内置方法
del(empty_list)        # 整个对象删除，连变量名都不存在了
empty_list.clear()     # 清空，变成空的列表[],变量还是存在的；与del不同，del后对象是不存在的，使用该变量的花会直接报错
# 改
empty_list[0] = 'change' 
# 查--切片
print(num_list)
print(num_list[0:2])
print(num_list[:2])
print(num_list[7:])
print(num_list[7:-1])
print(num_list[-3:])
print(num_list[-3:-1])
print(num_list[10:])
print(num_list[0:-1:3]) # 间隔切片
print(num_list[::3])    # 间隔切片
# 查--检验
print(4 in mix_list)
print(4 in mix_list[-1])
print(1 not in mix_list)
# 查--计数
print(len(num_list))        # 查看整个list的元素数量
print(num_list.count(10))   # 查看指定元素的数量
# 查
cmp(list1, list2)           # 比较两个列表的元素
print(num_list(1))          # 从列表中找出某个值第一个匹配项的索引位置
print(len(num_list))        # 查看整个list的元素数量
print(min(num_list))        # 返回列表元素最小值
print(max(num_list))        # 返回列表元素最大值
# 对象的复制
num_copy = num_list.copy()  # 使用copy才会在内存中开辟新的内存去存储num_copy的值
num_copy = num_list         # 简单的赋值语句只不过是两个不同的变量名指向同一块内存，感觉上就是改变一个，另一个也改变
num_copy = list(seq)        # 将元组转换为列表
# 顺序操作
num_list.reverse()          # 反向列表中元素
print(num_list)
num_list.sort()             # 对原列表进行排序,模式升序，配合reverse()，升降序就都实现了
print(num_list)

映射Mapping

• dict：字典

  • dict内置函数如下：

    • copy：返回一个字典的浅复制
    • fromkeys：以指定序列为键创建一个新字典，值都是一致的，使用场景很特定
    • update：以键批量更新的方法，（相同的更新，缺少的增补）
    • get：返回指定键的值，如果值不在字典中返回default值
    • setdefault：和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
    • pop：删除字典给定键 key 所对应的值，返回值为被删除的值；key值必须给出，否则返回default值
    • popitem：随机返回并删除字典中的一对键和值
    • clear：删除字典内所有元素，变为{}
    • items
    • keys
    • values

# 键必须是唯一的，但值则不必。
# 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组
# d = {key1 : value1, key2 : value2 }
dict1 = { 'abc': 456,'sss':'sss',100:100 }
dict2 = { 'abc': 123, 98.6: 37, 'sss':['a',3,5] }
dict3 = dict.fromkeys([1,2,3], [1,2,3])   # {1: [1, 2, 3], 2: [1, 2, 3], 3: [1, 2, 3]}
# 访问/取值，依靠键
dict2['abc']       # 返回123
dict2.get('abc','no')   # 效果一样,但如果建不存在，会方法默认值，这里设为no，默认值的参数默认是None
dict2.setdefault('s','sd') # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default，default默认为None
# 批量更新
dict2.update(dict1) # 相同的键，就更新值，缺少的键，直接增补
print(dict2)        # {98.6: 37, 100: 100, 'abc': 456, 'sss': 'sss'}
# 删除
print(dict2.pop("abc")) # 指定键，进行删除，并返回该键对应的值，如果键不存在，直接报错
print(dict2.popitem())  # 随机删除一对键值，并返回该对键值的元组形式
# 遍历
for k,v in dict2.items():
    print(k,":",v)
for k in dict2.keys():
    print(k)
for v in dict2.values():
    print(v)

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的

和list比较，dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而变慢
2. 需要占用大量的内存，内存浪费多

而list相反：

1. 查找和插入的时间随着元素的增加而增加
2. 占用空间小，浪费内存很少

所以，dict是用空间来换取时间的一种方法

dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）

集合Sets

• set：可变集合

  • set和dict类似，也是一组key的集合，但不存储value；这些key既不重复，也无序

• frozenset：不可变集合

参考：https://www.liaoxuefeng.com/

以上是 Python数据结构 的全部内容， 来源链接： utcz.com/z/388461.html