技 on nayun blog

小知识

Mon, 02 Mar 2026 11:16:37 +0800

string和[]byte
string是不可变类型，不能通过下标修改值，适合表示不可变的文本数据，安全、简洁，适合 map 键和比较操作。
[]byte可变类型，可以通过下标修改值，也可以动态扩容，适合处理可变的字节流，性能更高，适合 I/O 和缓冲区操作。
具名函数定义必须位于包级别中，不能在函数体内嵌套定义具名函数
类型断言value, ok := x.(T)/ value := x.(T)
询问接口值 x 中存储的动态类型是否是 T
导入的包必须在代码中被使用，除非使用空白标识符作为别名，仅为了执行包的初始化过程，而不直接使用包中的任何导出函数、类型或变量。，如import _ "net/http/pprof"
切片扩容
- 特殊直接分配：如果所需容量大于旧容量的两倍，新容量直接等于所需容量。
- 小容量翻倍：如果旧容量小于256，新容量一般直接翻倍（乘以2）。
- 大容量平滑过渡：如果旧容量大于等于256，则会进入一个循环，通过特定公式计算新容量。这个公式会让扩容倍数从2开始，随着容量增大，平滑地趋近于1.25倍，而不是一个固定的倍数。

CICD

Thu, 08 Jan 2026 15:04:14 +0800

Jenkins流水线部署
#

Jenkins Node
用agent.jar指定工作目录和节点名，部署jenkins节点
配置参数、code repo、shell脚本、归档，或直接使用jenkins groovy脚本构建任务工作流

画图

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)

LinuxHttp工具

Tue, 05 Aug 2025 14:28:04 +0800

wget
#

wget获取指定ip路由下的全部文件
-r：递归
--no-parent：无父目录
--accept：接收文件，支持通配符
--reject：拒绝文件，支持通配符
-P：指定下载路径

</>
shell


1wget -r --no-parent --accept "*.zip*" --reject "*.html" ip:port -P ./download/

Http文件服务器
#

python3 http server模块快速启动
python3 -m http.server 8000 --directory /path/

</>
console


1Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

优点：快速
缺点：不能直观看到本地ip

python3 代码

</>
python


 1import socket
 2import sys
 3import http.server
 4import socketserver
 5import traceback
 6
 7class Handler(http.server.SimpleHTTPRequestHandler):
 8 def __init__(self, *args, **kwargs):
 9 super().__init__(*args, directory=target, **kwargs)
10
11 def end_headers(self):
12 self.send_header('Connection', 'close')
13 super().end_headers()
14
15def get_local_ip() -> str:
16 try:
17 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
18 s.connect(("8.8.8.8", 80))
19 local_ip = s.getsockname()[0]
20 s.close()
21 return local_ip
22 except Exception as e:
23 raise Exception(f"无法获取IP: {str(e)}\n请检查网络环境")
24
25if __name__ == '__main__':
26 local_ip = get_local_ip()
27 target = ''
28 try:
29 target = sys.argv[1]
30 except:
31 target = "."
32
33 with socketserver.ThreadingTCPServer(("", 0), Handler) as httpd:
34 port = httpd.server_address[1]
35 print(f"Serving HTTP on http://{local_ip}:{port}/")
36 try:
37 httpd.serve_forever()
38 except:
39 print(traceback.format_exc())
40 finally:
41 httpd.server_close()
42 print('exit.')

</> shell

1python3 autofileserver.py /path/

优点：快速、直观看到ip:port

LearnHugo250804

Mon, 04 Aug 2025 17:11:01 +0800

设置code-header.language-label点击折叠
#

设置悬停spacing扩展效果

</>
css


 1.language-brackets {
 2 /* 全属性切换过渡动画效果 */
 3 transition: all 0.3s ease;
 4}
 5/* 悬停间距扩展，颜色高亮 */
 6.language-label:hover .language-brackets {
 7 letter-spacing: 3px;
 8 color: var(--code-header-hover-color);
 9}
10.language-label:hover .language-name {
11 color: var(--code-header-hover-color);
12}

js设置点击label切换chroma.collapsed

</>
javascript


document.querySelectorAll('.language-label').forEach(button => {
button.addEventListener('click', () => {
const codeBlock = button.closest('.code-block-wrapper');
const chroma = codeBlock?.querySelector('pre.chroma');
if (chroma) {
chroma.classList.toggle('collapsed');
}
else console.error('chroma折叠失败');
});
});

