识别盒装图标项目的一些功能函数

一、正则判断函数

1. 正则表达式规则（核心筛选逻辑）

规则 1

pattern_alphanumeric = re.compile(r'^(?=.*[a-zA-Z])(?=.*\d)[a-zA-Z\d-]{2,8}$')

• ^(?=.*[a-zA-z])：必须包含至少 1 个字母（a-z/A-Z）

• (?=.*\d)：必须包含至少 1 个数字

• [a-zA-Z\d-]{2,8}：整体只能由字母、数字、短横线-组成，且长度在 2-8 位之间

• $：匹配字符串结尾（确保整个子串都符合规则）

规则 2

pattern_at_least_two_digits = re.compile(r'^\d{4,7}$')

• ^\d{4,7}$：纯数字字符串，长度必须在 4-7 位之间（变量名里的two是错误的，实际是 4 位及以上）

• 若长度超出 7 位（如1234568956），则不匹配

2. 核心函数 process_string

• 步骤 1：用split()按空格分割输入字符串（如"Aceite p04476"会被拆成["Aceite", "p04476"]）

• 步骤 2：遍历每个分割后的子串，检查是否匹配规则 1 或规则 2

• 步骤 3：将符合条件的子串加入列表aa，最终返回该列表。

代码汇总：

import re

def process_string(input_string):
    result = []
    # 处理空字符串/全空格的情况
    if not input_string or input_string.strip() == "":
        return result
    
    parts = input_string.split()
    # 修正正则写法 + 规范命名
    pattern_alphanumeric = re.compile(r'^(?=.*[a-zA-Z])(?=.*\d)[a-zA-Z\d-]{2,8}$')
    pattern_at_least_four_digits = re.compile(r'^\d{4,7}$')
    
    for part in parts:
        if pattern_alphanumeric.match(part) or pattern_at_least_four_digits.match(part):
            result.append(part)
    return result

# 测试用例
a = "Aceite p04476"
b = 'sdighsg'
c = 's4967xl'
d = 'vθ-4985'
e = 'shfsfvO-4985'
f = '123'
g = '1234568956'
h = '45825'

ylist = []
llist = [a, b, c, d, e, f, g, h]
for i in llist:
    ma = process_string(i)
    ylist.extend(ma)

print(ylist)  # 输出：['p04476', 's4967xl', '45825']

二、三进一函数

这段代码的核心是实现一个带参数的装饰器 ：execute_after_n_calls(n, w2set)，作用是让被装饰的函数每执行 n 次后，自动调用一次指定的回调函数 w2set。

1. 装饰器的结构（Python 装饰器核心逻辑）

Python 装饰器本质是 "函数包装器"，带参数的装饰器需要三层嵌套函数：

• 外层 execute_after_n_calls(n, w2set)：接收装饰器的参数（n= 执行次数阈值、w2set= 回调函数）；

• 中层 decorator(func)：接收被装饰的目标函数（如 aa）；

• 内层 wrapper(*args, **kwargs)：实际执行的包装函数，负责计数、调用原函数、触发回调。

2. 核心逻辑逐行解析

def execute_after_n_calls(n,w2set):  # 外层：接收装饰器参数
    def decorator(func):            # 中层：接收被装饰的函数
        def wrapper(*args,**kwargs):# 内层：包装函数，替代原函数执行
            wrapper.count +=1       # 每次调用包装函数，计数器+1
            result = func(*args,**kwargs)  # 执行原函数，保存返回值
            if wrapper.count %n==0: # 判断是否达到n次调用
                w2set()             # 触发回调函数
            return result           # 返回原函数的执行结果
        wrapper.count =0            # 初始化计数器（绑定在wrapper上）
        return wrapper              # 返回包装函数
    return decorator                # 返回装饰器

3. 回调函数与被装饰函数

def bb ():
    print('b')  # 回调函数：被触发时打印 'b'

@execute_after_n_calls(3,bb)  # 装饰器参数：n=3（每3次）、回调=bb
def aa():
    print('a')  # 被装饰的目标函数：执行时打印 'a'

4.最后输出

a
a
a
b

三、多线程

这段代码是 Python 多线程编程的基础示例，核心作用是：创建并启动两个独立的线程（线程 1、线程 2），让它们并发执行相同的任务（循环打印工作信息并短暂休眠），同时主线程不会阻塞，会继续执行自身的代码

1. 核心模块导入

import threading  # 提供多线程编程的核心功能（创建、启动线程等）
import time       # 提供时间相关功能（这里用 sleep 模拟任务耗时）

2. 线程执行的任务函数 worker

def worker(name):
    print(f"{name}线程开始执行")  # 线程启动提示
    for i in range(5):            # 循环5次模拟任务执行
        print(f"{name}正在工作：{i}")  # 打印当前工作进度
        time.sleep(0.5)           # 休眠0.5秒，模拟任务耗时（非阻塞，仅当前线程暂停）
    print(f"{name}线程执行完毕")  # 线程结束提示

• 该函数是每个线程要执行的 "任务逻辑"，接收一个 name 参数用于区分不同线程

• time.sleep(0.5) 只会让当前执行该函数的线程暂停，不会影响其他线程

3. 创建并启动线程

# 创建线程对象：target 指定线程要执行的函数，args 是传给函数的参数（必须是元组）
thread1 = threading.Thread(target=worker, args=("线程1",))
thread2 = threading.Thread(target=worker, args=("线程2",))

# 启动线程：此时线程进入"就绪状态"，等待CPU调度执行
thread1.start()
thread2.start()

• threading.Thread() 只是创建线程对象，不会立即执行

• start() 方法才是真正启动线程，两个线程启动后会并发执行（CPU 交替调度，看起来像同时运行）

4. 主线程的执行逻辑

# 等待线程完成（注：代码里写的是"维续"，是笔误，应为"继续"）
print("***主线程继续执行***")

• 主线程是执行这段代码的默认线程，创建并启动子线程后，主线程不会等待子线程完成，会立即执行这行打印语句

• 这里的注释 "等待线程完成" 是错误的 ------ 代码中并没有真正的等待逻辑，子线程会和主线程并行执行，主线程执行完打印后会继续运行（直到自身代码结束）

5.输出示例

线程1线程开始执行
线程1正在工作：0
线程2线程开始执行
线程2正在工作：0
***主线程维续执行***
线程1正在工作：1
线程2正在工作：1
线程1正在工作：2
线程2正在工作：2
线程1正在工作：3
线程2正在工作：3
线程1正在工作：4
线程2正在工作：4
线程1线程执行完毕
线程2线程执行完毕

进程已结束,退出代码0