目录
- 一、 数组 list()
- 二、字符串 str()
- 三、队列 from queue import Queue
- 四、优先队列,PriorityQueue与heap (默认小顶堆)
- from queue import PriorityQueue
- import heap as hp (将list转换为等价的优先队列)
- 五、栈 stack
- 1. (list 模拟栈)
- 2. 自己构造一个class Stack
- 六、双端队列 from collections import deque
- 七、有序集合 from sortedcontainers import SortedSet (类似于c++ 的set)
- 1. 升序set
- 2. 降序set
- 3. SortedSet 转为 list/tuple/set
- 4. 插入、删除元素
- 5. 返回第一个和最后一个元素
- 6. 遍历 set
- 7. set 中判断某元素是否存在
- 8. bisect_left() / bisect_right() 二分搜索
- 八、无序集合 set() (类似于unordered_set)
- 1. 无序集合间的操作, 下面的运算法符都可以写成 op= 的形式
- 2. 无序集合的处理方法
- 九、有序可重复集合,from sortedcontainers import SortedList, 类似于 multiset
- 十、有序map,from sortedcontainers import SortedDict, 相当于cpp的map
- 1. bisect_left() / bisect_right() 二分查找
- 十一、无序字典 from collections imort defaultdict,相当于cpp的unordered_map
补充,print() 参数的解释
sep参数 – 用来间隔多个对象,默认值是一个空格
end参数 – 用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符串;“end=’ '”意思是末尾不换行,加空格。
file参数 – 要写入的文件对象。
flush参数 – 输出是否被缓存通常决定于 file,但如果 flush 关键字参数为 True,流会被强制刷新。
一、 数组 list()
python中 list()默认可以添加任何数据类型进入数组
C++则需要提前声明
声明列表的五种方式:(l4,l5比较快)
l1 = []
for i in range(1000): l1.append(i)
l2 = []
for i in range(1000): l2 += [i]
l3 = [0 for _ in range(1000)]
l4 = [0]*1000
l5 = list(range(1000))
方法:
-
pop()
: O(1) -
pop(i)
: O(n) -
insert(i, item)
: O(n) -
in list() -> bool
: O(n) 包含 -
list()[2:4] -> list()
: 数据切片 -
list().index(2, 1, 3) ->list
: 返回序列s从1开始到3位置中第一次出现元素2的位置,不存在产生ValueError异常 -
list().count(12)
: 返回 list 中出现12的总次数 -
list(),reverse()
: 反转列表 -
list().extend(list())
: 两个列表合并
举例
print(10 in l1) # True
print(0 not in l1) # False
二、字符串 str()
三、队列 from queue import Queue
方法:
- 入队:
Queue().put()
- 出队:
Queue().get()
- 是否为空:
Queue.empty()
- 队列size:
Queue.qsize()
使用list模拟
# queue: 使用list模拟队列
q = [] # 定义队列
q.append(4) # 入队 [4]
q.append(3) # 入队 [4, 3]
q.append(7) # 入队 [4, 3, 7]
q.pop(0) # 队首出队 [3, 7]`
四、优先队列,PriorityQueue与heap (默认小顶堆)
-
PriorityQueue
, 基于类的实现 -
heap
,基于函数方法实现,在原数组上修改(速度更快)
注意:该方法 只能保证 堆顶元素为最小值
from queue import PriorityQueue
from queue import PriorityQueue
heap = PriorityQueue()
heap.put((2, 'hi'))
heap.put((1, 'hello'))
heap.put((3, 'world'))
print(heap.queue)
# 输出堆中所有元素 [(1, ‘hello’), (2, ‘hi’), (3, ‘world’)]print(heap.queue[0])
# 输出堆顶元素, 不删除 (1, ‘hello’)print(heap.get())
# 输出堆顶元素, 并删除堆顶元素(1, ‘hello’)print(heap.qsize())
: 2
python3中不能向PriorityQueue添加参数变为大顶堆,
- 方法1:自己封装一个,
- 方法2:插入 负值
import heapq
class MaxHeap(object):
def __init__(self, x):
self.heap = [-e for e in x]
heapq.heapify(self.heap)
def put(self, value):
heapq.heappush(self.heap, -value)
def get(self):
return -heapq.heappop(self.heap)
import heap as hp (将list转换为等价的优先队列)
heapify(nums: List[int])->None
:保证 堆顶为最小值,
如要实现堆排序,则需借助 heappop
,
import heapq as hq
nums = [3,2,4,7,2,4,88,90,4]
hq.heapify(nums)
# [2, 2, 4, 4, 3, 4, 88, 90, 7]
cur = hq.heappop(nums)
# [2, 3, 4, 4, 7, 4, 88, 90]
hq.heappop(nums)
hq.heappush(nums, 1)
# [1, 2, 4, 3, 7, 4, 88, 90, 4]
五、栈 stack
1. (list 模拟栈)
stk = []
stk.append(20) # 入栈
stk.append(10)
stk.append(30)
stk.pop(len(stk) - 1) # 出栈
stk.pop() # 出栈,会返回值
stk.clear() # 清空栈
print(len(stk)) # 获取栈中元素个数 0
print(len(stk) == 0) # 判断栈是否为空 True
2. 自己构造一个class Stack
class Stack:
def __init__(self):
self.items = []
def empty(self): return self.items==[]
def push(self, item): self.items.append(item)
def pop(self): return self.items.pop()
def top(self): #return self.items[self.size()] 越界
return self.items[self.size()-1]
def size(self): return len(self.items)
六、双端队列 from collections import deque
from collections import deque
# 定义 deque
d = deque()
- 插入、删除元素
d.append(20)
# 队尾插入一个元素 deque([20])d.append(10)
# 队尾插入一个元素 deque([20, 10])d.pop()
# 弹出一个尾部数据 deque([20])d.appendleft(40)
# 队首插入一个元素 deque([40, 20])d.appendleft(30)
# 队首插入一个元素 deque([30, 40, 20])d.popleft()
# 弹出一个队首数据 deque([40, 20]) - 遍历
for x in d:
print(x, end=", ") # end 是print()的参数
- 返回队首和队尾元素
print(d[0])
# 队首元素 40print(d[len(d) - 1])
# 队尾元素 20 - 清空 deque
d.clear()
print(len(d)) # 0
print(len(d) == 0) # True
七、有序集合 from sortedcontainers import SortedSet (类似于c++ 的set)
1. 升序set
from sortedcontainers import SortedSet
ss = SortedSet([3, 1, 2, 5, 4])
print(ss) # SortedSet([1, 2, 3, 4, 5])
2. 降序set
from operator import neg
ss1 = SortedSet([3, 1, 2, 5, 4], neg)
print(ss1) # SortedSet([5, 4, 3, 2, 1], key=<built-in function neg>)
3. SortedSet 转为 list/tuple/set
print(list(ss)) # SortedSet转为list [1, 2, 3, 4, 5]
print(tuple(ss)) # SortedSet转为tuple (1, 2, 3, 4, 5)
print(set(ss)) # SortedSet转为set {1, 2, 3, 4, 5}
4. 插入、删除元素
ss.discard(-1) # 删除不存在的元素不报错
ss.remove(1) # 删除不存在的元素报错, KeyError
ss.discard(3) # SortedSet([1, 2, 4, 5])
ss.add(-10) # SortedSet([-10, 1, 2, 4, 5])
5. 返回第一个和最后一个元素
类似于c++的 set.begin(); --set.end()
print(ss[0]) # -10
print(ss[-1]) # 5
6. 遍历 set
for e in ss:
print(e, end=", ") # -10, 2, 4, 5,
print()
7. set 中判断某元素是否存在
print(2 in ss)
# True
8. bisect_left() / bisect_right() 二分搜索
print(ss.bisect_left(4)) # 返回大于等于4的最小元素对应的下标 2
print(ss.bisect_right(4)) # 返回大于4的最小元素对应的下标 3
# 清空 set
ss.clear()
print(len(ss)) # 0
print(len(ss) == 0) # True`
八、无序集合 set() (类似于unordered_set)
两种定义:
A = {"hi", 2, ("we", 24)}
B = set() # 空集合的定义,不能使用B = {}定义集合,这样是字典的定义
1. 无序集合间的操作, 下面的运算法符都可以写成 op= 的形式
print("---------------------------------------")
S = {1, 2, 3}
T = {3, 4, 5}
print(S & T) # 交集,返回一个新集合,包括同时在集合S和T中的元素
print(S | T) # 并集,返回一个新集合,包括在集合S和T中的所有元素
print(S - T) # 差集,返回一个新集合,包括在集合S但不在T中的元素
print(S ^ T) # 补集,返回一个新集合,包括集合S和T中的非相同元素
# 集合的包含关系
print("---------------------------------------")
C = {1, 2}
D = {1, 2}
print(C <= D) # C是否是D的子集 True
print(C < D) # C是否是D的真子集 False
print(C >= D) # D是否是C的子集 True
print(C > D) # D是否是C的真子集 False
2. 无序集合的处理方法
print("---------------------------------------")
S = {1, 2, 3, 5, 6}
S.add(4) # 如果x不在集合S中,将x增加到S
S.discard(1) # 移除S中元素x,如果x不在集合S中,不报错
S.remove(2) # 移除S中元素x,如果x不在集合S中,产生KeyError异常
for e in S: # 遍历
print(e, end=",")
print()
print(S.pop()) # 从S中随机弹出一个元素,S长度减1,若S为空产生KeyError异常
print(S.copy()) # 返回集合S的一个副本, 对该副本的操作不会影响S
print(len(S)) # 返回集合S的元素个数
print(5 in S) # 判断S中元素x, x在集合S中,返回True,否则返回False
print(5 not in S) # 判断S中元素x, x在集合S中,返回True,否则返回False
S.clear() # 移除S中所有元素
九、有序可重复集合,from sortedcontainers import SortedList, 类似于 multiset
"""
网址:http://www.grantjenks.com/docs/sortedcontainers/sortedlist.html
"""
from sortedcontainers import SortedList
# 定义
sl = SortedList(key=lambda x: -x) # 降序
sl = SortedList([3, 1, 2, 1, 5, 4]) # 升序
print(sl) # SortedList([1, 1, 2, 3, 4, 5])
# 插入、删除元素
sl.add(3)
sl.add(3)
sl.discard(2) # SortedList([1, 1, 3, 3, 3, 4, 5])
print(sl)
# 统计某个元素出现的次数
print(sl.count(3)) # 3
# 返回第一个和最后一个元素
print(sl[0]) # 1
print(sl[-1]) # 5
# 遍历 set
for e in sl:
print(e, end=", ") # 1, 1, 3, 3, 3, 4, 5,
print()
# 判断某元素是否存在
print(2 in sl) # False
# bisect_left() / bisect_right()
print(sl.bisect_left(3)) # 返回大于等于3的最小元素对应的下标 2
print(sl.bisect_right(3)) # 返回大于3的最小元素对应的下标 5
# 清空
sl.clear()
print(len(sl)) # 0
print(len(sl) == 0) # True
十、有序map,from sortedcontainers import SortedDict, 相当于cpp的map
from sortedcontainers import SortedDict
sd = SortedDict()
# 插入、删除元素
sd["wxx"] = 21
sd["hh"] = 18
sd["other"] = 20
print(sd) # SortedDict({'hh': 18, 'other': 20, 'wxx': 21})
print(sd["wxx"]) # 访问不存在的键会报错, KeyError
print(sd.get("c")) # 访问不存在的键会返回None None
# SortedDict转dict
print(dict(sd)) # {'hh': 18, 'other': 20, 'wxx': 21}
# 返回最后一个元素和最后一个元素
print(sd.peekitem(0)) # 类型tuple, 返回第一个元素 ('hh', 18)
print(sd.peekitem()) # 类型tuple, 返回最后一个元素 ('wxx', 21)
# 遍历
for k, v in sd.items():
print(k, ':', v, sep="", end=", ") # sep取消每行输出之间的空格
print()
for k in sd: # 遍历键k, 等价于for k in d.keys:
print(str(k) + ":" + str(sd[k]), end=", ")
print()
for v in sd.values(): # 遍历值v
print(v, end=", ")
print()
# 返回Map中的一个键
print(sd.peekitem()[0])
# 返回Map中的一个值
print(sd.peekitem()[1])
# 中判断某元素是否存在
print("wxx" in sd) # True
1. bisect_left() / bisect_right() 二分查找
sd["a"] = 1
sd["c1"] = 2
sd["c2"] = 4
print(sd) # SortedDict({'a': 1, 'c1': 2, 'c2': 4, 'hh': 18, 'other': 20, 'wxx': 21})
print(sd.bisect_left("c1")) # 返回键大于等于"c1"的最小元素对应的下标 1
print(sd.bisect_right("c1")) # 返回键大于"c1"的最小元素对应的下标 2
# 清空
sd.clear()
print(len(sd)) # 0
print(len(sd) == 0) # True
十一、无序字典 from collections imort defaultdict,相当于cpp的unordered_map
注意这里于dict(), {}
的不同,dict
不能访问不存在的元素,
而collections.defaultdict
可以,默认生成一个None
# 字典树
Trie = lambda: collections.defaultdict(Trie)
trie = Trie()
# 普通字典
d = {"c1": 2, "c2": 4, "hh": 18, "wxx": 21, 13: 14, 1: 0}
d2 = dict()
print(d["wxx"]) # 21
print(d[13]) # 14
d[13] += 1
print(d[13]) # 15
d["future"] = "wonderful" # 字典中添加键值对
del d[1] # 删除字典d中键1对应的数据值
print("wxx" in d) # 判断键"wxx"是否在字典d中,如果在返回True,否则False
print(d.keys()) # 返回字典d中所有的键信息 dict_keys(['c1', 'c2', 'hh', 'wxx', 13])
print(d.values()) # 返回字典d中所有的值信息 dict_values([2, 4, 18, 21, 14])
print(d.items()) # dict_items([('c1', 2), ('c2', 4), ('hh', 18), ('wxx', 21), (13, 14)])
for k, v in d.items(): # 遍历 k, v
print(k, ':', v)
for k in d: # 遍历键k, 等价于for k in d.keys:
print(str(k) + ":" + str(d[k]), end=", ")
print()
for v in d.values(): # 遍历值v
print(v, end=", ")
print()
# 字典类型操作函数和方法
print("---------------------------------------")
d = {"中国": "北京", "美国": "华盛顿", "法国": "巴黎"}
print(len(d)) # 返回字典d中元素的个数 3
print(d.get("中国", "不存在")) # 键k存在,则返回相应值,不在则返回<default>值 北京
print(d.get("中", "不存在")) # 不存在
print(d.get("中")) # None
d["美国"] = "Washington" # 修改键对应的值
print(d.pop("美国")) # 键k存在,则返回相应值,并将其从dict中删除
print(d.popitem()) # 随机从字典d中取出一个键值对,以元组形式返回,并将其从dict中删除
d.clear() # 删除所有的键值对