设置pre.chroma.collapsed折叠样式

</>
css


1pre.chroma.collapsed{
2 /* 折叠方法：设置高度为0 */
3 max-height: 0 !important;
4 /* 去除溢出拖动条 */
5 overflow: hidden !important;
6 /* 去除顽固padding */
7 padding: 0 !important;
8}

设置代码块换行按钮功能
#

核心样式方案：把ln设置固定宽度，cl设置为block，固定左侧间距

</>
css


 1pre.chroma .ln {
 2 float: left;
 3 /* 设置行号区域的宽度 */
 4 width: 20px;
 5 text-align: right;
 6 margin-right: 10px;
 7 user-select: none; /* 禁止行号被选中 */
 8}
 9
10pre.chroma .cl {
11 display: block;
12 margin-left: 30px; /* 与行号宽度一致 */
13}
14
15pre.chroma.wrap-lines .cl {
16 display: block;
17 margin-left: 30px; /* 与行号宽度一致 */
18 white-space: pre-wrap !important;
19}

js代码

</>
javascript


document.querySelectorAll('.code-block-wrapper').forEach(wrapper => {
// 为每个代码块创建换行状态存储
const preElement = wrapper.querySelector('pre.chroma');
if (preElement) {
// 默认从 localStorage 读取用户偏好
const wrapEnabled = localStorage.getItem('codeWrapEnabled') === 'true';
if (wrapEnabled) {
preElement.classList.add('wrap-lines');
const wrapButton = wrapper.querySelector('.wrap-button');
if (wrapButton) {
wrapButton.classList.add('active');
const span = wrapButton.querySelector('span');
if (span) span.textContent = '不换行';
}
}
}
});
// 换行按钮功能
document.addEventListener('click', function(e) {
if (e.target.closest('.wrap-button')) {
const button = e.target.closest('.wrap-button');
const codeBlock = button.closest('.code-block-wrapper');
const preElement = codeBlock.querySelector('pre.chroma');
24
if (preElement) {
preElement.classList.toggle('wrap-lines');
button.classList.toggle('active');
28
// 保存用户偏好
const isNowWrapped = preElement.classList.contains('wrap-lines');
localStorage.setItem('codeWrapEnabled', isNowWrapped.toString());
32
// 更新按钮文本
const span = button.querySelector('span');
if (span) {
span.textContent = isNowWrapped ? '换行' : '不换行';
}
}
}
});

时间字符串

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方法收集数据
完成数据收集之后自定义数据分析方法

Vscode

Wed, 30 Jul 2025 16:18:18 +0800

vscode 设置制表符转换空格
#

打开设置，搜索indent
Editor: DetectIndentation勾选
Editor: tab size 设置为4

强制转换文档的table –> 4 spaces
#

在vscode界面使用ctrl+shift+p，搜索convert
点选convert indentation to spaces

脚本日志

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方法
实现：

异常处理

Tue, 29 Jul 2025 15:24:57 +0800

核心思想：按需捕获
#

场景	处理方式	示例
不接受异常，基本不可能异常	抛出	不做处理，自然抛出
不接受异常，但有可能异常	抛出	1. assert condition, reason 2. catch后自定义raise
接受异常	捕获	正常捕获选择日志输出

代码示例
#

异常重试
#

需求：执行特定流程抛出异常时，执行指定次数重试
思路：retry变量控制
基本写法：

</>
python


 1def process_wp(retry=3):
e = None
res = None
while retry:
try:
res = might_err_process()
except:
print(f'retry {retry}...')
e = traceback.format_exc()
retry -= 1
# 按需等待
time.sleep(0.1)
else:
raise Exception(str(e))
return res

todo：python可写成装饰器

Linux文件读写

Tue, 29 Jul 2025 15:19:16 +0800

核心思想
#

一切皆文件（Everything is a File），提供了一套统一的接口 (open(), read(), write(), close(), ioctl() 等系统调用) 来操作各种资源，极大地简化了程序设计。

不仅指普通的文本文件、二进制可执行文件、图片、视频等，还包括：

硬件设备：硬盘 (/dev/sda1)、键盘 (/dev/input)、显示器 (/dev/fb0)、声卡 (/dev/snd)、甚至内存 (/dev/mem) 都被表示为文件。对这些“设备文件”的读写操作实际上是与硬件交互。
进程信息：正在运行的程序（进程）的信息和控制接口可以通过 /proc 文件系统访问（如 /proc/1234 对应 PID 为 1234 的进程）。
系统信息和配置： /sys 文件系统暴露内核参数、硬件信息和配置选项。
网络套接字：网络通信的端点。
管道：进程间通信的通道。

