全网最全Python数据结构集锦：列表（list）篇

全网最全Python数据结构集锦：列表（list）篇

目录

列表 list

1. 创建list的两种方法2. 增删查改

2.1 插入 *** 作2.2 删除 *** 作2.3 查找 *** 作2.4 改值 *** 作 3. 排序4. 计数5. 栈 *** 作6. 堆 *** 作

列表 list

本文源代码可以在这里找到：链接

列表是最基本的数据结构，可以当作栈来使用，也可以存入不同类型的数据，例如同一个列表可存入字符，数字，还有列表等等。

mylist = [1,2,3]
print(f"Mylist {mylist}")

mylist = [1,"Hello",["World", "!!!", 999]]
print(f"Mixed {mylist}")

output:

Mylist [1, 2, 3]
Mixed [1, 'Hello', ['World', '!!!', 999]]

1. 创建list的两种方法

mylist1 = []
mylist2 = list()

print(mylist1, mylist2)

mylist = [2,3,4,5]

# 切片：取列表的部分元素, 左闭右开
print(mylist[1:4])

# 反转列表
print("反转前",mylist)
print("反转后",mylist[::-1]) # 不在原地址反转
print("反转前",mylist)
mylist.reverse() # 在原地址上修改
print("反转后",mylist)

Output：

[] []
[3, 4, 5]
反转前 [2, 3, 4, 5]
反转后 [5, 4, 3, 2]
反转前 [2, 3, 4, 5]
反转后 [5, 4, 3, 2]

2. 增删查改 2.1 插入 *** 作

# 增 *** 作
mark = "-"
print(f"{mark*10}插入 *** 作{mark*10}")
# 1. 在末尾插入
mylist = [5,6,7,8]
print(f"n原列表:{mylist}")
mylist.append(6)
print(f"在尾部插入{mylist}")

# 2. 在指定位置插入
mylist = [5,6,7,8]
print(f"n原列表:{mylist}")
mylist.insert(0, 0)
print(f"在值插入0位置 {mylist}")

Output：

----------插入 *** 作----------

原列表:[5, 6, 7, 8]
在尾部插入[5, 6, 7, 8, 6]

原列表:[5, 6, 7, 8]
在值插入0位置 [0, 5, 6, 7, 8]

2.2 删除 *** 作

# 删除 *** 作
print(f"{mark*10}删除 *** 作{mark*10}")
# 1. 按照值来删除, remove  *** 作会找到列表中第一个符合该值的元素删除，所以最好还是使用索引删除
mylist = [5,6,7,8]
print(f"n原列表:{mylist}")
mylist.remove(6)
print(f"删除值为6的值:{mylist}")

# 2. 按照索引删除
mylist = [5,6,7,8]
print(f"n原列表:{mylist}")
del mylist[1]
print(f"删除索引为1的值:{mylist}")

# 3. 推出列表顶部位置
mylist = [5,6,7,8]
print(f"n原列表:{mylist}")
mylist.pop()
print(f"推出列表顶部位置:{mylist}")

# 4. 按索引pop
mylist = [5,6,7,8]
print(f"n原列表:{mylist}")
mylist.pop(2)
print(f"推出列表索引为2的值:{mylist}")

Output：

----------删除 *** 作----------

原列表:[5, 6, 7, 8]
删除值为6的值:[5, 7, 8]

原列表:[5, 6, 7, 8]
删除索引为1的值:[5, 7, 8]

原列表:[5, 6, 7, 8]
推出列表顶部位置:[5, 6, 7]

原列表:[5, 6, 7, 8]
推出列表索引为2的值:[5, 6, 8]

2.3 查找 *** 作

# 查找 *** 作
print(f"{mark*10}查找 *** 作{mark*10}")

# 1. 按索引正序查找
mylist = [5,6,7,8]
print(f"n原列表:{mylist}")
print(mylist[1], mylist[2])

# 2. 按索引逆序查找, -1表示最后一个，-2表示倒数第二，以此类推
mylist = [5,6,7,8]
print(f"n原列表:{mylist}")
print(mylist[-1],mylist[-2])

# 3. 判断是否在列表中
mylist = [5,6,7,8,5]
print(f"n原列表:{mylist}")
print(f"5 在列表:{mylist}中, ",5 in mylist)
print(f"5 不在列表:{mylist}中, ",5 not in mylist)

# 在列表从左往右，找到第一个就返回
print(f"5 在列表中的索引为{mylist.index(5)}")

# 在切片位置中，2：5 左开右闭
print(f"5 在列表中的索引为{mylist.index(5, 2,5)}")

Output：

----------查找 *** 作----------

原列表:[5, 6, 7, 8]
6 7

原列表:[5, 6, 7, 8]
8 7

原列表:[5, 6, 7, 8, 5]
5 在列表:[5, 6, 7, 8, 5]中,  True
5 不在列表:[5, 6, 7, 8, 5]中,  False
5 在列表中的索引为0
5 在列表中的索引为4

2.4 改值 *** 作

# 按索引改值
print(f"{mark*10}改值 *** 作{mark*10}")

# 1. 按索引正序查找
mylist = [5,6,7,8]
print(f"n原列表:{mylist}")
mylist[1] = 0
print(mylist)

