Python蓝桥杯算法模板
Python蓝桥杯算法模板
今天来给大家分享超实用的Python蓝桥杯算法模板，助力大家在蓝桥杯比赛中披荆斩棘~
目录
- sys库
- math库
- datetime库
- queue库
- list常用api
- set常用api
- str常用api
- 进制转换与排序
- 并查集（DSU）
- 最短路径（Dijkstra）
- 线段树（SegTree）
sys库
sys库是Python的标准库，它提供了许多与Python解释器和系统环境相关的功能。比如sys.stdin和sys.stdout可以用于更高效的输入输出，在蓝桥杯这种对时间有一定要求的比赛中，合理使用可以提升程序运行效率。
math库
math库包含了许多数学运算相关的函数，如计算平方根的math.sqrt()，计算幂次方的math.pow() 等。在解决几何、数值计算等类型的题目时，math库能派上大用场。
datetime库
datetime库用于处理日期和时间相关的
目录
- sys库
- math库
- datatime库
- queue库
- list常用api
- set常用api
- str常用api
- 进制转换与排序
- 并查集（DSU）
- 最短路径（Dijkstra）
- 线段树（SegTree）
sys库
import sys
# 快读函数
def read():
return int(sys.stdin.readline().strip())
def read_list():
return list(map(int, sys.stdin.readline().strip().split()))
# 快写函数
def write(result, end='\n'):
sys.stdout.write(str(result) + end)
# 提前结束整个程序
if __name__ == "__main__":
sys.exit()
math库
import math
# 四舍五入和取整函数
x = 3.1415926
print("四舍五入保留两位小数:", round(x, 2))
print("向上取整:", math.ceil(x))
print("向下取整:", math.floor(x))
print("向零取整:", int(x))
# 幂和对数函数
print("平方根:", math.sqrt(4))
print("幂运算:", math.pow(2, 4))
print("自然对数:", math.log(math.e))
print("以 10 为底的对数:", math.log10(100))
# 三角函数
angle_rad = math.radians(45)
print("正弦值:", math.sin(angle_rad))
print("余弦值:", math.cos(angle_rad))
print("正切值:", math.tan(angle_rad))
print("反正弦值:", math.degrees(math.asin(0.5)))
print("反余弦值:", math.degrees(math.acos(0.5)))
print("反正切值:", math.degrees(math.atan(1)))
# 角度和弧度转换函数
angle_deg = 90
print("角度转弧度:", math.radians(angle_deg))
print("弧度转角度:", math.degrees(math.pi / 2))
# 绝对值和其他函数
print("浮点绝对值:", math.fabs(-1))
print("阶乘:", math.factorial(5))
print("最大公约数:", math.gcd(12, 18))
datatime库
import datetime
date1 = datetime.date(2022, 1, 1)
date2 = datetime.date(2023, 1, 1)
day = datetime.timedelta(days=1)
while date1 < date2:
# 访问日期的年、月、日
print("年:", date1.year)
print("月:", date1.month)
print("日:", date1.day)
date1 += day
queue库
import queue
# Queue (FIFO) 示例
q = queue.Queue(maxsize=3)
q.put(1)
q.put(2)
q.put(3)
print("队列是否已满:", q.full())
print("取出元素:", q.get())
print("队列是否为空:", q.empty())
print("队列中剩余元素数量:", q.qsize())
# LifoQueue (LIFO) 示例
lifo_q = queue.LifoQueue()
lifo_q.put(1)
lifo_q.put(2)
lifo_q.put(3)
print("取出元素:", lifo_q.get())
# PriorityQueue 示例
# 定义一个自定义类
class Task:
def __init__(self, priority, name):
self.priority = priority
self.name = name
def __lt__(self, other):
# 自定义排序规则：优先级高的任务优先
return self.priority > other.priority
def __repr__(self):
return f"Task(priority={self.priority}, name={self.name})"
# 创建一个 PriorityQueue
priority_q = queue.PriorityQueue()
# 向队列中添加任务
priority_q.put(Task(2, "task2"))
priority_q.put(Task(1, "task1"))
priority_q.put(Task(3, "task3"))
# 从队列中取出任务
while not priority_q.empty():
task = priority_q.get()
print("取出任务:", task)
list
# 创建列表
# 使用方括号创建列表
empty_list = []
numbers = [1, 2, 3, 4, 5]
mixed_list = [1, "hello", True]
# 使用 list() 构造函数创建列表
from_tuple = list((1, 2, 3))
from_string = list("hello")
print("空列表:", empty_list)
print("数字列表:", numbers)
print("混合类型列表:", mixed_list)
print("从元组创建的列表:", from_tuple)
print("从字符串创建的列表:", from_string)
# 基本操作 - 访问元素
fruits = ["apple", "banana", "cherry", "date"]
print("第一个元素:", fruits[0])
print("获取第 2 到第 3 个元素:", fruits[1:3])
# 基本操作 - 修改元素
numbers = [1, 2, 3]
numbers[1] = 10
print("修改后的列表:", numbers)
# 基本操作 - 拼接和重复
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2
repeated_list = list1 * 3
print("拼接后的列表:", combined_list)
print("重复后的列表:", repeated_list)
# 添加元素 - append() 方法
fruits = ["apple", "banana"]
fruits.append("cherry")
print("使用 append() 方法后:", fruits)
# 添加元素 - extend() 方法
fruits = ["apple", "banana"]
new_fruits = ["cherry", "date"]
fruits.extend(new_fruits)
print("使用 extend() 方法后:", fruits)
# 添加元素 - insert() 方法
numbers = [1, 2, 3]
numbers.insert(1, 10)
print("使用 insert() 方法后:", numbers)
# 删除元素 - remove() 方法，未找到异常
fruits = ["apple", "banana", "cherry"]
fruits.remove("banana")
print("使用 remove() 方法后:", fruits)
# 删除元素 - pop() 方法
numbers = [1, 2, 3]
popped = numbers.pop(1)
print("弹出的元素:", popped)
print("使用 pop() 方法后:", numbers)
# 删除元素 - clear() 方法
fruits = ["apple", "banana", "cherry"]
fruits.clear()
print("使用 clear() 方法后:", fruits)
# 查找元素 - index() 方法，未找到异常
fruits = ["apple", "banana", "cherry"]
print("banana 的索引:", fruits.index("banana"))
# 查找元素 - count() 方法
numbers = [1, 2, 2, 3, 2]
print("数字 2 出现的次数:", numbers.count(2))
# 排序 - sort() 方法
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
numbers.sort()
print("使用 sort() 方法排序后:", numbers)
# 反转 - reverse() 方法
numbers = [1, 2, 3]
numbers.reverse()
print("使用 reverse() 方法反转后:", numbers)
set
# 创建集合
# 使用花括号直接创建集合，集合中的元素具有唯一性
fruits = {"apple", "banana", "cherry"}
print("使用花括号创建的集合:", fruits)
# 使用 set() 构造函数创建集合，传入一个可迭代对象，会自动去除重复元素
numbers = set([1, 2, 3, 4, 4])
print("使用 set() 构造函数创建的集合:", numbers)
# 创建空集合，注意不能使用 {} 创建空集合，因为 {} 表示空字典，必须使用 set()
empty_set = set()
print("空集合:", empty_set)
# 基本操作 - 添加元素
# add() 方法：向集合中添加一个元素，如果元素已存在，集合不会有任何变化
fruits = {"apple", "banana"}
fruits.add("cherry")
print("使用 add() 后集合:", fruits)
# update() 方法：将一个可迭代对象中的所有元素添加到集合中
new_fruits = ["cherry", "date"]
fruits.update(new_fruits)
print("使用 update() 后集合:", fruits)
# 基本操作 - 删除元素
# remove() 方法：移除集合中的指定元素，如果元素不存在，会抛出 KeyError 异常
fruits = {"apple", "banana", "cherry"}
fruits.remove("banana")
print("使用 remove() 后集合:", fruits)
# discard() 方法：移除集合中的指定元素，如果元素不存在，不会抛出异常
fruits = {"apple", "banana", "cherry"}
fruits.discard("date")
print("使用 discard() 后集合:", fruits)
# pop() 方法：随机移除并返回集合中的一个元素，如果集合为空，会抛出 KeyError 异常
fruits = {"apple", "banana", "cherry"}
popped_fruit = fruits.pop()
print("使用 pop() 弹出元素:", popped_fruit)
print("使用 pop() 后集合:", fruits)
# clear() 方法：清空集合中的所有元素
fruits = {"apple", "banana", "cherry"}
fruits.clear()
print("使用 clear() 后集合:", fruits)
# 集合运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}
# 使用 | 运算符：用于计算两个集合的并集
union_set_op = set1 | set2
print("使用 | 运算符得到的并集:", union_set_op)
# 使用 & 运算符：用于计算两个集合的交集
intersection_set_op = set1 & set2
print("使用 & 运算符得到的交集:", intersection_set_op)
# 使用 - 运算符：用于计算两个集合的差集
difference_set_op = set1 - set2
print("使用 - 运算符得到的差集:", difference_set_op)
str
# 创建字符串
# 使用双引号
str1 = "Hello"
# 使用双引号
str2 = "World"
print("双引号创建的字符串:", str1)
print("双引号创建的字符串:", str2)
# 基本操作 - 拼接
# 使用 + 运算符
combined_str1 = str1 + " " + str2
print("使用 + 运算符拼接结果:", combined_str1)
# 使用 join() 方法
words = ["Hello", "World"]
combined_str2 = " ".join(words)
print("使用 join() 方法拼接结果:", combined_str2)
# 基本操作 - 重复
repeated_str = str1 * 3
print("使用 * 运算符重复字符串结果:", repeated_str)
# 基本操作 - 访问字符
# 索引
print("访问字符串 str1 的第一个字符:", str1[0])
# 切片
print("对字符串 str1 进行切片操作 [1:3] 的结果:", str1[1:3])
# 查找与替换 - 查找
# find() 方法
search_str = "Hello World"
print("使用 find() 方法查找 'World' 的索引:", search_str.find("World"))
# index() 方法，会抛出异常
print("使用 index() 方法查找 'World' 的索引:", search_str.index("World"))
# count() 方法
print("使用 count() 方法统计 'l' 在字符串中出现的次数:", search_str.count("l"))
# 查找与替换 - 替换
replaced_str = search_str.replace("World", "Python")
print("使用 replace() 方法替换字符串后的结果:", replaced_str)
# 大小写转换
# upper() 方法
lower_str = "hello world"
print("使用 upper() 方法将字符串转换为大写:", lower_str.upper())
# lower() 方法
upper_str = "HELLO WORLD"
print("使用 lower() 方法将字符串转换为小写:", upper_str.lower())
进制转换与排序
# 十进制转二进制
decimal_num = 10
binary_num = bin(decimal_num)
print(f"十进制数 {decimal_num} 转换为二进制是: {binary_num}")
# 十进制转八进制
octal_num = oct(decimal_num)
print(f"十进制数 {decimal_num} 转换为八进制是: {octal_num}")
# 十进制转十六进制
hex_num = hex(decimal_num)
print(f"十进制数 {decimal_num} 转换为十六进制是: {hex_num}")
# 二进制转十进制
binary_str = "0b1010"
decimal_num = int(binary_str, 2)
print(f"二进制数 {binary_str} 转换为十进制是: {decimal_num}")
# 八进制转十进制
octal_str = "0o12"
decimal_num = int(octal_str, 8)
print(f"八进制数 {octal_str} 转换为十进制是: {decimal_num}")
# 十六进制转十进制
hex_str = "0xa"
decimal_num = int(hex_str, 16)
print(f"十六进制数 {hex_str} 转换为十进制是: {decimal_num}")
# 无前缀二进制字符串转十进制
binary_str = "1010"
decimal_num = int(binary_str, 2)
print(f"无前缀二进制数 {binary_str} 转换为十进制是: {decimal_num}")
# 定义一个包含元组的列表，每个元组有两个元素
data = [(3, 2), (1, 4), (2, 1), (4, 3)]
# 使用 sorted() 函数和 lambda 函数按元组的第一个元素升序排序，若第一个元素相同则按第二个元素升序排序
sorted_data = sorted(data, key=lambda x: (x[0], x[1]))
print("排序后的列表:", sorted_data)
并查集（DSU）
class DSU:
def __init__(self, n):
self.f = list(range(n))
self.siz = [1 for _ in range(n)]
def leader(self, x):
while self.f[x] != x:
self.f[x] = self.f[self.f[x]]
x = self.f[x]
return x
def same(self, x, y):
return self.leader(x) == self.leader(y)
def merge(self, x, y):
px, py = self.leader(x), self.leader(y)
if px == py: return False
self.siz[px] += self.siz[py]
self.f[py] = px
return True
def size(self, x):
return self.siz[self.leader(x)]
最短路径（Dijkstra）
import heapq
class dijkstra:
def __init__(self, n):
self.dis = [-1] * n
self.adj = [[] for _ in range(n)]
def run(self, s):
self.dis[s] = 0
heap = []
heapq.heappush(heap, (0, s))
while heap:
dist, now = heapq.heappop(heap)
if self.dis[now] != dist:
continue
for v, w in self.adj[now]:
if self.dis[v] == -1 or self.dis[v] > dist + w:
self.dis[v] = dist + w
heapq.heappush(heap, (self.dis[v], v))
线段树（SegTree）
tree = [0] * ((n << 2) + 10)
def push_up(p):
tree[p] = math.gcd(tree[p << 1], tree[p << 1 | 1])
def build(p, pl, pr):
if pl == pr:
tree[p] = a[pl]
return
mid = pl + pr >> 1
build(p << 1, pl, mid)
build(p << 1 | 1, mid + 1, pr)
push_up(p)
def query(p, pl, pr, L, R):
if L <= pl and R >= pr:
return tree[p]
mid = pl + pr >> 1
if L > mid:
return query(p << 1 | 1, mid + 1, pr, L, R)
elif R <= mid:
return query(p << 1, pl, mid, L, R)
else:
return math.gcd(query(p << 1, pl, mid, L, R), query(p << 1 | 1, mid + 1, pr, L, R))