特性	普通文件	管道(Pipe)	Socket(TCP)
打开方式	路径直接打开	pipe()系统调用	socket()+bind/connect
数据存储	持久化存储	内存缓冲区	网络传输
访问模式	随机访问	顺序访问	顺序访问
生命周期	显式创建/删除	进程结束自动销毁	连接关闭即失效
进程通信	不支持进程间通信	支持相关进程通信	支持跨网络通信
阻塞行为	通常非阻塞	读空阻塞/写满阻塞	默认阻塞

1. 普通文件
#

代码通用实现
#

1. python
#

基本方法：with open(fp, mode)
示例

</>
python


 1with open('text.txt', 'w', encoding='utf-8') as f: # 'w' 覆盖写
 2 f.write("Hello Python!\n")
 3 f.writelines(["Line 1\n", "Line 2\n"]) # 写入多行
 4
 5with open('text.txt', 'r', encoding='utf-8') as f:
 6 content = f.read() # 一次性读取
 7
 8with open('text.txt', 'r') as f:
 9 lines = f.readlines() # 返回列表
10
11# ========== 二进制文件读写 ==========
12data = b'\x48\x65\x6C\x6C\x6F\x21' # "Hello!" 的二进制
13with open('binary.bin', 'wb') as f: # 'wb' 二进制写
14 f.write(data)
15
16with open('binary.bin', 'rb') as f:
17 binary_content = f.read()
18 print("二进制内容:", binary_content) # b'Hello!'
19 print("解码为字符串:", binary_content.decode('utf-8'))

2. c++
#

基本方法：fstream
1. 读：std::ifstream
2. 写：std::ofstream
注：创建流对象后需要手动关闭
示例

</>
c++


 1#include <iostream>
 2#include <fstream>
 3#include <vector>
 4#include <string>
 5
 6int main() {
// ========== 文本文件读写 ==========
// 写入文本文件
std::ofstream textOut("text.txt");
if (textOut.is_open()) {
textOut << "Hello C++!\n";
textOut << "Line 1\nLine 2\n";
textOut.close();
std::cout << "文本写入成功" << std::endl;
} else {
std::cerr << "文本文件打开失败" << std::endl;
}
18
// 读取文本文件
std::ifstream textIn("text.txt");
if (textIn.is_open()) {
std::string line;
std::cout << "文本内容:" << std::endl;
while (std::getline(textIn, line)) { // 逐行读取
std::cout << line << std::endl;
}
textIn.close();
} else {
std::cerr << "文本文件打开失败" << std::endl;
}
31
// ========== 二进制文件读写 ==========
// 写入二进制文件
std::ofstream binOut("binary.bin", std::ios::binary);
char data[] = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x21}; // "Hello!"
if (binOut.is_open()) {
binOut.write(data, sizeof(data));
binOut.close();
std::cout << "二进制写入成功" << std::endl;
} else {
std::cerr << "二进制文件打开失败" << std::endl;
}
43
// 读取二进制文件
std::ifstream binIn("binary.bin", std::ios::binary);
if (binIn.is_open()) {
// 获取文件大小
binIn.seekg(0, std::ios::end);
size_t size = binIn.tellg();
binIn.seekg(0, std::ios::beg);
51
// 读取到vector
std::vector<char> buffer(size);
binIn.read(buffer.data(), size);
binIn.close();
56
std::cout << "二进制内容: ";
for (char c : buffer) std::cout << c; // 输出 "Hello!"
std::cout << std::endl;
} else {
std::cerr << "二进制文件打开失败" << std::endl;
}
63
return 0;
65}

3. golang
#

基本方法：os
1. 读：
  1. 整体读取：os.ReadFile
  2. 逐行读取：
    1. os.Open
    2. bufio.NewScanner
2. 写：os.WriteFile

</>
golang


 1package main
 2
 3import (
"fmt"
"io"
"os"
"bufio"
 8)
 9
