【刷题2025】知识点梳理

1.常用操作

二进制异或 ans = a ^ b

向上取整 math.ceil(a/b)

向下取整 math.floor(a/b)

每次取最低字节：一个字节八位

        while a > 0:
            aSum += a & 0xff  # 累加最低字节的大小
            a >>= 8  # 一个字节八位, a右移八位, 将最低字节移除

正则匹配

# 编译正则表达式，用于匹配以 < 开头、以 > 结尾的字符串片段
# 编译后的对象可以调用 findall、search、match 等方法
regexp = re.compile(r"(<.*?>)")
 
# findall 查找字符串text中所有与正则表达式regexp匹配的子串，并返回一个列表
matchers = re.findall(regexp, text)
 
# search 查找字符串text中第一个与正则表达式regexp匹配的子串，返回一个match对象或None
matchers = re.search(regexp, text)
 
# match 从字符串text起始位置开始匹配正则表达式regex，只检查字符串开头
# 成功返回一个match对象，失败返回None
matchers = re.match(regexp, text)
 
# 替换
pattern = r"\d+"
text = "我有 3 只猫和 2 只狗"
 
# 只替换第一个匹配项
new_text = re.sub(pattern, "X", text, count=1)
print("替换后的文本:", new_text)
 
# Match 对象的常用方法
group()：返回匹配的字符串。
group(0)：返回整个匹配的字符串。
group(1)：返回第一个分组的内容。
group(2)：返回第二个分组的内容，依此类推。
start()：返回匹配的起始位置。
end()：返回匹配的结束位置。
span()：返回匹配的范围（起始和结束位置的元组）。
 
import re
 
text = "a(1)b(2)c(3)"
match = re.search(r'\((\d)\)', text)
if match:
    print(match.group())   # 输出: '(1)'
    print(match.group(1))  # 输出: '1'
    print(match.start())   # 输出: 1
    print(match.end())     # 输出: 4
    print(match.span())    # 输出: (1, 4)
 
# 检查字符串是否只包含大小写字母和数字
if not re.match(r"^[a-zA-Z0-9]+$", cells[i]):
 
r"(<.*?>)"
<：匹配字符 <。
.：匹配任意字符（除了换行符 \n）。
*：匹配前面的字符 0 次或多次。
?：非贪婪模式，尽可能少地匹配字符。
>：匹配字符 >。
整体表示匹配以 < 开头、以 > 结尾的字符串片段。
使用括号 () 将匹配的内容捕获为一个分组。
 
r"^[a-zA-Z0-9]+$"
^：匹配字符串的开头。
[a-zA-Z0-9]：匹配任意一个字母（大小写）或数字。
a-z：小写字母。
A-Z：大写字母。
0-9：数字。
+：匹配前面的字符（字母或数字）1 次或多次。
$：匹配字符串的结尾。
 
r"[^aeiou][aeiou][^ariour]e"
检测 辅音+元音+辅音（除r以外）+e
 
pattern = r"(\d{3})-(\d{2})-(\d{4})"  # 匹配日期格式 123-45-6789
 
 
. 匹配任意字符（除换行符）
^ 匹配字符串开头
$ 匹配字符串结尾
* 匹配前一个字符 0 次或多次
+ 匹配前一个字符 1 次或多次
? 匹配前一个字符 0 次或 1 次
{n} 匹配前一个字符恰好 n 次
{n,} 匹配前一个字符至少 n 次
{n,m} 匹配前一个字符 n 到 m 次
\d 匹配数字
\D 匹配非数字
\w 匹配字母、数字、下划线
\W 匹配非字母、数字、下划线
\s 匹配空白字符
\S 匹配非空白字符

reg=re.compile("^(01)+0$")

自定义排序：

list.sort(key = lambda x:x[0], reverse=False)


# functools.cmp_to_key 的作用是将一个 自定义的比较函数 转换为一个 键函数（key function），
# 以便在 sorted() 或其他排序函数中使用。
# 当比较函数返回 -1、0 或 1 时，排序算法会根据这些返回值来决定元素的顺序。
# 当cmp_to_key返回1时，排序会将a，b顺序调换。
import functools
 
def cmp(a, b):
    s1 = a + b
    s2 = b + a
    return 0 if s1 == s2 else 1 if s1 > s2 else -1
 
def solution():
    nums.sort(key=lambda x: int(x))
    return "".join(sorted(nums[:3], key=functools.cmp_to_key(cmp)))

二分法：

# 左闭右开区间
class Solution:
    def search(self, nums, target):
        left, right = 0, len(nums)  # 定义target在左闭右开的区间里，即：[left, right)
         
        # 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
        while left < right:  
            middle = left + (right - left) // 2
 
            if nums[middle] > target:
                right = middle  # target 在左区间，在[left, middle)中
            elif nums[middle] < target:
                left = middle + 1  # target 在右区间，在[middle + 1, right)中
            else:
                return middle  # 数组中找到目标值，直接返回下标
        return -1  # 未找到目标值

字符串判断：

s.isalnum()：判断字符是否为数字或字母
s.isdigit()：判断字符是否数字
s.isalpha():判断字符是否为字母
s.islower()：判断字符是否为小写字母
s.isupper()：判断字符是否为大写字母
s.lower()：将所有大写字母转换为小写
s.lstrip()：截掉左边空格（s.rstrip()、s.strip()）
s.replace(s1, s2)：将所有s1替换为s2
s.find(c)：返回c第一次出现位置，未找到返回-1（s.rfind(c)返回最后一次出现位置）

ord("A")  # 返回“A”的ascii码
chr(65)   # 返回ascii码为65的字符
 

输入输出：

# 循环输出
for c in sorted_dic:
    print(f"{c}:{dic[c]};", end="")

print默认输出换行，如果句末不换行采用end禁用
print(dic, end="")

# 检测非法输入
if __name__ == "__main__":
    try:
        list = input()
        print(solve(list))
    except:
        print(0)

deque用法：

from collections import deque
dq = deque()
dq.append()
dq.appendleft()
dp.pop()
dq.popleft()
dq.extend()
dq.extendleft()
dq.rotate()

heapq用法：

'''
在 Python 中，heapq 模块提供了堆队列算法的实现，可以用来手动实现一个优先队列。
heapq 是一个最小堆（min-heap），即堆顶元素始终是最小的元素。
通过将元素插入堆中并保持堆的性质，可以实现优先队列的功能。
'''
 
# 1. 导入 heapq 模块
import heapq
 
# 2. 优先队列的基本操作
 
heapq.heappush(heap, item)  # 将元素插入堆中，并保持堆的性质。
heapq.heappop(heap)  # 弹出并返回堆中的最小元素。
heapq.heapify(heap)  # 将列表转换为堆（原地操作）。
heapq.heappushpop(heap, item)  # 将元素插入堆中并弹出最小元素。
heapq.heapreplace(heap, item)  # 弹出最小元素并插入新元素。
 
# 3. 实现优先队列
# 优先队列的核心思想是将元素插入堆中，并根据优先级（通常是元素的第一个值）进行排序。
 
import heapq
 
class PriorityQueue:
    def __init__(self):
        self.heap = []  # 使用列表存储堆
        self.index = 0  # 用于处理优先级相同的情况
 
    def push(self, item, priority):
        # 将元素插入堆中，优先级由 priority 决定
        # 使用 (priority, index, item) 来确保相同优先级时按插入顺序处理
        heapq.heappu