Python on nayun blog

ParamSpec

Wed, 06 Aug 2025 11:31:02 +0800

在 Python 的类型系统中，ParamSpec（参数规格）是一种高级泛型工具，用于捕获函数或方法的参数类型信息，使得泛型高阶函数（如装饰器、回调工厂）能够精确保留原始函数的参数类型。以下是关于 ParamSpec 的详细解析：

1. `ParamSpec` 的核心作用
#

解决的问题：在泛型装饰器或高阶函数中，传统 TypeVar 无法描述函数的参数列表（如 *args 和 **kwargs 的类型）。
功能：ParamSpec 允许你泛化函数的参数签名，保留参数名称、类型和顺序信息。

2. 基本语法
#

(1) 导入与定义
#

</>
python


1from typing import ParamSpec, Callable, TypeVar
2
3P = ParamSpec("P") # 定义参数规格变量
4R = TypeVar("R") # 定义返回值类型变量

P 表示一个函数的参数规格（包括位置参数和关键字参数）。
R 表示函数的返回值类型。

(2) 使用场景
#

主要用于泛型 Callable 类型或装饰器：

3.12高级类型参数

Wed, 06 Aug 2025 11:14:51 +0800

Python 3.12 通过 PEP 695 引入了更强大的高级类型参数机制，包括 可变类型参数（*Ts） 和 参数规格（**P），用于处理复杂泛型场景（如可变参数函数、回调函数类型等）。以下是对它们的详细解析：

1. **可变类型参数（`*Ts`）**
#

用途
#

表示一组不定数量的类型参数，类似 *args 的泛型版本。常用于：

泛型元组或可变长度容器
函数参数的类型标注（如 *args: *Ts）

语法与示例
#

</>
python


 1from typing import Tuple
 2
 3# 定义泛型元组，第一个元素为 str，其余元素类型可变
 4type LabeledTuple[*Ts] = tuple[str, *Ts] # PEP 695 语法
 5
 6# 使用
 7x: LabeledTuple[int, float] = ("id", 42, 3.14) # 等效于 tuple[str, int, float]
 8y: LabeledTuple[bool] = ("flag", True) # 等效于 tuple[str, bool]
 9
10# 函数中的可变参数类型
11def zip[*T](*args: *T) -> list[tuple[*T]]: # 模拟内置 zip 的类型
12 return list(zip(*args))

关键点
#

*Ts 表示类型元组，可匹配任意数量的类型参数。
运行时会被擦除为 tuple，仅静态类型检查器（如 mypy）会验证类型安全性。
与传统 TypeVarTuple 等效（Python 3.11 之前需用 from typing import TypeVarTuple）。

2. 参数规格（`P`）**
#

用途
#

描述函数的参数类型和返回值类型，用于泛型高阶函数（如装饰器、回调函数）。类似 **kwargs 的泛型扩展。

3.12泛型特性

Wed, 06 Aug 2025 11:04:17 +0800

1. 泛型函数
#

可以直接在函数名后使用 [T] 定义类型参数，无需显式导入 TypeVar：

</>
python


1def max[T](args: Iterable[T]) -> T: # 定义泛型函数
2 return max(args, default=None)
3
4max([1, 2, 3]) # T 自动推断为 int
5max(["a", "b"]) # T 自动推断为 str

特点：

类型参数 T 的作用域仅限于该函数。
支持默认类型推断，无需手动指定 [int] 或 [str]。

2. 泛型类
#

类名后可直接声明类型参数：

</>
python


1class Box[T]:
2 def __init__(self, value: T):
3 self.value = value
4
5 def get(self) -> T:
6 return self.value
7
8int_box = Box[int](42) # 明确指定 T 为 int
9str_box = Box("hello") # 自动推断 T 为 str

特点：

中间件工厂

Tue, 05 Aug 2025 17:02:12 +0800

概念
#

在函数式编程和软件架构中，中间件工厂是一种创建中间件的高阶函数模式。它是在函数工厂（能够生成其他函数的函数）概念基础上的扩展应用。

定义
#

中间件工厂是一个函数，它接收配置参数并返回一个中间件函数。这种模式常见于Web框架（如Express、Koa）和数据处理流程中。

</>
javascript


 1// 中间件工厂示例
 2function createMiddleware(config) {
 3 return function middleware(req, res, next) {
 4 // 使用config和实现中间件逻辑
 5 if (config.condition) {
 6 // 做一些事情
 7 }
 8 next();
 9 };
10}
11
12// 使用
13const myMiddleware = createMiddleware({ condition: true });
14app.use(myMiddleware);