10func main() {
textContent := "Hello Go!\nLine 1\nLine 2\n"
err := os.WriteFile("text.txt", []byte(textContent), 0644) // 覆盖写入
if err != nil {
fmt.Println("文本写入失败:", err)
} else {
fmt.Println("文本写入成功")
}
18
data, err := os.ReadFile("text.txt") // 一次性读取
if err != nil {
fmt.Println("文本读取失败:", err)
} else {
fmt.Println("文本内容:\n", string(data))
}
25
// 逐行读取（使用 bufio）
file, err := os.Open("text.txt")
if err != nil {
fmt.Println("文件打开失败:", err)
return
}
defer file.Close()
33
fmt.Println("逐行读取:")
scanner := bufio.NewScanner(file)
for scanner.Scan() {
fmt.Println(scanner.Text()) // 输出每一行
}
39
// ========== 二进制文件读写 ==========
binaryData := []byte{0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x21} // "Hello!"
err = os.WriteFile("binary.bin", binaryData, 0644)
if err != nil {
fmt.Println("二进制写入失败:", err)
} else {
fmt.Println("二进制写入成功")
}
48
binContent, err := os.ReadFile("binary.bin")
if err != nil {
fmt.Println("二进制读取失败:", err)
} else {
fmt.Println("二进制内容:", binContent) // [72 101 108 108 111 33]
fmt.Println("解码为字符串:", string(binContent)) // "Hello!"
}
56
// 大文件分块读取
largeFile, err := os.Open("largefile.bin")
if err != nil {
fmt.Println("大文件打开失败:", err)
return
}
defer largeFile.Close()
64
buffer := make([]byte, 1024) // 1KB缓冲区
for {
n, err := largeFile.Read(buffer)
if err == io.EOF {
break // 文件结束
}
if err != nil {
fmt.Println("读取错误:", err)
break
}
fmt.Printf("读取 %d 字节\n", n)
// 处理 buffer[:n]
}
78}

2. 管道
#

代码实现
#

1. python
#

</>
python


 1import os
 2r, w = os.pipe()
 3pid = os.fork()
 4if pid == 0: # Child
 5 os.close(w)
 6 data = os.read(r, 100)
 7 print("Pipe read:", data.decode())
 8 os._exit(0)
 9else: # Parent
10 os.close(r)
11 os.write(w, b"Pipe message")
12 os.wait()

2. c++
#

</>
c++


 1#include <iostream>
 2#include <fstream>
 3#include <unistd.h>
 4#include <sys/wait.h>
 5#include <sys/socket.h>
 6#include <netinet/in.h>
 7
 8int main() {
 9 int fd[2]; pipe(fd);
10 if (fork() == 0) { // Child
11 close(fd[1]);
12 char buf[100];
13 read(fd[0], buf, sizeof(buf));
14 std::cout << "Pipe read: " << buf << std::endl;
15 exit(0);
16 } else { // Parent
17 close(fd[0]);
18 write(fd[1], "Pipe message", 13);
19 wait(nullptr);
20 }
21}

3. golang
#

</>
golang


 1package main
 2
 3import (
 4 "fmt"
 5 "io"
 6 "net"
 7)
 8func main() {
 9
10 r, w, _ := os.Pipe()
11 go func() {
12 w.Write([]byte("Pipe message"))
13 w.Close()
14 }()
15 pipeData, _ := io.ReadAll(r)
16 fmt.Println("Pipe read:", string(pipeData))
17}

3. 网络套接字socket
#

代码实现
#

1.python
#

</>
python


 1
 2import socket
 3# Server
 4srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 5srv.bind(('127.0.0.1', 12345))
 6srv.listen(1)
 7# Client
 8cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 9cli.connect(('127.0.0.1', 12345))
10# Accept and send
11conn, _ = srv.accept()
12conn.send(b"Socket data")
13print("Socket read:", cli.recv(100).decode())
14cli.close(); srv.close()

2. c++
#

</>
c++


 1#include <iostream>
 2#include <fstream>
 3#include <unistd.h>
 4#include <sys/wait.h>
 5#include <sys/socket.h>
 6#include <netinet/in.h>
 7
 8int main() {
 9 // Server setup
10 int srv_fd = socket(AF_INET, SOCK_STREAM, 0);
11 sockaddr_in addr = {AF_INET, htons(12345), INADDR_ANY};
12 bind(srv_fd, (sockaddr*)&addr, sizeof(addr));
13 listen(srv_fd, 1);
14 // Client connect
15 int cli_fd = socket(AF_INET, SOCK_STREAM, 0);
16 connect(cli_fd, (sockaddr*)&addr, sizeof(addr));
17 // Communication
18 int conn_fd = accept(srv_fd, nullptr, nullptr);
19 send(conn_fd, "Socket data", 12, 0);
20 char buffer[100];
21 recv(cli_fd, buffer, sizeof(buffer), 0);
22 std::cout << "Socket read: " << buffer << std::endl;
23 close(cli_fd); close(srv_fd);
24}

