1.列表
1.1初始化列表&添加修改元素
if __name__ == '__main__':
#初始化一个长度为3 默认值为0的列表
arr1 = [0] * 7
#初始化一个空的列表 空列表如果向其添加元素只能使用append()
arr0 = []
#赋值(修改)元素
arr1[0] = 1
arr1[1] = 2
arr1[2] = 3
arr1[3] = 4
arr1[4] = 3
arr1[5] = 5
arr1[6] = 6
print("arr1初始值: {}".format(arr1))
# 继续添加元素
# arr1[7] = 7
# 注意:这种方式是错误的,因为我们指定了arr1的初始长度为7,所以索引最大为6,
#追加元素 使用append()
arr1.append(7)
print("arr1 追加一个元素7后: {}".format(arr1))
# 打印
# arr1初始值: [1, 2, 3, 4, 3, 5, 6]
# arr1 追加一个元素7后: [1, 2, 3, 4, 3, 5, 6, 7]
1.2删除元素
# pop(idx)方法 按照索引删除元素,默认删除末尾的元素并返回
x = arr1.pop()
y = arr1.pop()
print("arr1.poo() 删除末尾两个元素后: {}".format(arr1))
#remove(x)方法 删除列表中从左到右第一个x元素
arr1.remove(3)
print("arr1.remove 删除第一个元素3后: {}".format(arr1))
#根据索引删除
del arr1[0]
print("del arr1 删除索引为0的元素后: {}".format(arr1))
# 打印
# arr1.poo() 删除末尾两个元素后: [1, 2, 3, 4, 3, 5]
# arr1.remove 删除第一个元素3后: [1, 2, 4, 3, 5]
# del arr1 删除索引为0的元素后: [2, 4, 3, 5]
1.3其他常用方法
#将列表b中的元素全部添加到列表a中 (Java中的addAll())
a = [1, 3, 5]; b = [2, 4, 6]
a.extend(b)
print(a) #[1, 3, 5, 2, 4, 6]
# 注意:不能使用append(),使用append()那么b会当做一个列表会添加到a中.
# 就会变成[1, 3, 5, [2, 4, 6]]
#统计x元素在列表中出现的次数
cnt = list.count(x)
#判断元素x是否在列表中出现过
f = x in list
#返回列表中的最小值
min_v = min(list)
#返回列表中的最大值
max_v = max(list)
#找出元素x在列表中第一次出现的位置 注意:不存在报错 所以使用之前先判断是否存在
idx = list.index(x)
#反转列表
list.reverse()
#排序 默认从小到大(普通类型)
list.sort()
#加上reverse参数,从大到小排序
list.sort(reverse = True)
#判断两个列表的元素是否相同 借助operatot模块的eq方法
a = [1, 2]
b = [2, 3]
print(operator.eq(a, b)) # False
#遍历
#通过索引遍历
for i in range(len(list)): print(list[i])
#类似Java增强for循环遍历
for x in list: print(x)
1.4自定义排序
class Pair:
f = 0
s = 0
def __init__(self, f, s):
self.f = f
self.s = s
#类似Java的toString()方法
def __str__(self):
return "{} -- {}".format(self.f, self.s)
if __name__ == '__main__':
p1 = Pair(1, 22)
p2 = Pair(2, 21)
p3 = Pair(3, 223)
p4 = Pair(3, 32)
p5 = Pair(4, 21)
a = []
a.append(p1)
a.append(p2)
a.append(p3)
a.append(p4)
a.append(p5)
#sorted()不改变原序列 key:按照某个属性排序 False默认从小到大排序
sorted(a, key=lambda p: p.f, reverse=False)
#改变原序列 按照Pair的s属性排序,False从小到大排序
a.sort(key=lambda p: p.s, reverse=False)
for x in a:
print(x)
1.5二维数组
python是没有专门的二维数组的,我们可以使用列表的嵌套当做二维数组(列表)使用
if __name__ == '__main__':
# 创建一个4行3列的二维数组
a = [[0] * 3] * 4
# m行数 n列数
m = len(a)
n = len(a[0])
# 赋值
for i in range(m):
for j in range(n):
a[i][j] = 1
# 遍历
for i in range(m):
for j in range(n):
print(a[i][j], end=" ")
print()
2.栈
一般我们使用Python3的列表作为栈使用
stk = []
#入栈(将元素添加到最后)
stk.append()
#出栈(删除最后一个元素)
stk.pop()
3.集合
if __name__ == '__main__':
#根据一个列表创建一个集合
a = [1, 2, 3, 3, 4, 3, 5]
S3 = set(a)
#创建一个空集合
S = set()
#向集合中添加元素
S.add(1)
S.add(1)
S.add(2)
S.add(3)
#向集合中添加列表中的元素,
S.update([1, 2, 3], [2, 3, 4])
#判断x是否存在集合中 (x in set)
f = 4 in S
#移除元素 不存在报错
S.remove(11)
#移除元素 不存在不会报错
S.discard(2)
#遍历
for x in S:
print(x)
4.字典
if __name__ == '__main__':
# 创建一个空的字典
map = dict()
# 添加|修改元素 map[key] = value
map[1] = 2
map[2] = 2
map[3] = 2
map[4] = 3
#添加键值对,当key不存在时设置默认值
map.setdefault(9, 0)
# 根据key删除键值对
map.pop(1)
# 根据key删除键值对
del map[2]
# 根据key获取value,注意key不存在时报错
x = map[3]
# 根据key获取value,key不存在时不报错
map.get(1)
# 重载方法 根据key获取value,如果key不存在返回默认值 map.get(key, default_val)
map.get(9, 12)
# 将字典中的所有key取出并转换成一个列表
keys = list(map.keys())
# 将字典中的所有value取出并转换成一个列表
values = list(map.values())
# 判断key为x的键值对是否存在于字典中
f = 3 in map
#获取字典中所有的键值对
items = map.items()
#遍历每一个键值对
for k, v in map.items():
print(k, "---", v)
5.(双端)队列
from collections import deque
if __name__ == '__main__':
#创建一个空的双端队列
q = deque()
#第一种组合,尾进头出
# 队列末尾进
q.append(1)
q.append(2)
q.append(3)
# 队列头出
x = q.popleft()
y = q.popleft()
z = q.popleft()
#--------------------------------------------------------
#第二种组合,头进尾出
#队头进
q.appendleft(1)
q.appendleft(2)
q.appendleft(3)
#队尾出
x = q.pop()
y = q.pop()
z = q.pop()
#---------------作为栈使用-----------------------------------------
#当然,双端队列,每一端都可以作为栈使用
# append() + pop() 尾进尾出
# appendleft() + popleft() 头进头出
7.优先队列
使用heapq操作
class Solution:
def topKFrequent(self, nums: List[int], n: int) -> List[int]:
import heapq
heap = []; ans = []
map = dict()
for x in nums:
map.setdefault(x, 0) # x不存在设置默认值为0
map[x] += 1
#将元素添加到堆中,优先级根据次数排列,
for k, v in map.items():
heapq.heappush(heap, (-v, k))
for i in range(len(heap)):
if n == 0: return ans
v, k = heapq.heappop(heap) #弹出堆顶元素
ans.append(k); n -= 1
return ans
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
import heapq
dummy = ListNode(0); cur = dummy
heap = []
#将链表头加入堆中,值越小优先级越高
for i in range(len(lists)):
if lists[i]: heapq.heappush(heap, (lists[i].val, i))
while heap:
val, idx = heapq.heappop(heap) #弹出队头元素,取出下标
node = lists[idx]; cur.next = node; cur = cur.next
if node.next:
heapq.heappush(heap, (node.next.val, idx))
lists[idx] = lists[idx].next
return dummy.next