核心意义
#

1. 配置与复用性
#

中间件工厂通过参数化配置，使得单个中间件实现可以适应多种使用场景，大大提高了代码的复用性。

画图

Tue, 05 Aug 2025 15:50:51 +0800

matplotlib
#

</>
python


 1import matplotlib.pyplot as plt
 2def draw(x:list, y:list, titles, fileName, output='./'
,lineColor='blue',marker='.',markerfacecolor='white',markeredgecolor='#fd5e0f',fillBetColor='white'):
'''绘图的主要方法
 5
:param x: x轴
:param y: y轴
:param titles: 图片内部标题
:param fileName: 图片文件名称
'''
fig,ax = plt.subplots(figsize=(20, 6))
ax.set_facecolor('white')
plt.grid(which='both', color='grey', linestyle='--', alpha=0.5)
plt.rcParams['axes.unicode_minus'] = False
plt.rcParams['figure.max_open_warning'] = 30
plt.plot(x, y,color=lineColor,marker=marker, markerfacecolor=markerfacecolor, markeredgecolor=markeredgecolor)
plt.fill_between(x,y,color=fillBetColor)
plt.title(label=titles, fontsize=23, loc='left')
fig.subplots_adjust(left=0.03, right=1)
ax.margins(x=0)
plt.xticks(fontsize=10)
plt.yticks(fontsize=10)
x_num = len(x)//10
x_coordinate = x[::x_num]
plt.xticks(x_coordinate, x_coordinate)
filePath = os.path.join(output, fileName)
plt.savefig(f"{filePath}.png", dpi=300)

时间字符串

Thu, 31 Jul 2025 15:44:35 +0800

1. datetime系列
#

一般来说用from datetime import datetime

1. `.fromtimestamp`
#

接收一个浮点ts参数，返回datetime结构体，可接续使用datetime内置方法
经典场景：ts -> 格式化timestr
datetime.fromtimestamp(ts).strftime('%Y-%m-%d-%H:%M:%S')

</>
python


1def ts2timestr(ts:float) -> str:
2 return datetime.fromtimestamp(ts).strftime('%Y-%m-%d-%H:%M:%S')

2. `.strptime`
#

接收1. 格式化timestr, 2. 格式format；返回datetime结构体(接续使用其他内置方法)
经典场景：格式化timestr -> ts
datetime.strptime(timestr, pattern).timestamp()

</>
python


1def timestr2ts(timestr, pattern='%Y-%m-%d %H:%M:%S'):
2 return datetime.strptime(timestr, pattern).timestamp()

3. `.replace`
#

python hint

</>
python


 1(method) def replace(
year: SupportsIndex = ...,
month: SupportsIndex = ...,
day: SupportsIndex = ...,
hour: SupportsIndex = ...,
minute: SupportsIndex = ...,
second: SupportsIndex = ...,
microsecond: SupportsIndex = ...,
tzinfo: _TzInfo | None = ...,
*,
fold: int = ...
12) -> datetime

一般使用关键字参数指定参数传参：
.replace(hour=23, minute=59, second=59, microsecond=0)

Requests

Thu, 31 Jul 2025 15:29:43 +0800

requests.request方法
#

基础用法：

</>
python


1requests.request(method, url, headers, json)
2requests.request(method, url, headers, data)

参数json和data的区别：
json为字典对象
data为字典字符串，需要使用json.dumps(payload)转换为字符串

压缩解压

Wed, 30 Jul 2025 17:51:10 +0800

解压
#

基础
#

解压zip
模块：zipfile

</>
python


1import zipfile
2with zipfile.ZipFile(fp, 'r') as zip_ref:
3 zip_ref.extractall()

递归解压zip
#

模块：zipfile, pathlib
zipfile.ZipFile.extract(fi, ep)方法逐个判断fi.filename是否匹配zip文件，匹配则进入递归解压

</>
python


 1import zipfile
 2from pathlib import Path
 3from os.path import join
 4def r_unzip(fp:Path, ep:str='./unzip') -> int:
# 统计解压的zip文件数
c = 1
try:
extr_path = join(ep, fp.stem.split('.zip')[0])
with zipfile.ZipFile(fp, 'r') as zip_ref:
for finfo in zip_ref.infolist():
zip_ref.extract(finfo, extr_path)
extr_file = Path(join(extr_path, finfo.filename))
if extr_file.match("*.zip"):
c += r_unzip(extr_file, extr_path)
except Exception as e:
print(f'file error, pass:{fp}, error msg:{e}')
finally:
return c

读日志