3. golang
#

</>
golang


 1package main
 2
 3import (
 4 "fmt"
 5 "io"
 6 "net"
 7)
 8func main() {
 9 // Server
10 listener, _ := net.Listen("tcp", "127.0.0.1:12345")
11 go func() {
12 conn, _ := listener.Accept()
13 conn.Write([]byte("Socket data"))
14 conn.Close()
15 }()
16 // Client
17 conn, _ := net.Dial("tcp", "127.0.0.1:12345")
18 sockData, _ := io.ReadAll(conn)
19 fmt.Println("Socket read:", string(sockData))
20}

Hugo学习250728

Mon, 28 Jul 2025 15:33:17 +0800

1. 可折叠列表 HTML5 标签，折叠内容无法支持原生markdown语法
#

config.yaml中配置，允许渲染 HTML 标签

</>
yaml


1markup:
2 goldmark:
3 renderer:
4 unsafe: true

使用原生html5 details标签

</>
html


1<details>
2 <summary>点击展开查看详情</summary>
3
4 这里是隐藏的内容，支持 **Markdown** 格式：
5
6 - 列表项1
7 - 列表项2
8 - [链接](https://example.com)
9</details>

效果：

这里是隐藏的内容，支持 Markdown 格式：

列表项1
列表项2
链接

本质是隐藏细节

嵌套

一级折叠标题

这是一级内容…

二级折叠标题

<details>
<summary>三级折叠标题</summary>
- 这是三级列表
- 支持 Markdown
- 可以无限嵌套（但建议不超过3-4层）
</details>

一级内容中的普通列表
也可以混合使用

似乎只能嵌套两层

元类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

词云实践流程

Thu, 24 Jul 2025 17:15:11 +0800

1. 通过deepseek生成词云`html、js、css`代码
#

</>
prompt参考


1我在做hugo页面，帮我生成标签词云的代码，我会在首页index.html中导入，词云内容为tag，点击跳转对应url，每个tag样式为圆形，大小只和tag字符关联，无旋转，排序权值使用tag文章数量，权值越高越靠中间，分成html css js三个文件实现，tag在html中使用.Site.Taxonomies.tags生成
2让词云标签贴合，至少行对齐（居中、等分对齐），有一定的对齐的美感

</>
生成


1tag-cloud.html
2tag-cloud.css
3tag-cloud.js

2. tag-cloud绑定在baseURL/tags/url上
#

原理：

</>
路由机制


1Hugo 会自动将 layouts/taxonomy/tag.terms.html 映射到 /tags/ URL
2这是 Hugo 分类系统（Taxonomy）的标准行为

流程：

- 1. 创建layouts/taxonomy/tag.terms.html
#

- 2. 在tag.terms.html中直接调用tag-cloud.html
#

</>
tag.terms.html


1{{ define "main" }}
2{{ partial "tag-cloud.html" . }}
3{{ end }}

- 3. 导入css、js文件
#

为了方便，直接在tag-cloud.html中嵌入了css、js的导入（缺点，页面会动态加载js）

hugo学习250723

Wed, 23 Jul 2025 15:01:34 +0800

hugo工作流程
#

url route -> 确定页面类型

hugo页面类型推断
#

(1) 文件系统结构
#

Hugo 会扫描 content/ 目录下的内容文件（如 .md 或 .html），根据文件的位置和命名规则自动推断页面类型：

</>
text


1_index.md → 列表页（kind: "section" 或 kind: "home"）
2
3普通内容文件（如 post.md） → 单页（kind: "page" 或 kind: "single"）
4
5分类/标签页 → 分类列表（kind: "taxonomy" 或 kind: "term"）

(2) 页面 Front Matter
#

通过 Front Matter 中的 type 或 layout 字段可手动指定类型（覆盖自动推断）：

用户态、内核态内存空间

Mon, 14 Jul 2025 15:39:03 +0800

用户态、内核态指内存空间，CPU的各寄存器则是CPU硬件，不属于内存部分，仅在需要存档备份数据时保存至（用户态/内核态）内存
1、进程内核栈
每个进程都有自己独立的位于内核空间的内核栈，保存进程在内核态执行的函数调用栈、局部变量、寄存器状态等数据

linux系统切换进程时会切换

内核栈
将 CPU 的栈指针寄存器 (SP/ESP/RSP, x86架构) 从指向进程 A 的内核栈顶部，修改为指向进程 B 的内核栈顶部
页目录
系统切换进程时找到进程的页目录的物理基地址（mm->pgd指针），写入CR3(x86)/TTBR0(ARM)寄存

2、进程页目录
存储在物理内存中，进程在创建时，系统创建mm_struct结构，用mm->pgd指针保存页目录物理基地址（用来在系统切换进程时找到进程的页目录的物理基地址，写入CR3(x86)/TTBR0(ARM)寄存器，完成进程上下文切换）
页目录包含进程使用的全部内存的虚拟内存地址->物理内存地址的映射关系
3、进程硬件上下文
运行时各寄存器的中间结果、比如PC程序计数器（下一条指令地址）、SP栈指针寄存器（当前调用栈顶）
切换时，这些数据被保存到进程内核栈中

4、线程切换总是发生在同一个进程（同一个虚拟地址空间）内的线程之间。不同进程的线程之间的切换，本质上是通过上层的进程切换完成的
5、切换线程时只切换线程内核栈，同样CPU栈指针寄存器从指向线程A的内核栈顶->B的内核栈顶。因为同属一个进程，所以不切换页目录，也即使用同一虚拟内存空间

6、进程、线程切换都依赖内核调度器，抢占式调度（时间片、中断）
7、协程切换只在用户态通过程序本身调度切换，主动让出，显式让出控制权
8、

进程	线程	协程
切换内核栈、页目录	切换内核栈	仅切换寄存器状态

9、用户态进程与内核态进程全双工通信 -> Netlink Socket

相比传统 IPC (syscall, ioctl, procfs)，Netlink 具有显著优势：易于扩展、异步通信、完美支持内核模块、强大的组播能力、真正的全双工通信、开发者友好的标准 Socket API。

单播回显: 用户请求->内核处理->内核响应的双向通信模式
内核主动组播: 内核主动向多个订阅进程广播事件的能力

netlink属于无连接协议（无连接协议是一种通信协议，其中每个数据包的处理都是独立的，不需要在发送数据之前建立连接）

闭包

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}