# 2. 切片改值
mylist = [5,6,7,8]
print(f"n原列表:{mylist}")
mylist[1:3] = [2,1]
print(mylist)

Output：

----------改值 *** 作----------

原列表:[5, 6, 7, 8]
[5, 0, 7, 8]

原列表:[5, 6, 7, 8]
[5, 2, 1, 8]

3. 排序

print(f"{mark*10}排序 *** 作{mark*10}")

# 1. sort 直接在地址修改没有返回值
mylist = [4,3,2,1,5]
print(f"n原列表:{mylist}")
mylist.sort()
print(mylist)

# 2. sorted 创建新的数组，原数组不变
mylist = [4,3,2,1,5]
print(f"n原列表:{mylist}")
mylist2 = sorted(mylist)
print(mylist)
print(mylist2)

# 3. lambda 表达式
mylist = [4,3,2,1,5]
print(f"n原列表:{mylist}")
mylist.sort(key=lambda x: x)
print("升序:",mylist)
mylist.sort(key=lambda x: -x)
print("降序", mylist)

# 4. lambda 表达式
# 二维数组
mylist = [[2,1],[3,2],[0,1],[4,7]]
print(f"n原列表:{mylist}")
mylist.sort(key=lambda x: x[0])
print("按第一个元素升序:",mylist)
mylist.sort(key=lambda x: -x[1])
print("按第二个元素降序:",mylist)

mylist = [[2,1],[3,2],[0,1],[4,7],[4,5],[2,-1]]
print(f"n原列表:{mylist}")
mylist.sort(key=lambda x:[x[0],x[1]])
print("按第一个元素升序,如果相同，按第二个元素升序:",mylist)

mylist.sort(key=lambda x:[x[0],-x[1]])
print("按第一个元素升序,如果相同，按第二个元素降序:",mylist)

Output：

----------排序 *** 作----------

原列表:[4, 3, 2, 1, 5]
[1, 2, 3, 4, 5]

原列表:[4, 3, 2, 1, 5]
[4, 3, 2, 1, 5]
[1, 2, 3, 4, 5]

原列表:[4, 3, 2, 1, 5]
升序: [1, 2, 3, 4, 5]
降序 [5, 4, 3, 2, 1]

原列表:[[2, 1], [3, 2], [0, 1], [4, 7]]
按第一个元素升序: [[0, 1], [2, 1], [3, 2], [4, 7]]
按第二个元素降序: [[4, 7], [3, 2], [0, 1], [2, 1]]

原列表:[[2, 1], [3, 2], [0, 1], [4, 7], [4, 5], [2, -1]]
按第一个元素升序,如果相同，按第二个元素升序: [[0, 1], [2, -1], [2, 1], [3, 2], [4, 5], [4, 7]]
按第一个元素升序,如果相同，按第二个元素降序: [[0, 1], [2, 1], [2, -1], [3, 2], [4, 7], [4, 5]]

4. 计数

print(f"{mark*10}计数 *** 作{mark*10}")

# 统计元素a在列表中出现的次数
a = 5
mylist = [1,2,3,5,5,5,4,3,2]
time = mylist.count(a)
print("原列表", mylist)
print(f"{a} 在列表中出现的次数为{time}")

# Counter: 统计每一个元素出现的次数
# 并生成字典，key为element， value 为次数
from collections import Counter
freq = Counter(mylist)
print(freq)

Output：

原列表 [1, 2, 3, 5, 5, 5, 4, 3, 2]
5 在列表中出现的次数为3
Counter({5: 3, 2: 2, 3: 2, 1: 1, 4: 1})

5. 栈 *** 作

print(f"{mark*10}栈 *** 作{mark*10}")

stack = []
    
# 入栈
stack.append(1)
stack.append(-1)
print(stack)

# 出栈
stack.pop()
print(stack)

# 栈大小
print(len(stack))

Output:

----------栈 *** 作----------
[1, -1]
[1]
1

6. 堆 *** 作

大顶堆：每个节点(叶节点除外)的值都大于等于其子节点的值，根节点的值是所有节点中最大的。

小顶堆：每个节点(叶节点除外)的值都小于等于其子节点的值，根节点的值是所有节点中最小的。

参考：https://blog.csdn.net/weixin_43790276/article/details/107741332

print(f"{mark*10}堆 *** 作{mark*10}")

import heapq
mylist = [12,14,16,3,2,5,1]
heap = []

for ele in mylist:
    heapq.heappush(heap, ele)
print(mylist)
print(heap)
# 直接将列表转成堆
heapq.heapify(mylist)
print(mylist)
print("两者存在小差异，但不影响堆的 *** 作n")

for _ in range(len(mylist)):
    # 取出堆顶
    print(heapq.heappop(heap), heapq.heappop(mylist))

Output：

----------堆 *** 作----------
[12, 14, 16, 3, 2, 5, 1]
[1, 3, 2, 14, 12, 16, 5]
[1, 2, 5, 3, 14, 12, 16]
两者存在小差异，但不影响堆的 *** 作

1 1
2 2
3 3
5 5
12 12
14 14
16 16