Wed, 30 Jul 2025 16:44:17 +0800

读取单个日志
#

1. 读全部日志
#

处理方法：直接读取整体文件内容，或者逐行读取，返回lines列表

</>
python


1def readlog(logfile):
2 with open(logfile, 'r') as f:
3 return f.read() or f.readlines()

2. 读部分日志（限定时间范围）
#

需要考虑：日志文件过大，逐行判断时间戳性能过低
处理方法：

二分查找起始位置

</>
python


 1import datetime
 2import os
 3
 4def bs_read_log(logfile, st, et):
 5 text = []
 6 file_size = os.path.getsize(logfile)
 7
 8 with open(logfile, 'r', encoding='utf-8') as f:
 9 # 二分查找定位起始位置
10 low, high = 0, file_size
11 start_pos = 0
12
13 while low < high:
14 mid = (low + high) // 2
15 f.seek(mid)
16 f.readline() # 移动到完整行首
17 line = f.readline()
18
19 if not line:
20 break
21
22 line_tm = logline_time(line)
23 if line_tm is None: # 跳过无效行
24 continue
25
26 if line_tm < st:
27 low = mid + 1
28 start_pos = f.tell() # 记录最后有效位置
29 else:
30 high = mid
31
32 # 定位到起始区域
33 f.seek(start_pos)
34 while True:
35 line = f.readline()
36 if not line:
37 break
38
39 line_tm = logline_time(line)
40 if line_tm is None:
41 continue
42
43 if line_tm > et:
44 break
45
46 if st <= line_tm <= et:
47 text.append(line.strip())
48
49 return text

二分查找起始位置 + 分块检测日志时间

</>
python


 1def readlog(logfile, st, et):
# 入参检测
if st > et:
return None
# 根据日志大小设置分块大小
chunksize = 1024
# chunk值初始设置为chunksize 大小，可以在读第一行日志时先判断日志时间是否在(st, et)区间，不在即可直接退出
chunk = 1024
text = []
file_size = os.path.getsize(logfile)
with open(logfile, 'rb') as f:
# 二分查找定位起始位置
low, high = 0, file_size
start_pos = 0
15
while low < high:
mid = (low + high) // 2
f.seek(mid)
f.readline() # 移动到完整行首
line = f.readline()
21
if not line:
break
24
line_tm = logline_time(line)
if line_tm is None: # 跳过无效行
continue
28
if line_tm < st:
low = mid + 1
start_pos = f.tell() # 记录最后有效位置
else:
high = mid
34
# 定位到起始区域
f.seek(start_pos)
while(line:=f.readline().decode(errors='ignore')):
chunk += 1
if chunk >= chunksize:
chunk = 1
if (tm:=logline_time(line)) != None and tm > et:
break
43
text.append(line)
45
# 如果追求读取范围结束时间准确性，可以从后往前逐行清除区间外日志，不追求结束时间准确性可以不做
while logline_time(text[-1]) > et:
text.pop(-1)
return text

3. 反向读日志
#

思路：定位到文件尾，逐行读取
核心：

日志分析

Wed, 30 Jul 2025 16:44:17 +0800

纯python处理
#

支持关键字正则表达式组合，逐行后处理，跨平台兼容

日志关键字处理
#

需求：

1次遍历，O(n)
多关键字(支持regex pattern)
关键字一对一自定义处理方法解耦
处理结果统计，每个关键字的成功/失败处理量+处理总量

例子：
找到日志中包含kwA的日志，执行dealA(line) -> pass/fail处理方法
找到日志中包含kwB的日志，执行dealB(line) -> pass/fail处理方法
…

思路：

每行日志查询全部关键字，有关键字出现，进入deallog回调
通过deal_log回调函数，在回调内部区分kw，执行不同逻辑
结束时输出关键字相关处理总量

</>
python


 1import re
 2from collection import defaultdict
 3def keywords_check(checktitle, text, checklist, deal_log=(lambda pt, line:True)) -> int, str:
# checklist 入参多类型支持(dict, list)
checklist = list(dict.fromkeys(checklist))
# 计数器
kw_counter, err_counter = defaultdict(int), defaultdict(int)
for line in text:
found = [pattern for pattern in checklist if re.search(pattern, line) is not None]
if not found:continue
for pattern in found:
kw_counter[pattern] += 1
if False == deal_log(pattern, line):
err_counter[pattern] += 1
msg = "{} done, total {} records, {} errors\n{}".format(
checktitle
, (kw_sum:=sum(kw_counter.values()))
, sum(err_counter.values())
, "".join(["[{}]: {} records, {} errors\n".format(
pattern
, kw_counter.get(pattern, 0)
, err_counter.get(pattern, 0)
) for pattern in checklist
])
)
return kw_sum, msg
27
28checklist = {
'pt1':r"^kwA*$",
'pt2':r"^kwB*$",
'pt3':r"^kwC*$",
32}
33def deal_log(pt, line):
if pt == checklist['pt1']:
return dealA(line)
elif pt == checklist['pt2']:
return dealB(line)
elif pt == checklist['pt3']:
return dealC(line)
else:
return False
42
43keywords_check('check keywords', checklist.values(), deal_log)

数据收集
#

可以使用上面的keywords_check方法，通过自定义deal_log方法收集数据
完成数据收集之后自定义数据分析方法

脚本日志

Wed, 30 Jul 2025 14:10:07 +0800

print
#

纯print输出
#

通过sys.stdout/sys.stderr重定向输出至文件

</>
python


 1import sys
 2class Tee:
 3 """同时重定向 stdout 和 stderr 到文件和终端"""
 4 def __init__(self, filename):
 5 self.file = open(filename, 'a') # 追加模式
 6 self.stdout = sys.stdout
 7 self.stderr = sys.stderr
 8
 9 def write(self, message):
10 self.file.write(message)
11 self.stdout.write(message) # 标准输出到终端
12 self.file.flush() # 确保实时写入文件
13
14 def flush(self):
15 self.file.flush()
16
17# 脚本日志重定向
18sys.stdout = Tee(f"{__file__.split('.')[0]}.log")
19sys.stderr = Tee(f"{__file__.split('.')[0]}.log")

封装print，自定义输出
#

</>
python


1from datetime import datetime
2class Logger:
3 def now(self):return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
4 def info(self, msg):print(self.now() + ' - INFO - ' + msg)
5 def warning(self, msg):print(self.now() + ' - WARN - ' + msg)
6 def error(self, msg):print(self.now() + ' - ERROR - ' + msg)
7
8logger = Logger()

logging
#

通用代码
#

</>
python


 1import logging
 2import os
 3from datetime import datetime
 4
 5def setup_logger(name, log_level=logging.INFO, log_file_path=None):
 6 logger = logging.getLogger(name)
 7 logger.setLevel(log_level)
 8 formatter = logging.Formatter(
 9 '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
10 datefmt='%Y-%m-%d %H:%M:%S'
11 )
12 console_handler = logging.StreamHandler()
13 console_handler.setFormatter(formatter)
14 logger.addHandler(console_handler)
15
16 if log_file_path is None:
17 return logger
18
19 file_handler = logging.FileHandler(log_file_path)
20
21 file_handler.setFormatter(formatter)
22 logger.addHandler(file_handler)
23 return logger

默认logger再封装
#

不设置formatter，自定义logging的info/debug/error方法
实现：

元类MetaClass

Fri, 25 Jul 2025 16:08:19 +0800

元类作用时机
当使用此元类定义新类时（如 class MyClass(metaclass=StaticMethodMeta)），元类的 __new__ 方法会在类创建时被调用。

利用元类改变类特性 -> 创建一个成员函数自动转换为静态成员函数的类

</>
python


 1class StaticMethodMeta(type):
 2 def __new__(cls, name, bases, namespace):
 3 for attr_name, attr_value in namespace.items():
 4 if callable(attr_value) and not attr_name.startswith('__'):
 5 namespace[attr_name] = staticmethod(attr_value)
 6 return super().__new__(cls, name, bases, namespace)
 7
 8class tool(metaclass=StaticMethodMeta):
 9 # 静态成员没有self参数
10 def tool1(p1, p2):
11 pass

闭包

Mon, 14 Jul 2025 11:35:25 +0800

在创建时封装当时状态，并使当时的状态生存周期延长至与闭包生存周期一致
闭包思想产物：
1. python装饰器
2. 回调函数
3. 函数工厂
4. 惰性求值
…

典型用法
#

1. python装饰器
#

</>
python


1def execute(f):
2 f()
3
4@execute
5def execute_when_defined():
6 print('executed')

2. 函数工厂
#

保存调用函数工厂时的参数
调用生成的函数时，使用函数工厂创建函数时的参数上下文

示例
#

python api函数工厂

</>
python


1def get_table_grids_wp(cli:Client, docid):
2 def func(tableid):
3 return [c['children'][0] for c in cli.fetchblocks(docid, tableid)['data']['items']]
4 return func
5
6get_table_grids = get_table_grids_wp(cli, docid)
7get_table_grids(tid)