Hugo理解

Wed, 09 Jul 2025 14:07:34 +0800

hugo工作流程
#

导入主题后，完成自定义配置和资源

</>
markdown


 1- config yaml/toml/json
 2- assets
- css
- js
- images
 6- layouts
- 404.html : 404错误页面模板
- _default/ : 默认模板
- baseof.html : 基础模板框架
- list.html : 列表页模板（如分类、标签页）
- single.html : 单内容页模板（如文章页）
- terms.html : 分类列表模板（如所有标签的列表）
- partials/ : 可重用部分模板
- header.html : 页头部分
- footer.html : 页脚部分
- head.html : <head>部分
- ... : 其他部分模板
- shortcodes/ : 短代码模板
- figure.html : 图片短代码
- ... : 其他短代码
- index.html : 首页模板
- section/ : 分区模板（如博客、文档等）
- blog.html : 博客分区模板
- ... : 其他分区模板
- taxonomy/ : 分类法模板
- category.html : 分类页面模板
- tag.html : 标签页面模板
- ... : 其他自定义模板

所有layouts模板均可

Hugo博客搭建记录

Tue, 08 Jul 2025 10:18:41 +0800

环境准备
#

设备：ubuntu
github地址：https://github.com/gohugoio/hugo
安装：

</>
shell


1wget https://github.com/gohugoio/hugo/releases/download/v0.147.9/hugo_extended_0.147.9_Linux-64bit.tar.gz
2tar -xvzf hugo_extended_0.147.9_Linux-64bit.tar.gz
3sudo su
4mv hugo /usr/bin

Start!
#

1. 基础
#

1. 创建新博客
#

</> shell

1hugo new site siteproducer

2. 重要配置&配置逻辑链
#

2. 使用stack主题
#

</> shell

1git submodule add https://github.com/CaiJimmy/hugo-theme-stack themes/hugo-theme-stack

Hugo Tricks
#

1. 自定义样式
#

1. 样式覆盖规则：后引入覆盖前引入
#

params.yaml配置中指定自定义custom_css

</>
yaml


1custom_css: ["scss/custom.scss"]

assets/custom.scss中

</>
scss


1// 引入主题样式
2@import "general";
3// 引入你的自定义覆盖
4@import "custom-markdown"; // 无下划线、无扩展名

2. 自定义鸿蒙字体
#

下载鸿蒙字体
解压到siteproducer/assets/fonts目录
在assets/scss/中创建_fonts.scss，并在scss/custom.scss中引用

font.scss

技 on nayun blog

小知识

CICD

Jenkins流水线部署 #

画图

matplotlib #

LinuxHttp工具

wget #

Http文件服务器 #

LearnHugo250804

设置code-header.language-label点击折叠 #

设置代码块换行按钮功能 #

时间字符串

1. datetime系列 #

1. .fromtimestamp #

2. .strptime #

3. .replace #

Requests

requests.request方法 #

压缩解压

解压 #

基础 #

递归解压zip #

读日志

读取单个日志 #

1. 读全部日志 #

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

3. 反向读日志 #

日志分析

纯python处理 #

日志关键字处理 #

数据收集 #

Vscode

vscode 设置制表符转换空格 #

强制转换文档的table –> 4 spaces #

脚本日志

print #

纯print输出 #

封装print，自定义输出 #

logging #

通用代码 #

默认logger再封装 #

异常处理

核心思想：按需捕获 #

代码示例 #

异常重试 #

Linux文件读写

核心思想 #

1. 普通文件 #

代码通用实现 #

1. python #

2. c++ #

3. golang #

2. 管道 #

代码实现 #

1. python #

2. c++ #

3. golang #

3. 网络套接字socket #

代码实现 #

1.python #

2. c++ #

3. golang #

Hugo学习250728

1. 可折叠列表 HTML5 标签，折叠内容无法支持原生markdown语法 #

元类MetaClass

词云实践流程

1. 通过deepseek生成词云html、js、css代码 #

2. tag-cloud绑定在baseURL/tags/url上 #

- 1. 创建layouts/taxonomy/tag.terms.html #

- 2. 在tag.terms.html中直接调用tag-cloud.html #

- 3. 导入css、js文件 #

hugo学习250723

hugo工作流程 #

hugo页面类型推断 #

(1) 文件系统结构 #

(2) 页面 Front Matter #

用户态、内核态内存空间

闭包

典型用法 #

Jenkins流水线部署
#

matplotlib
#

wget
#

Http文件服务器
#

设置code-header.language-label点击折叠
#

设置代码块换行按钮功能
#

1. datetime系列
#

1. `.fromtimestamp`
#

2. `.strptime`
#

3. `.replace`
#

requests.request方法
#

解压
#

基础
#

递归解压zip
#

读取单个日志
#

1. 读全部日志
#

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

3. 反向读日志
#

纯python处理
#

日志关键字处理
#

数据收集
#

vscode 设置制表符转换空格
#

强制转换文档的table –> 4 spaces
#

print
#

纯print输出
#

封装print，自定义输出
#

logging
#

通用代码
#

默认logger再封装
#

核心思想：按需捕获
#

代码示例
#

异常重试
#

核心思想
#

1. 普通文件
#

代码通用实现
#

1. python
#

2. c++
#

3. golang
#

2. 管道
#

代码实现
#

1. python
#

2. c++
#

3. golang
#

3. 网络套接字socket
#

代码实现
#

1.python
#

2. c++
#

3. golang
#

1. 可折叠列表 HTML5 标签，折叠内容无法支持原生markdown语法
#

1. 通过deepseek生成词云`html、js、css`代码
#

2. tag-cloud绑定在baseURL/tags/url上
#

- 1. 创建layouts/taxonomy/tag.terms.html
#

- 2. 在tag.terms.html中直接调用tag-cloud.html
#

- 3. 导入css、js文件
#

hugo工作流程
#

hugo页面类型推断
#

(1) 文件系统结构
#

(2) 页面 Front Matter
#

典型用法
#

1. python装饰器
#

2. 函数工厂
#

示例
#

hugo工作流程
#

环境准备
#

Start!
#

1. 基础
#

1. 创建新博客
#

2. 重要配置&配置逻辑链
#

2. 使用stack主题
#

Hugo Tricks
#

1. 自定义样式
#

1. 样式覆盖规则：后引入覆盖前引入
#

2. 自定义鸿蒙字体
#