go 基础函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5// 函数工厂：返回一个加法函数
 6func makeAdder(addend int) func(int) int {
 7 return func(x int) int {
 8 return x + addend
 9 }
10}
11
12func main() {
13 add5 := makeAdder(5) // 创建一个加5的函数
14 add10 := makeAdder(10) // 创建一个加10的函数
15
16 fmt.Println(add5(3)) // 输出: 8 (3 + 5)
17 fmt.Println(add10(3)) // 输出: 13 (3 + 10)
18}

go 中间件工厂
带配置的函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5type GreeterConfig struct {
 6 Prefix string
 7 Suffix string
 8}
 9
10// 创建问候函数
11func NewGreeter(config GreeterConfig) func(string) string {
12 return func(name string) string {
13 return fmt.Sprintf("%s, %s%s", config.Prefix, name, config.Suffix)
14 }
15}
16
17func main() {
18 friendlyGreeter := NewGreeter(GreeterConfig{
19 Prefix: "Hello",
20 Suffix: "! Welcome!",
21 })
22
23 formalGreeter := NewGreeter(GreeterConfig{
24 Prefix: "Dear",
25 Suffix: ", we are pleased to meet you",
26 })
27
28 fmt.Println(friendlyGreeter("Alice")) // 输出: Hello, Alice! Welcome!
29 fmt.Println(formalGreeter("Bob")) // 输出: Dear, Bob, we are pleased to meet you
30}

缓存函数工厂

</>
go


 1package main
 2
 3import "fmt"
 4
 5// 创建带缓存的函数
 6func makeCachedFunc(fn func(int) int) func(int) int {
 7 cache := make(map[int]int)
 8 return func(x int) int {
 9 if result, found := cache[x]; found {
10 fmt.Printf("Cache hit for %d\n", x)
11 return result
12 }
13 result := fn(x)
14 cache[x] = result
15 fmt.Printf("Calculated for %d\n", x)
16 return result
17 }
18}
19
20func expensiveCalculation(x int) int {
21 // 模拟耗时计算
22 return x * x
23}
24
25func main() {
26 cachedCalc := makeCachedFunc(expensiveCalculation)
27
28 fmt.Println(cachedCalc(5)) // 输出: Calculated for 5 \n 25
29 fmt.Println(cachedCalc(5)) // 输出: Cache hit for 5 \n 25
30}

Python on nayun blog

ParamSpec

1. ParamSpec 的核心作用 #

2. 基本语法 #

(1) 导入与定义 #

(2) 使用场景 #

3.12高级类型参数

1. 可变类型参数（*Ts） #

用途 #

语法与示例 #

关键点 #

2. 参数规格（**P） #

用途 #

3.12泛型特性

1. 泛型函数 #

2. 泛型类 #

中间件工厂

概念 #

定义 #

核心意义 #

1. 配置与复用性 #

画图

matplotlib #

时间字符串

1. datetime系列 #

1. .fromtimestamp #

2. .strptime #

3. .replace #

Requests

requests.request方法 #

压缩解压

解压 #

基础 #

递归解压zip #

读日志

读取单个日志 #

1. 读全部日志 #

2. 读部分日志（限定时间范围） #

3. 反向读日志 #

日志分析

纯python处理 #

日志关键字处理 #

数据收集 #

脚本日志

print #

纯print输出 #

封装print，自定义输出 #

logging #

通用代码 #

默认logger再封装 #

元类MetaClass

闭包

典型用法 #

1. python装饰器 #

2. 函数工厂 #

示例 #

1. `ParamSpec` 的核心作用
#

2. 基本语法
#

(1) 导入与定义
#

(2) 使用场景
#

1. **可变类型参数（`*Ts`）**
#

用途
#

语法与示例
#

关键点
#

2. 参数规格（`P`）**
#

用途
#

1. 泛型函数
#

2. 泛型类
#

概念
#

定义
#

核心意义
#

1. 配置与复用性
#

matplotlib
#

1. datetime系列
#

1. `.fromtimestamp`
#

2. `.strptime`
#

3. `.replace`
#

requests.request方法
#

解压
#

基础
#

递归解压zip
#

读取单个日志
#

1. 读全部日志
#

2. 读部分日志（限定时间范围）
#

3. 反向读日志
#

纯python处理
#

日志关键字处理
#

数据收集
#

print
#

纯print输出
#

封装print，自定义输出
#

logging
#

通用代码
#

默认logger再封装
#

典型用法
#

1. python装饰器
#

2. 函数工厂
#

示例
#