包与工程化 on 扎塔-Zata

python-lru_cache 缓存装饰器

Fri, 29 May 2026 11:09:25 +0800

Python `lru_cache` 缓存装饰器详解

lru_cache 是 Python 标准库 functools 里的一个装饰器，作用很纯粹：

记住函数的入参 → 返回值，下次同样入参直接返回缓存结果，不再执行函数体。

LRU = Least Recently Used（最近最少使用），是它在缓存满时的淘汰策略。

1. 它解决了什么问题

一个常见的痛点：某个函数纯计算，但比较慢（读盘、解析、网络、递归、DP 子问题等等）。同样入参被反复调用时，每一次都重算一遍，是纯浪费。

import time

def slow_square(x: int) -> int:
 time.sleep(1)
 return x * x

slow_square(3) # 1 秒
slow_square(3) # 又 1 秒
slow_square(3) # 再 1 秒……

加上 lru_cache：

from functools import lru_cache

@lru_cache(maxsize=128)
def slow_square(x: int) -> int:
 time.sleep(1)
 return x * x

slow_square(3) # 1 秒（miss，真的算）
slow_square(3) # 0 秒（hit，从缓存取）
slow_square(3) # 0 秒（hit）

2. 基本用法

from functools import lru_cache

@lru_cache(maxsize=128)
def fib(n: int) -> int:
 if n < 2:
 return n
 return fib(n - 1) + fib(n - 2)

fib(50) # 一瞬间出结果；没有 cache 时这是经典指数爆炸

maxsize=128：最多记住 128 组不同的 (入参 → 结果) 映射。
超出后最久没被命中的那个条目会被踢掉（这就是 LRU 的"L"和"R"）。
缓存挂在函数对象上，进程生命周期内一直存在；不同进程之间不共享。

3. 入参必须是可哈希的

lru_cache 内部把入参组成 tuple 当作 dict 的 key，所以入参必须是 hashable：

可以做 key	不能做 key
`int` / `float` / `str` / `bool`	`list`
`tuple`（且其中元素也都可哈希）	`dict`
`frozenset`	`set`
`bytes` / `None`	普通可变对象
`pathlib.Path`	`numpy.ndarray`

传入不可哈希参数时会抛 TypeError: unhashable type。

@lru_cache
def bad(x):
 return sum(x)

bad([1, 2, 3]) # TypeError: unhashable type: 'list'
bad((1, 2, 3)) # OK

关键字参数也会参与 key 计算，并且 f(1, 2) 和 f(1, b=2) 被当作不同的缓存条目——尽量统一调用风格。

4. 自带的辅助能力

被装饰的函数会多出三个方法：

fib.cache_info()
# CacheInfo(hits=48, misses=51, maxsize=128, currsize=51)

fib.cache_clear() # 清空整张缓存表
fib.cache_parameters() # {'maxsize': 128, 'typed': False}（3.9+）

cache_info() 调优时很有用：hits 远大于 misses 才说明缓存值钱。
cache_clear() 是测试或长跑服务里热更新配置时必备——下一节会展开。

5. `maxsize` 和 `typed` 怎么选

@lru_cache(maxsize=None, typed=False)
def f(...): ...

maxsize=None 或直接 @functools.cache（3.9+）：无大小上限、无淘汰。适合"键空间天然有限"的场景，比如解析一份固定文件、有限枚举类型。
maxsize=数字：留个上限防内存爆炸；常用 128、256、1024，按调用模式估。
typed=True：把 f(1) 和 f(1.0) 当成两个不同 key。默认 False，多数情况下不用动。

6. 实战例子：缓存配置文件解析

我在自己的项目里用 lru_cache 包装一个读取 TOML 配置的函数：

import tomllib
from functools import lru_cache
from pathlib import Path
from typing import Any


@lru_cache(maxsize=4)
def load_models_config(config_path: str | Path | None = None) -> dict[str, Any]:
 """加载 config.toml 中的 [models] section，并缓存解析结果。"""
 resolved_path = Path(config_path) if config_path else DEFAULT_TOML
 with open(resolved_path, "rb") as toml_file_handle:
 raw_toml_data = tomllib.load(toml_file_handle)
 return raw_toml_data.get("models", {})

收益：

长跑进程（API server、Agent runtime）里同样的配置可能被读上百次，加 cache 后只读盘一次。
maxsize=4 是保守值——默认 key 只有 None（默认路径），留三个余量给测试或自定义路径。

7. 三个常见陷阱

7.1 返回的是同一个对象，不是拷贝

@lru_cache
def get_settings() -> dict[str, Any]:
 return {"db_url": "postgres://..."}

cfg = get_settings()
cfg["db_url"] = "evil" # ⚠️ 改的是缓存里的那个 dict

get_settings()["db_url"] # 'evil'，已经被污染

对策：要么让函数返回不可变结构（frozendict、tuple、@dataclass(frozen=True)），要么在调用方拿到后立刻 copy.deepcopy，要么明确约定"只读"。

7.2 外部状态变了，缓存不会感知

@lru_cache
def read_file(path: str) -> str:
 return Path(path).read_text(encoding="utf-8")

read_file("config.toml") # 读到 v1
# ... 文件被改了 ...
read_file("config.toml") # 还是 v1！

lru_cache 只看入参，不看文件 mtime、不看时间戳。热重载场景不能用 lru_cache；要么换成手动管理的缓存层 + watchdog，要么手动 cache_clear()。

7.3 测试之间缓存会泄漏

pytest 跑在同一个 Python 进程里，模块级别的 @lru_cache 函数缓存会跨测试残留。前一个测试用 tmp_path 写入的配置，可能被后一个测试当作"默认配置"读到。

对策：写一个 autouse fixture 在每个测试前清缓存。

@pytest.fixture(autouse=True)
def _clear_models_config_cache() -> None:
 load_models_config.cache_clear()

8. `lru_cache` vs `functools.cache`（3.9+）

from functools import cache, lru_cache

@cache # 等价于 lru_cache(maxsize=None)
def f(x): ...

@lru_cache(maxsize=128) # 有上限，会淘汰
def g(x): ...

@cache：写法最简洁；无上限、无 LRU 淘汰、有内存风险。键空间小、可控时用它。
@lru_cache(maxsize=...)：键空间不确定、可能膨胀时用它，留一道保险。

9. 在类的方法上慎用

class Service:
 @lru_cache(maxsize=128)
 def expensive(self, x: int) -> int:
 ...

这种写法会把 self 也作为 cache key 的一部分，看上去能跑，但有两个副作用：

每个 Service 实例都有自己一份缓存（其实是 method 共享一张表、按 self 隔离）。
缓存会持有 self 的强引用，让本来该被回收的实例无法被 GC——是个隐蔽的内存泄漏。

更稳妥的做法：把要缓存的部分抽成模块级函数（不依赖 self），或者用第三方库 cachetools 的 @cachedmethod。

10. 一图小结

场景	推荐做法
纯计算函数、入参 hashable	`@lru_cache(maxsize=128)`
入参取值空间小、不会膨胀	`@functools.cache`
入参里有 `list` / `dict`	先把它转 `tuple` / `frozenset` 再缓存，或不用 cache
文件 / 配置可能被外部改	不要用 `lru_cache`，自己管理失效
测试之间不能共享缓存	autouse fixture 调 `.cache_clear()`
实例方法	抽成模块级函数，或换 `cachetools.cachedmethod`

lru_cache 是 Python 里"用最少的代码换到最多的性能"的几个工具之一，但用之前最好先想清楚两件事：

同样入参真的会被反复调用吗？ 如果不会，加 cache 只是徒增复杂度。
被缓存的返回值是否安全共享？ 是否需要担心调用方误改、外部状态过期、self 泄漏？

想清楚这两点，再决定要不要加 @lru_cache。

python-将py文件编译为pyc文件并运行

Mon, 28 Apr 2025 17:24:39 +0800

py编译为pyc(为了代码加密)

问题提醒

1. 版本号问题：编译版本和runtime版本不一致会导致报错

打包过程

我在2025年5月左右开发了一个软件项目，想要将其发布，代码中有我的api-key，因此我需要将代码进行加密。

（打包我使用的是PyStand项目，他最简单的方式当然是直接粘贴源码了。）

项目结构如下：

实际上必要的程序是我用红框圈起来的，src是放了我的核心代码，run.py是入口程序，然后config.yaml是配置文件

1. 新建compile_py.py文件并填入代码

其中script文件夹就是源码，out_文件夹用来防止编译后的文件，可以手动创建一下

需要注意的是，运行这边编译代码的py版本和runtime的嵌入版本要一致，大版本一致就行了，比如编译是3.11.16和runtime3.11.15好像没什么影响


import py_compile
import os
import hashlib

# 配置
script_dir = 'script' # 输入文件夹
output_dir = 'out_' # 输出根目录
preserve_structure = True # 是否保留文件夹结构（True/False）

# 确保 script 文件夹存在
if not os.path.exists(script_dir):
 print(f"Error: Directory '{script_dir}' does not exist.")
 exit(1)

# 遍历 script 文件夹及其子文件夹
for root, _, files in os.walk(script_dir):
 for filename in files:
 if filename.endswith('.py'):
 # 构造完整的 .py 文件路径
 py_file = os.path.join(root, filename)

 # 计算相对路径
 relative_path = os.path.relpath(py_file, script_dir)
 base_name = os.path.splitext(filename)[0]

 if preserve_structure:
 # 保留文件夹结构：输出到 output_dir 下的相对路径
 pyc_relative_dir = os.path.dirname(relative_path)
 pyc_dir = os.path.join(output_dir, pyc_relative_dir)
 os.makedirs(pyc_dir, exist_ok=True)
 pyc_filename = f"{base_name}.pyc"
 pyc_file = os.path.join(pyc_dir, pyc_filename)
 else:
 # 不保留结构：平铺到 output_dir，使用哈希前缀避免冲突
 hash_prefix = hashlib.md5(relative_path.encode()).hexdigest()[:8]
 pyc_filename = f"{hash_prefix}_{base_name}.pyc"
 pyc_file = os.path.join(output_dir, pyc_filename)

 try:
 # 编译 .py 文件为 .pyc 文件
 py_compile.compile(py_file, cfile=pyc_file)
 print(f"Compiled {py_file} to {pyc_file}")
 except Exception as e:
 print(f"Failed to compile {py_file}: {e}")

2. 不编译py外文件，手动修改

因为不编译py文件以外的，但是需要用到配置文件，就手动移动一下，然后把整个文件夹移动到PyStand的分发包里面

（其中我把两个test文件删除了）

python-相对导入错误attempted relative import with no known parent package

Thu, 20 Mar 2025 11:46:30 +0800

下面是一个简洁的教程，旨在帮助读者理解并解决你在运行 arxiv.py 时遇到的 ImportError: attempted relative import with no known parent package 错误。这个教程将从问题背景开始，逐步分析原因，并提供多种解决方案。

教程：解决 Python 相对导入错误 - “attempted relative import with no known parent package”

背景

假设你有一个 Python 项目，目录结构如下：

Upick/
├── src/
│ ├── crawler/
│ │ ├── arxiv.py
│ │ └── base.py

在 arxiv.py 中，你尝试使用相对导入：

from .base import BaseCrawler

然后在命令行中运行：

python -u "c:\Users\zata\Desktop\UPick\src\crawler\arxiv.py"

结果却报错：

Traceback (most recent call last):
 File "c:\Users\zata\Desktop\UPick\src\crawler\arxiv.py", line 7, in <module>
 from .base import BaseCrawler
ImportError: attempted relative import with no known parent package

这个错误困扰了许多 Python 开发者。本教程将解释其原因并提供解决方案。

问题原因

在 Python 中，相对导入（例如 from .base import BaseCrawler）依赖于包结构。当你直接运行一个 .py 文件（例如 python arxiv.py），Python 会将其视为独立脚本，而不是包的一部分。这时，相对导入无法解析，因为 Python 不知道当前文件所属的包。

在这个例子中：

arxiv.py 使用 .base 表示从同一目录（crawler）导入 base.py。
但直接运行 arxiv.py 时，Python 不认为 crawler 是一个包，因此无法找到 .base。

前置条件

要解决这个问题，确保你的项目满足以下条件：

base.py 存在于 crawler 目录下，并且定义了 BaseCrawler 类。
你希望保持模块化的代码结构，而不是硬编码绝对路径。

解决方案

方法 1：以模块方式运行 (推荐)

Python 提供了 -m 参数，允许你以模块方式运行脚本，这样可以正确解析包结构。

步骤：

添加包标志文件
确保 crawler 目录下有一个空的 __init__.py 文件。这是 Python 识别包的标志。更新后的结构：

Upick/
├── src/
│ ├── crawler/
│ │ ├── __init__.py
│ │ ├── arxiv.py
│ │ └── base.py

切换到项目根目录
在命令行中进入 Upick 目录：
```
cd C:\Users\zata\Desktop\Upick
```
运行模块
使用以下命令运行：
```
python -m src.crawler.arxiv
```
-m 表示将 src.crawler.arxiv 作为模块运行，而不是直接运行文件。

为什么有效？

以模块方式运行时，Python 会从 Upick 开始解析包结构，识别 src 和 crawler 作为包，因此相对导入 from .base import BaseCrawler 可以正常工作。

方法 2：调整 PYTHONPATH

如果你希望直接运行文件，可以通过设置 PYTHONPATH 来告诉 Python 包的根目录。

步骤：

设置 PYTHONPATH
将 PYTHONPATH 设置为包含 src 的父目录：
```
set PYTHONPATH=C:\Users\zata\Desktop\Upick\src
```

运行文件
在命令行中运行：

python -u "c:\Users\zata\Desktop\UPick\src\crawler\arxiv.py"

注意：

仍然需要在 crawler 目录下有 __init__.py 文件。
这种方法不如方法 1 优雅，因为它依赖于环境变量。

方法 3：改为绝对导入

如果你不想依赖包结构，可以将相对导入改为绝对导入。

步骤：

修改导入语句
编辑 arxiv.py，将：

from .base import BaseCrawler

改为：

from src.crawler.base import BaseCrawler

设置 PYTHONPATH
在命令行中运行：

set PYTHONPATH=C:\Users\zata\Desktop\Upick
python -u "c:\Users\zata\Desktop\UPick\src\crawler\arxiv.py"

优点与缺点：

优点：无需依赖包结构和 __init__.py。
缺点：代码中硬编码了路径，移植性较差。

方法 4：检查文件和结构

有时问题出在文件本身。确保以下几点：

base.py 存在于 crawler 目录下。

base.py 中正确定义了 BaseCrawler 类，例如：

# base.py
class BaseCrawler:
 def __init__(self):
 print("BaseCrawler initialized")

crawler 目录下有 __init__.py。

测试与验证

运行后，如果没有错误，arxiv.py 将成功导入 BaseCrawler 并执行后续逻辑。如果仍有问题，可以检查：

是否遗漏了 __init__.py。
base.py 中的类名是否拼写正确。

总结

Python 的相对导入依赖于包结构，直接运行脚本会导致 ImportError。通过以模块方式运行（python -m）、调整 PYTHONPATH 或改为绝对导入，你可以轻松解决问题。根据项目需求选择适合的方法，但通常以模块方式运行是最优解。

python-在项目中应该如何定义文件路径

Wed, 19 Mar 2025 10:57:57 +0800

虽然也是老生常态的事情了，无论是把代码打包成exe还是在多平台的迁移上，经常会涉及到这个问题，原本我以为我已经不会再犯错了，没想到今天还是又犯错了，算是给自己提一个醒吧。

具体描述一下遇到了什么问题：

我写了一个项目，在项目中，我使用了绝对路径定义了一个sqlite数据库，如下：

在windows平台上运行没有问题，然后放到Linux上，重要的是！！！它也不报错，然后我部署好之后我也没有看文件路径，心想没有报错能有什么事情，然后第二天发现没有按照原本方式执行，这时候就感觉有问题了，然后进入docker一看，生成了这么一个文件：

笑死了….

如何在python中定义文件路径

在项目中定义文件路径时，尤其是涉及到像 SQLite 数据库这样的资源，关键是要确保路径的可移植性和可靠性。以下是一些建议和操作步骤，帮助你在项目中合理定义和管理文件路径：

1. 理解相对路径和绝对路径

绝对路径：从文件系统的根目录开始，例如 /home/user/project/db/mydatabase.db（Linux/Mac）或 C:\Users\user\project\db\mydatabase.db（Windows）。这种方式依赖具体的文件系统结构，不利于跨平台或项目迁移。
相对路径：相对于当前工作目录或项目根目录，例如 ./db/mydatabase.db。这种方式更灵活，推荐在项目中使用。

为了让项目更健壮，建议使用相对路径，并结合编程语言提供的工具动态生成路径。

2. SQLite 数据库路径的定义方法

假设你的项目结构如下：

project/
├── src/
│ └── main.py
├── db/
│ └── mydatabase.db
└── README.md

Python 示例

在 Python 中，可以使用 os 或 pathlib 模块来动态构建路径，确保跨平台兼容：

import os
from pathlib import Path

# 方法 1：使用 os 模块
BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # 获取当前脚本所在目录
DB_PATH = os.path.join(BASE_DIR, "..", "db", "mydatabase.db") # 构建数据库路径
DB_PATH = os.path.normpath(DB_PATH) # 规范化路径，处理斜杠差异

# 方法 2：使用 pathlib（更现代的方式）
BASE_DIR = Path(__file__).resolve().parent # 当前脚本目录
DB_PATH = BASE_DIR / ".." / "db" / "mydatabase.db" # 使用 / 拼接路径

# 连接 SQLite 数据库
import sqlite3
conn = sqlite3.connect(DB_PATH)
print(f"数据库路径: {DB_PATH}")

__file__：表示当前脚本的文件路径。
os.path.abspath 或 Path.resolve()：将路径转换为绝对路径，避免相对路径的歧义。
os.path.join 或 Path 的 / 操作符：跨平台拼接路径，自动处理 Windows 和 Unix 的斜杠差异。

3. 最佳实践

a. 将路径定义为配置

将文件路径集中管理，避免硬编码。例如：

# config.py
from pathlib import Path
BASE_DIR = Path(__file__).resolve().parent.parent # 项目根目录
DB_PATH = BASE_DIR / "db" / "mydatabase.db"

# main.py
from config import DB_PATH
import sqlite3
conn = sqlite3.connect(DB_PATH)

b. 检查文件是否存在

在连接数据库前，确保文件存在：

if not DB_PATH.exists():
 raise FileNotFoundError(f"数据库文件不存在: {DB_PATH}")
conn = sqlite3.connect(DB_PATH)

c. 考虑打包或部署

如果项目会被打包（如用 PyInstaller），相对路径可能失效。可以用以下方式动态检测：

import sys
if getattr(sys, 'frozen', False): # 如果是打包后的可执行文件
 BASE_DIR = Path(sys.executable).parent
else:
 BASE_DIR = Path(__file__).resolve().parent.parent
DB_PATH = BASE_DIR / "db" / "mydatabase.db"

d. 数据库初始化

如果数据库文件不存在，可以在代码中创建：

if not DB_PATH.exists():
 conn = sqlite3.connect(DB_PATH) # 创建空数据库
 # 这里可以添加表结构初始化代码
else:
 conn = sqlite3.connect(DB_PATH)

4. 注意事项

权限问题：确保程序对目标路径有读写权限，尤其是部署到服务器时。
跨平台兼容：始终使用 os.path.join 或 pathlib 处理路径，避免手动写斜杠。
安全性：不要将数据库放在公开访问的目录（如 web 服务器的根目录），建议放在项目专用目录中。

5. 总结

对于你的 SQLite 数据库，推荐的做法是：

将数据库放在项目目录的子文件夹中（如 db/mydatabase.db）。
使用 pathlib 或 os 动态构建路径，基于项目根目录。
将路径定义在配置文件中，方便维护。
在代码中检查文件是否存在并处理异常。

python中将函数设置为定时任务

Tue, 18 Mar 2025 15:59:11 +0800

将函数设置为定时任务有几种方法。以下是几种常用的实现方案：

方案1：使用Python的schedule库

这是一个在Python应用程序内部实现的轻量级定时任务方案：

import schedule
import time
import threading
from src.db import refresh_content

def run_scheduler():
 """启动定时任务调度器"""
 # 每小时执行一次刷新
 schedule.every(1).hour.do(refresh_content)

 # 也可以设置特定时间执行，例如每天凌晨2点
 # schedule.every().day.at("02:00").do(refresh_content)

 while True:
 schedule.run_pending()
 time.sleep(60) # 每分钟检查一次是否有待执行的任务

# 在单独的线程中运行调度器，这样不会阻塞主应用
def start_scheduler_thread():
 scheduler_thread = threading.Thread(target=run_scheduler)
 scheduler_thread.daemon = True # 设置为守护线程，这样主程序退出时线程也会退出
 scheduler_thread.start()

将此代码添加到应用程序启动过程中：

if __name__ == "__main__":
 # 启动定时任务
 start_scheduler_thread()

 # 启动主应用（例如Gradio界面）
 app.launch()

方案2：使用APScheduler库

APScheduler是一个更强大的Python调度库，支持持久化任务和多种调度器后端：

from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.triggers.interval import IntervalTrigger
from src.db import refresh_content

def setup_scheduler():
 """设置并启动APScheduler调度器"""
 scheduler = BackgroundScheduler()

 # 添加刷新任务，每小时执行一次
 scheduler.add_job(
 func=refresh_content,
 trigger=IntervalTrigger(hours=1),
 id='refresh_content_job',
 name='刷新订阅内容',
 replace_existing=True
 )

 # 启动调度器
 scheduler.start()
 return scheduler

在主应用中集成：

if __name__ == "__main__":
 # 启动定时任务调度器
 scheduler = setup_scheduler()

 # 启动主应用
 try:
 app.launch()
 finally:
 # 在应用关闭时优雅地关闭调度器
 scheduler.shutdown()

方案3：使用系统级定时任务

Linux/Mac上使用cron

创建一个独立的Python脚本，例如refresh_subscriptions.py：

#!/usr/bin/env python3
# refresh_subscriptions.py
from src.db import refresh_content

if __name__ == "__main__":
 result = refresh_content()
 print(result)

使用crontab设置定时任务：

# 编辑crontab
crontab -e

# 添加以下行，每小时执行一次
0 * * * * /path/to/python /path/to/refresh_subscriptions.py >> /path/to/logs/refresh.log 2>&1

Windows上使用任务计划程序

创建类似的Python脚本
打开任务计划程序，创建基本任务
设置触发器为每小时执行一次
操作设置为运行Python解释器，参数为脚本路径

方案4：使用Celery（对于大型应用）

如果你的应用较大，可以考虑使用Celery：

# 设置Celery
from celery import Celery
from celery.schedules import crontab

app = Celery('subscription_manager', broker='redis://localhost:6379/0')

# 配置定时任务
app.conf.beat_schedule = {
 'refresh-content-hourly': {
 'task': 'tasks.refresh_content_task',
 'schedule': crontab(minute=0, hour='*'), # 每小时整点执行
 },
}

# 定义任务
@app.task
def refresh_content_task():
 from src.db import refresh_content
 return refresh_content()

实现建议

对于简单部署：使用方案1或方案2，将定时任务集成到主应用中
对于生产环境：使用方案3，将刷新任务与Web应用分离，降低相互影响
对于高负载场景：使用方案4，实现任务队列和分布式处理

python-logging模块添加日志

Tue, 18 Mar 2025 14:30:39 +0800

在 Python 项目中添加日志功能是一个很好的实践，可以帮助你跟踪程序运行状态、调试问题以及记录重要事件。对于一个包含多个文件且存在调用关系的项目，可以通过以下步骤实现日志功能：

基本概念

1. 使用 Python 的 `logging` 模块

Python 内置的 logging 模块非常强大且灵活，适合在多文件项目中使用。相比 print，它提供了日志级别（如 DEBUG、INFO、ERROR 等）、格式化输出、文件记录等功能。

2. 基本实现步骤

以下是一个在多文件项目中添加日志的通用方法：

(1) 创建一个日志配置模块

在一个单独的文件（例如 logger.py）中配置日志，这样可以全局复用。

# logger.py
import logging
import os

# 创建日志器
logger = logging.getLogger('MyProject')
logger.setLevel(logging.DEBUG) # 设置全局日志级别

# 创建日志处理器（输出到控制台）
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO) # 控制台显示 INFO 及以上级别

# 创建日志处理器（输出到文件）
log_dir = "logs"
if not os.path.exists(log_dir):
 os.makedirs(log_dir)
file_handler = logging.FileHandler(os.path.join(log_dir, "app.log"), encoding="utf-8")
file_handler.setLevel(logging.DEBUG) # 文件记录 DEBUG 及以上级别

# 设置日志格式
formatter = logging.Formatter(
 "%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s"
)
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

# 将处理器添加到日志器
logger.addHandler(console_handler)
logger.addHandler(file_handler)

# 提供获取日志器的方法
def get_logger(name):
 return logging.getLogger(f"MyProject.{name}")

这个配置：

将日志同时输出到控制台和文件。
文件日志记录所有级别（DEBUG 及以上），控制台只显示 INFO 及以上。
日志格式包括时间、模块名、级别、文件名、行号和消息。

(2) 在其他文件中使用日志

在项目中的各个文件里，通过 logger.py 获取日志器并使用。

例如，假设你有两个文件 module1.py 和 module2.py，它们之间有调用关系：

# module1.py
from logger import get_logger

logger = get_logger("module1")

def func1():
 logger.debug("正在执行 func1")
 logger.info("func1 开始调用 func2")
 from module2 import func2
 func2()
 logger.info("func1 执行完成")

# module2.py
from logger import get_logger

logger = get_logger("module2")

def func2():
 logger.debug("正在执行 func2")
 logger.warning("func2 中可能有潜在问题")
 logger.info("func2 执行完成")

(3) 主程序入口

在主程序中调用这些模块：

# main.py
from logger import get_logger
from module1 import func1

logger = get_logger("main")

if __name__ == "__main__":
 logger.info("程序启动")
 func1()
 logger.info("程序结束")

运行后，日志会同时输出到控制台和 logs/app.log 文件中。文件中的日志可能如下：

2025-03-17 10:00:00,123 - MyProject.main - INFO - main.py:7 - 程序启动
2025-03-17 10:00:00,125 - MyProject.module1 - DEBUG - module1.py:5 - 正在执行 func1
2025-03-17 10:00:00,126 - MyProject.module1 - INFO - module1.py:6 - func1 开始调用 func2
2025-03-17 10:00:00,127 - MyProject.module2 - DEBUG - module2.py:5 - 正在执行 func2
2025-03-17 10:00:00,128 - MyProject.module2 - WARNING - module2.py:6 - func2 中可能有潜在问题
2025-03-17 10:00:00,129 - MyProject.module2 - INFO - module2.py:7 - func2 执行完成
2025-03-17 10:00:00,130 - MyProject.module1 - INFO - module1.py:8 - func1 执行完成
2025-03-17 10:00:00,131 - MyProject.main - INFO - main.py:9 - 程序结束

控制台只会显示 INFO 及以上级别的日志。

3. 高级配置（可选）

如果项目较大或需求更复杂，可以考虑以下优化：

(1) 使用配置文件

将日志配置写入一个配置文件（例如 logging_config.ini），然后通过 logging.config 加载：

# logging_config.ini
[loggers]
keys=root

[handlers]
keys=consoleHandler,fileHandler

[formatters]
keys=simpleFormatter

[logger_root]
level=DEBUG
handlers=consoleHandler,fileHandler

[handler_consoleHandler]
class=StreamHandler
level=INFO
formatter=simpleFormatter
args=(sys.stdout,)

[handler_fileHandler]
class=FileHandler
level=DEBUG
formatter=simpleFormatter
args=('logs/app.log', 'a', 'utf-8')

[formatter_simpleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s

在 logger.py 中加载：

# logger.py
import logging.config

logging.config.fileConfig("logging_config.ini")
logger = logging.getLogger("MyProject")

def get_logger(name):
 return logging.getLogger(f"MyProject.{name}")

(2) 日志按时间分割

使用 logging.handlers.TimedRotatingFileHandler 实现日志按时间（例如每天）分割：

# logger.py
from logging.handlers import TimedRotatingFileHandler

file_handler = TimedRotatingFileHandler(
 "logs/app.log", when="midnight", interval=1, backupCount=7, encoding="utf-8"
)
file_handler.setLevel(logging.DEBUG)

这会每天生成一个新日志文件，并保留最近 7 天的日志。

(3) 避免重复日志

如果模块被多次导入，确保日志处理器不会重复添加。可以在 logger.py 中添加检查：

if not logger.handlers:
 logger.addHandler(console_handler)
 logger.addHandler(file_handler)

4. 注意事项

日志级别：合理选择日志级别（DEBUG 用于调试，INFO 用于常规信息，WARNING 用于警告，ERROR 用于错误）。
性能：日志过多可能影响性能，建议在生产环境中调整日志级别（例如只记录 INFO 以上）。
模块化：通过 get_logger("模块名") 为每个模块创建独立的日志器，便于追踪调用关系。

5. 总结

通过以上方法，你可以在多文件 Python 项目中实现统一的日志管理。推荐从简单的 logger.py 开始，随着项目需求增加再逐步优化配置。

在 Python 的 logging 模块中，日志级别是用来区分日志消息重要性的一种机制。不同的级别对应不同的使用场景，帮助开发者或运维人员快速筛选和定位信息。logging 模块内置了以下几种标准日志级别，从低到高排列：

日志级别划分

以下是 Python logging 模块的标准日志级别及其数值（数值越大，级别越高）：

级别	数值	描述
`NOTSET`	0	未设置，默认级别，通常不直接使用。
`DEBUG`	10	调试信息，通常用于开发和调试阶段，记录详细的程序运行细节。
`INFO`	20	常规信息，用于确认程序按预期运行，记录关键步骤或状态。
`WARNING`	30	警告信息，表示可能存在问题，但程序仍能继续运行（默认级别）。
`ERROR`	40	错误信息，表示发生了较严重的问题，某些功能可能无法正常执行。
`CRITICAL`	50	严重错误信息，表示程序遇到致命问题，可能无法继续运行。

各日志级别的使用场景

DEBUG（调试）
- 用途：记录详细的调试信息，例如变量值、函数调用栈、循环迭代等。
- 场景：开发和测试阶段，用于排查问题。
- 示例：
```
logger.debug("变量 x 的值: %s", x)
```
INFO（信息）
- 用途：记录程序正常运行时的关键信息，例如启动、结束、重要步骤完成。
- 场景：生产环境中确认程序正常运行。
- 示例：
```
logger.info("服务器启动成功，监听端口: 8080")
```
WARNING（警告）
- 用途：记录潜在问题或非预期情况，但不影响程序继续运行。
- 场景：提醒开发者或用户注意某些异常情况。
- 示例：
```
logger.warning("配置文件未找到，使用默认设置")
```
ERROR（错误）
- 用途：记录发生的错误，通常会导致某些功能失效。
- 场景：生产环境中记录需要修复的问题。
- 示例：
```
logger.error("数据库连接失败: %s", exception_message)
```
CRITICAL（严重）
- 用途：记录致命错误，通常会导致程序崩溃或无法继续运行。
- 场景：需要立即关注和处理的问题。
- 示例：
```
logger.critical("系统内存不足，程序即将退出")
```

日志级别的工作机制

日志器的级别：通过 logger.setLevel() 设置，只有大于等于该级别的日志才会记录。
- 例如，如果设置为 INFO，则 DEBUG 日志不会输出，但 INFO、WARNING、ERROR 和 CRITICAL 会输出。
处理器的级别：每个处理器（如 StreamHandler、FileHandler）也可以单独设置级别，决定输出哪些日志。
- 例如，控制台只显示 INFO 及以上，文件记录 DEBUG 及以上。

示例代码

import logging

# 创建日志器
logger = logging.getLogger("example")
logger.setLevel(logging.DEBUG) # 日志器记录所有级别

# 创建控制台处理器，只显示 INFO 及以上
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
console_handler.setFormatter(logging.Formatter("%(levelname)s - %(message)s"))
logger.addHandler(console_handler)

# 创建文件处理器，记录 DEBUG 及以上
file_handler = logging.FileHandler("example.log", encoding="utf-8")
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
logger.addHandler(file_handler)

# 测试不同级别日志
logger.debug("这是一个调试信息")
logger.info("这是一个常规信息")
logger.warning("这是一个警告信息")
logger.error("这是一个错误信息")
logger.critical("这是一个严重错误信息")

输出结果：

控制台（只显示 INFO 及以上）：

INFO - 这是一个常规信息
WARNING - 这是一个警告信息
ERROR - 这是一个错误信息
CRITICAL - 这是一个严重错误信息

文件 example.log（记录 DEBUG 及以上）：

2025-03-17 10:00:00,123 - DEBUG - 这是一个调试信息
2025-03-17 10:00:00,124 - INFO - 这是一个常规信息
2025-03-17 10:00:00,125 - WARNING - 这是一个警告信息
2025-03-17 10:00:00,126 - ERROR - 这是一个错误信息
2025-03-17 10:00:00,127 - CRITICAL - 这是一个严重错误信息

如何选择日志级别

开发阶段：多用 DEBUG 和 INFO，方便调试。
生产环境：通常设置为 INFO 或 WARNING，避免过多调试信息影响性能。
异常处理：用 ERROR 或 CRITICAL 记录错误，并结合异常堆栈（如 logger.exception()）。

自定义日志级别（可选）

如果内置级别不够用，可以通过 logging.addLevelName() 定义新级别：

logging.addLevelName(15, "VERBOSE")
logger.setLevel(15)
logger.log(15, "这是一个自定义VERBOSE信息")

python使用教程-难点和遇到的问题

Thu, 13 Mar 2025 10:17:58 +0800

功能实现和知识点

python程序后台运行

python后台运行

linux

# 1. 使用nohup
nohup python3 script.py > output.log 2>&1 &

# 你也可以把上面这个代码放入.sh文件中
echo 'nohup python3 script.py > output.log 2>&1 &' >> run_script.sh

chmod +x script.py

./script.py


# 2. 使用tmux

sudo apt install tmux # Ubuntu/Debian
# 或
sudo yum install tmux # CentOS/RHEL

tmux new -s my_session # 创建会话

python3 your_script.py # 在会话中运行 Python 脚本

# 按 Ctrl+B，然后按 D # 断开会话（脚本继续运行）

---

tmux attach -t my_session # 恢复会话
tmux kill-session -t my_session # 终止会话

nohup详细解释

nohup python3 script.py > output.log 2>&1 &
作用：使 Python 脚本在终端关闭后继续运行。
解释：
nohup：忽略挂起信号（HUP），防止终端关闭导致进程终止。
python3 script.py：运行你的 Python 脚本。
> output.log：将标准输出重定向到 output.log。
2>&1：将标准错误输出也重定向到 output.log。
&：将进程放入后台运行。

Python 函数定义教程

什么是函数？函数是一段可重用的代码块，用于执行特定任务。它可以接受输入（参数），处理逻辑，并返回输出（返回值）。函数使代码更模块化、可读和可维护。

函数的基本定义在 Python 中，函数使用 def 关键字定义，基本语法如下：

def function_name(parameters):
 """Docstring: 函数的说明文档"""
 # 函数体
 # 执行具体逻辑
 return result # 可选的返回值

def: 定义函数的关键字。
function_name: 函数的名称，遵循变量命名规则（小写字母、单词用下划线分隔）。
parameters: 函数的输入参数（可选）。
:: 表示函数体开始。
函数体: 缩进的代码块，包含函数的逻辑。
return: 返回结果（可选），如果没有 return，函数默认返回 None。
文档字符串（Docstring）: 用三引号 """ 包裹，描述函数的作用、参数和返回值（推荐使用）。

示例：

def greet(name):
 """返回对指定用户的问候语。

 参数:
 name (str): 用户的姓名。

 返回:
 str: 格式化的问候语。
 """
 message = f"你好，{name}！"
 return message

# 调用函数
print(greet("Alice")) # 输出: 你好，Alice！

参数的类型 Python 函数支持多种参数类型，帮助灵活处理输入：

位置参数按顺序传递参数，调用时必须按照定义的顺序提供。

示例：

def add(a, b):
 """返回两个数的和。"""
 return a + b

print(add(3, 5)) # 输出: 8

关键字参数调用时指定参数名，顺序不重要，增强代码可读性。

示例：

def introduce(name, age):
 """介绍一个人。"""
 return f"{name} 是 {age} 岁。"

print(introduce(age=25, name="Bob")) # 输出: Bob 是 25 岁。

默认参数为参数设置默认值，如果调用时不提供该参数，则使用默认值。

示例：

def greet(name, greeting="你好"):
 """返回问候语，带有默认问候词。"""
 return f"{greeting}，{name}！"

print(greet("Alice")) # 输出: 你好，Alice！
print(greet("Bob", "Hi")) # 输出: Hi，Bob！

可变参数：*args *args 允许函数接受任意数量的位置参数，参数被收集为一个元组。

示例：

def sum_numbers(*args):
 """返回所有输入数字的和。"""
 return sum(args)

print(sum_numbers(1, 2, 3)) # 输出: 6
print(sum_numbers(1, 2, 3, 4, 5)) # 输出: 15

关键字可变参数：**kwargs **kwargs 允许函数接受任意数量的关键字参数，参数被收集为一个字典。

示例：

def print_info(**kwargs):
 """打印所有关键字参数。"""
 for key, value in kwargs.items():
 print(f"{key}: {value}")

print_info(name="Alice", age=25, city="Shanghai")
# 输出:
# name: Alice
# age: 25
# city: Shanghai

编写出色的函数：最佳实践要编写高质量的函数，遵循以下原则：

单一职责原则一个函数只做一件事，保持逻辑简单。例如，计算面积的函数不应同时打印结果。

示例：

def calculate_circle_area(radius):
 """计算圆的面积。"""
 return 3.14159 * radius ** 2

def print_area(area):
 """打印面积。"""
 print(f"面积是: {area}")

# 使用
area = calculate_circle_area(5)
print_area(area) # 输出: 面积是: 78.53975

使用有意义的函数和参数名函数名应清晰描述其功能，参数名应直观。例如，calculate_circle_area(radius) 比 calc(x) 更清晰。

始终添加文档字符串文档字符串（Docstring）描述函数的作用、参数和返回值，方便他人理解和使用。

示例：

def divide(a, b):
 """将两个数相除并返回结果。

 参数:
 a (float): 被除数。
 b (float): 除数，不能为 0。

 返回:
 float: 除法结果。

 抛出:
 ZeroDivisionError: 当 b 为 0 时抛出。
 """
 return a / b

处理异常在函数中处理可能的错误，增强健壮性。

示例：

def divide_safe(a, b):
 """安全地执行除法操作。

 参数:
 a (float): 被除数。
 b (float): 除数。

 返回:
 float 或 None: 除法结果，如果除数为 0 则返回 None。
 """
 try:
 return a / b
 except ZeroDivisionError:
 print("错误：除数不能为 0！")
 return None

print(divide_safe(10, 0)) # 输出: 错误：除数不能为 0！ None
print(divide_safe(10, 2)) # 输出: 5.0

限制函数长度函数体应尽量简短（建议不超过 20-30 行）。如果逻辑复杂，拆分为多个小函数。

使用类型提示（Type Hints） Python 3.5+ 支持类型提示，增强代码可读性和 IDE 支持。

示例：

def add_numbers(a: float, b: float) -> float:
 """返回两个数的和。"""
 return a + b

高级函数技巧使用 lambda 函数 lambda 用于定义简短的匿名函数，常用于一次性或简单逻辑。

示例：

# 定义一个 lambda 函数
square = lambda x: x ** 2
print(square(5)) # 输出: 25

# 在 sorted 中使用 lambda
names = ["Alice", "Bob", "Charlie"]
sorted_names = sorted(names, key=lambda x: len(x))
print(sorted_names) # 输出: ['Bob', 'Alice', 'Charlie']

函数作为参数函数可以作为参数传递给其他函数，常见于回调函数。

示例：

def apply_operation(numbers, operation):
 """对数字列表应用指定操作。"""
 return [operation(x) for x in numbers]

def double(x):
 return x * 2

numbers = [1, 2, 3]
result = apply_operation(numbers, double)
print(result) # 输出: [2, 4, 6]

装饰器装饰器是函数的高级用法，用于在不修改函数代码的情况下添加功能。

示例：

def log_function(func):
 """记录函数调用信息。"""
 def wrapper(*args, **kwargs):
 print(f"调用函数: {func.__name__}，参数: {args}, {kwargs}")
 return func(*args, **kwargs)
 return wrapper

@log_function
def add(a, b):
 """返回两个数的和。"""
 return a + b

print(add(3, 5))
# 输出:
# 调用函数: add，参数: (3, 5), {}
# 8

实践：编写一个出色的函数任务：编写一个函数，计算一个数的阶乘，支持输入验证和异常处理。

示例：

def factorial(n: int) -> int:
 """计算 n 的阶乘。

 参数:
 n (int): 非负整数。

 返回:
 int: n 的阶乘。

 抛出:
 ValueError: 如果 n 不是非负整数。
 """
 if not isinstance(n, int):
 raise ValueError("输入必须是整数")
 if n < 0:
 raise ValueError("输入必须是非负整数")
 if n == 0 or n == 1:
 return 1
 result = 1
 for i in range(2, n + 1):
 result *= i
 return result

# 测试
try:
 print(factorial(5)) # 输出: 120
 print(factorial(-1)) # 抛出 ValueError
except ValueError as e:
 print(f"错误: {e}")

总结

函数使用 def 定义，包含函数名、参数、函数体和返回值。
使用 *args 和 **kwargs 处理可变参数。
编写出色的函数需要：单一职责、有意义的命名、文档字符串、异常处理、类型提示等。
高级技巧如 lambda 函数、函数作为参数和装饰器可以进一步提升代码灵活性。

从.py文件中获取函数对象和参数的字典

在给定的Python脚本中，通过模块导入和反射机制，如何动态获取包含模型函数的模块中的函数及其默认参数，并构建一个字典以便后续使用？

解决方案

test.py

# test.py
import numpy as np
def return_inputs(*args):
 return args
# 前处理 要求输入为 X, y, **params 输出为 X_new, y_new
def mahalanobis(X, y,threshold=95):
 mahal_X = np.asarray(X)
 x_mu = mahal_X - np.mean(mahal_X, axis=0)
 cov = np.cov(mahal_X.T)
 inv_covmat = np.linalg.inv(cov)
 left_term = np.dot(x_mu, inv_covmat)
 mahal = np.dot(left_term, x_mu.T)
 d = mahal.diagonal()
 threshold = np.percentile(d, threshold)
 mahal_x = mahal_X[d < threshold]
 return mahal_x, y[d < threshold]

main.py


import test as AF # 导入包含模型函数的模块
import inspect
def getModelParamsFromAF():

 # 获取模块中的所有成员
 module_members = AF.__dict__.items()

 # 构建models字典
 models = {}
 for name, member in module_members:
 if callable(member): # 检查成员是否为函数
 # 使用inspect模块获取函数的参数信息
 params = inspect.signature(member).parameters
 default_params = {param: params[param].default for param in params if params[param].default != inspect.Parameter.empty}

 models[name] = (member, default_params)
 return models

print(getModelParamsFromAF())

总结 本问题涉及在Python脚本中通过模块导入和反射机制，动态获取包含模型函数的模块中的函数及其默认参数，并将其构建成一个字典。通过利用inspect模块获取函数参数信息，作者实现了一个函数getModelParamsFromAF()，该函数返回一个包含模型函数及其默认参数的字典。这种动态获取参数的方法可以方便后续使用，提高代码的灵活性和可维护性。最后，通过print语句输出获取到的模型函数及其默认参数，以便进行进一步的分析和使用。

Python 多进程

相关问题	地址
python使用进程池多进程时，如何打印错误信息	博客园

在python机器学习中，我想要进行自动调参，这需要比较大的运算能力，但是我发现cpu的性能总是不能跑满，原来是我用了多线程，python对于多线程的支持并不是很好可以看廖雪峰

python多线程为什么不能把多核CPU的性能吃满？ 因为Python的线程虽然是真正的线程，但解释器执行代码时，有一个GIL锁：Global Interpreter Lock，任何Python线程执行前，必须先获得GIL锁，然后，每执行100条字节码，解释器就自动释放GIL锁，让别的线程有机会执行。这个GIL全局锁实际上把所有线程的执行代码都给上了锁，所以，多线程在Python中只能交替执行，即使100个线程跑在100核CPU上，也只能用到1个核。

GIL是Python解释器设计的历史遗留问题，通常我们用的解释器是官方实现的CPython，要真正利用多核，除非重写一个不带GIL的解释器。

所以，在Python中，可以使用多线程，但不要指望能有效利用多核。如果一定要通过多线程利用多核，那只能通过C扩展来实现，不过这样就失去了Python简单易用的特点。

不过，也不用过于担心，Python虽然不能利用多线程实现多核任务，但可以通过多进程实现多核任务。多个Python进程有各自独立的GIL锁，互不影响。

目前python团队已经计划在3.13版本以后删除GIL锁CSDN链接

把多线程改成多线程 一个例子，根据自己核心数创建进程，然后把数据写入json文件中最后合并

from multiprocessing import Pool
import multiprocessing
import os, time, random
import json

def long_time_task(name):
 print('Run task %s (%s)...' % (name, os.getpid()))
 start = time.time()
 # 需要保存的数据
 data = {
 "name": str(name)
 }

 # 将数据写入JSON文件
 with open('data'+str(name)+'.json', 'w') as f:
 json.dump(data, f, indent=4)
 end = time.time()
 print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':
 print('Parent process %s.' % os.getpid())
 p = Pool()
 # 获取CPU的核心数
 cpu_cores = multiprocessing.cpu_count()
 print(cpu_cores)
 for i in range(cpu_cores):
 p.apply_async(long_time_task, args=(i,))
 print('Waiting for all subprocesses done...')
 p.close()
 p.join()


 files = []
 file_path = os.path.dirname(__file__)
 for file in os.listdir(file_path):
 if file.find('data') != -1:
 files.append(file)
 merged_data = []

 # 遍历每个文件，读取并解析 JSON 数据，然后添加到合并后的数据列表中
 for file_name in files:
 with open(file_name, 'r') as file:
 print(file_name)
 data = json.load(file)
 merged_data.append(data)

 # 将合并后的数据写入新的 JSON 文件
 with open('merged.json', 'w') as merged_file:
 json.dump(merged_data, merged_file, indent=4)

 print('JSON 文件已合并完成。')

 print('All subprocesses done.')

加进程锁

from multiprocessing import Process, Queue, Pool
import multiprocessing
import os, time, random

def write1(q, lock):
 lock.acquire() # 加上锁
 for value in ['A', 'B', 'C']:
 print('Put %s to queue...' % value)
 q.put(value)
 time.sleep(random.random())
 lock.release()

def write2(q, lock):
 lock.acquire() # 加上锁
 for value in ['D', 'E', 'F']:
 print('Put %s to queue...' % value)
 q.put(value)
 time.sleep(random.random())
 lock.release()

if __name__ == '__main__':
 q = Queue()
 manager = multiprocessing.Manager()
 lock = manager.Lock()
 pw1 = Process(target=write1, args=(q, lock))
 pw2 = Process(target=write2, args=(q, lock))
 # 启动子进程pw，写入:
 pw1.start()
 pw2.start()
 # pr.start()
 pw1.join()
 pw2.join()
 # pr.join()
 print('所有数据都写入并且读完')

总结

写过另外一个程序

collection_lock = Lock()
def collect_with_retry():
 if collection_lock.acquire(blocking=False):
 try:
 main()
 # break
 except Exception as e:
 self.logger.error(f"Collection failed: {str(e)}")
 finally:
 collection_lock.release()
 else:
 self.logger.warning("Failed to acquire lock for collection after multiple attempts")
if not hasattr(self, 'collection_thread') or not self.collection_thread.is_alive():
 self.collection_thread = Thread(target=collect_with_retry)
 self.collection_thread.daemon = True
 self.collection_thread.start()
else:
 self.logger.warning("Collection is already in progress")

文件所在文件夹外的另一文件导入函数或类

要在一个Python文件中从位于该文件所在文件夹外的另一个文件导入函数或类，你需要确保两个文件都在Python的搜索路径中。假设你有如下的目录结构：

project/
│
├── utils.py
│
└── subfolder/
 └── myfile.py

在这种情况下，utils.py 文件位于 subfolder 文件夹的外面。要从 myfile.py 中导入 utils.py 中的内容，你可以使用几种方法：

方法1: 修改系统路径在 myfile.py 中，你可以添加代码来修改系统路径，这样 Python 就可以找到 utils.py 文件。示例如下：

import sys
sys.path.insert(0, '../')

from utils import *

这里 sys.path.insert(0, '../') 将 utils.py 文件所在的上级目录添加到 Python 搜索路径的开始处，确保 Python 可以找到并导入 utils.py。

方法2: 使用相对导入如果你的项目结构适合使用包的结构（即目录中有 __init__.py 文件），你可以使用相对导入。首先，确保每个需要作为包处理的目录中都有一个空的 __init__.py 文件：

project/
│
├── utils.py
│
└── subfolder/
 ├── __init__.py
 └── myfile.py

然后，在 myfile.py 中使用相对导入：

from ..utils import *

注意，使用相对导入时，你的脚本必须作为包的一部分运行，不能直接作为主脚本运行，否则会出错。即，你需要这样的方式执行代码：

python -m myproject.submodule1.myscript

方法3:使用环境变量你可以设置 PYTHONPATH 环境变量，使其包括 utils.py 所在的目录。这样，当你运行 Python 时，它会自动将该目录添加到搜索路径中。

在 Unix-like 系统中，你可以在终端中这样设置：

export PYTHONPATH="/path/to/project:$PYTHONPATH"

在 Windows 系统中，你可以在命令提示符中这样设置：

set PYTHONPATH=C:\path\to\project;%PYTHONPATH%

这样设置之后，你可以在 myfile.py 中正常导入：

from utils import *

选择最适合你项目结构和需求的方法来导入模块。如果你正在开发一个较大的项目，考虑使用环境变量或确保你的项目可以作为包运行，这通常更为稳定和灵活。

OS库常用函数

获取当前工作目录：

import os
current_directory = os.getcwd()
print(current_directory)

改变工作目录：
```
os.chdir('/path/to/directory')
```

列出目录中的文件：

files = os.listdir('/path/to/directory')
print(files)

创建新目录：
```
os.mkdir('new_directory')
```
删除目录：
```
os.rmdir('new_directory')
```

检查文件或目录是否存在：

exists = os.path.exists('/path/to/file_or_directory')
print(exists)

获取文件大小：

file_size = os.path.getsize('/path/to/file')
print(file_size)

如何避免类重复创建实例

在 Python 中，为了避免一个类重复创建实例（例如，确保某个类在程序运行中只存在一个实例），可以使用 单例模式（Singleton Pattern）。单例模式是一种设计模式，保证一个类只有一个实例，并提供一个全局访问点。以下是实现单例模式的几种方法，以及如何避免类重复创建的说明：

方法 1：使用类方法和类属性通过在类中维护一个静态变量（类属性）来保存唯一实例，并在实例化时检查是否已存在实例。

class Singleton:
 _instance = None # 类属性，用于存储唯一实例

 def __new__(cls):
 if cls._instance is None:
 cls._instance = super().__new__(cls) # 创建新实例
 return cls._instance

# 测试
s1 = Singleton()
s2 = Singleton()
print(s1 is s2) # 输出: True，说明是同一个实例

说明：

__new__ 方法在对象创建时被调用，用于控制实例的创建。
_instance 保存类的唯一实例，如果已存在则直接返回，不重复创建。
is 运算符验证 s1 和 s2 是同一个对象。

方法 2：使用装饰器通过装饰器实现单例模式，适用于多个类需要单例逻辑的情况。

def singleton(cls):
 instances = {} # 存储类与实例的映射

 def get_instance(*args, **kwargs):
 if cls not in instances:
 instances[cls] = cls(*args, **kwargs)
 return instances[cls]

 return get_instance

@singleton
class Singleton:
 def __init__(self):
 print("实例化 Singleton")

# 测试
s1 = Singleton()
s2 = Singleton()
print(s1 is s2) # 输出: True

说明：

装饰器 singleton 维护一个字典 instances，存储类的唯一实例。
每次调用类时，检查是否已有实例，若无则创建，若有则返回现有实例。
@singleton 装饰器使类自动具备单例行为。

方法 3：使用元类（Metaclass）通过自定义元类来控制类的实例化过程，实现单例模式。

class SingletonMeta(type):
 _instances = {}

 def __call__(cls, *args, **kwargs):
 if cls not in cls._instances:
 cls._instances[cls] = super().__call__(*args, **kwargs)
 return cls._instances[cls]

class Singleton(metaclass=SingletonMeta):
 def __init__(self):
 print("实例化 Singleton")

# 测试
s1 = Singleton()
s2 = Singleton()
print(s1 is s2) # 输出: True

说明：

SingletonMeta 是一个元类，控制类的创建过程。
__call__ 方法在类被调用（实例化）时触发，检查是否已有实例。
通过 metaclass=SingletonMeta，类自动实现单例模式。

方法 4：模块级单例 Python 的模块本身就是单例的（模块只导入一次），因此可以在模块级别定义一个全局对象来模拟单例。

# singleton.py
class Singleton:
 def __init__(self):
 print("实例化 Singleton")

singleton_instance = Singleton()

# 使用时
from singleton import singleton_instance

说明：

Python 模块在程序运行期间只加载一次，因此 singleton_instance 是唯一的。
这种方式简单，但不够灵活，适合简单的全局对象需求。

注意事项

线程安全：上述方法在多线程环境中可能不安全，可能导致多个实例被创建。如果需要线程安全，可以使用锁机制。例如：

import threading

class Singleton:
 _instance = None
 _lock = threading.Lock()

 def __new__(cls):
 with cls._lock:
 if cls._instance is None:
 cls._instance = super().__new__(cls)
 return cls._instance

单例的适用场景：
- 需要全局唯一实例的场景，如配置管理器、日志记录器、数据库连接池等。
- 不适合所有类，滥用单例可能导致代码难以测试和维护。
替代方案：
- 如果不需要严格的单例，可以使用全局变量或工厂模式。
- 在某些情况下，依赖注入（Dependency Injection）可能比单例更适合。
测试单例：
- 使用 is 运算符检查两个实例是否相同。
- 确保单例的属性在所有实例中共享。

总结

推荐方法：方法 1（__new__）最简单直接，适合大多数场景。
灵活性：方法 2（装饰器）适合多个类复用单例逻辑。
高级需求：方法 3（元类）适合需要深度控制类行为的场景。
模块级单例：方法 4 适合简单的全局对象需求。
线程安全：在多线程环境中，添加锁机制以避免竞争条件。

装饰器函数 @….

在sklearn中看到红框中的函数，于是好奇是什么东西，查到python-函数前一行加@xxxx的含义

于是找到函数定义：def validate_params(parameter_constraints, *, prefer_skip_nested_validation):

但是，里面没有定义func参数 于是再看到下面，原来这个函数下面又定义了一个def decorator(func): 这样是可以的嘛？于是去尝试

def test_func():
 print(1111)
 def inner_func(func):
 func()
 return

@test_func()
def some_func():
 print("pp")
 return
some_func()

这也不行啊

进一步了解到，原来：它是通过 functools 重写了装饰器函数，你要这样写才行

import functools
def test_func():
 print(1111)
 ### 装饰器函数
 def decorator(func):
 @functools.wraps(func)
 def wrapper(*args, **kwargs):
 return func(*args, **kwargs)
 return wrapper
 return decorator

@test_func()
def some_func():
 print("pp")
 return

some_func()

下面是具体介绍

@validate_params 装饰器的运作原理

装饰器定义：

validate_params 是一个装饰器函数。它的作用是用于验证被装饰函数的参数类型是否符合预设的约束条件。

参数约束：

parameter_constraints 是一个字典，用于定义每个参数的允许类型。例如，可以指定某个参数可以是列表或 NumPy 数组。

内部装饰器：

decorator 是 validate_params 内部定义的装饰器函数。它接受被装饰的函数 func 作为参数。

参数绑定：

在 wrapper 函数中，使用 signature(func).bind(*args, **kwargs).arguments 将传入的参数与函数的签名进行绑定，生成一个包含所有参数及其值的字典 params。

参数验证：

对字典中的每个参数进行检查。使用 any() 函数来判断该参数的值是否符合定义的约束条件。如果不符合，则抛出一个自定义的异常 InvalidParameterError，并提供错误信息。

调用原函数：

如果所有参数都通过了验证，wrapper 函数就会调用原始的被装饰函数 func，并返回其结果。

@validate_params 装饰器的核心功能是自动检查函数参数的类型。这可以帮助开发者在调用函数之前发现潜在的错误，增强代码的健壮性和可维护性。通过这种方式，确保了函数在执行时获得正确类型的输入，从而减少了运行时错误的风险。我写了一个示例代码：

import functools
import numpy as np
from inspect import signature

class InvalidParameterError(ValueError):
 pass

def validate_params(parameter_constraints, *, prefer_skip_nested_validation):
 """装饰器用于验证函数和方法的参数类型和值。"""

 def decorator(func):
 setattr(func, "_parameter_constraints", parameter_constraints)

 @functools.wraps(func)
 def wrapper(*args, **kwargs):
 params = signature(func).bind(*args, **kwargs).arguments
 to_ignore = ["self", "cls"]
 params = {k: v for k, v in params.items() if k not in to_ignore}

 validate_parameter_constraints(parameter_constraints, params, caller_name=func.__qualname__)

 return func(*args, **kwargs)

 return wrapper

 return decorator

def validate_parameter_constraints(parameter_constraints, params, caller_name):
 for param, constraints in parameter_constraints.items():
 if param not in params:
 continue
 value = params[param]
 valid = False
 for constraint in constraints:
 # 检查是否为类型
 if isinstance(constraint, type):
 if isinstance(value, constraint):
 valid = True
 break
 # 检查是否为 None
 elif constraint is None and value is None:
 valid = True
 break

 if not valid:
 expected_types = ', '.join(c.__name__ if isinstance(c, type) else str(c) for c in constraints)
 raise InvalidParameterError(f"{caller_name}: '{param}' must be one of types: {expected_types}.")

@validate_params(
 {
 "y_true": [list, np.ndarray],
 "y_pred": [list, np.ndarray],
 "sample_weight": [list, np.ndarray, None],
 },
 prefer_skip_nested_validation=True,
)
def mean_squared_error(y_true, y_pred, *, sample_weight=None):
 """计算均方误差 (MSE)。"""

 if sample_weight is not None:
 sample_weight = np.array(sample_weight)

 y_true = np.array(y_true)
 y_pred = np.array(y_pred)

 if sample_weight is not None:
 return np.average((y_pred - y_true) ** 2, weights=sample_weight)
 else:
 return np.mean((y_pred - y_true) ** 2)

# 示例用法
y_true = [3, -0.5, 2, 7] # 真实值
y_pred = [2.5, 0.0, 2, 8] # 预测值
print(mean_squared_error(y_true, y_pred)) # 输出均方误差

结果

sklearn中源码


def validate_params(parameter_constraints, *, prefer_skip_nested_validation):
 """Decorator to validate types and values of functions and methods.

 Parameters
 ----------
 parameter_constraints : dict
 A dictionary `param_name: list of constraints`. See the docstring of
 `validate_parameter_constraints` for a description of the accepted constraints.

 Note that the *args and **kwargs parameters are not validated and must not be
 present in the parameter_constraints dictionary.

 prefer_skip_nested_validation : bool
 If True, the validation of parameters of inner estimators or functions
 called by the decorated function will be skipped.

 This is useful to avoid validating many times the parameters passed by the
 user from the public facing API. It's also useful to avoid validating
 parameters that we pass internally to inner functions that are guaranteed to
 be valid by the test suite.

 It should be set to True for most functions, except for those that receive
 non-validated objects as parameters or that are just wrappers around classes
 because they only perform a partial validation.

 Returns
 -------
 decorated_function : function or method
 The decorated function.
 """

 def decorator(func):
 # The dict of parameter constraints is set as an attribute of the function
 # to make it possible to dynamically introspect the constraints for
 # automatic testing.
 setattr(func, "_skl_parameter_constraints", parameter_constraints)

 @functools.wraps(func)
 def wrapper(*args, **kwargs):
 global_skip_validation = get_config()["skip_parameter_validation"]
 if global_skip_validation:
 return func(*args, **kwargs)

 func_sig = signature(func)

 # Map *args/**kwargs to the function signature
 params = func_sig.bind(*args, **kwargs)
 params.apply_defaults()

 # ignore self/cls and positional/keyword markers
 to_ignore = [
 p.name
 for p in func_sig.parameters.values()
 if p.kind in (p.VAR_POSITIONAL, p.VAR_KEYWORD)
 ]
 to_ignore += ["self", "cls"]
 params = {k: v for k, v in params.arguments.items() if k not in to_ignore}

 validate_parameter_constraints(
 parameter_constraints, params, caller_name=func.__qualname__
 )

 try:
 with config_context(
 skip_parameter_validation=(
 prefer_skip_nested_validation or global_skip_validation
 )
 ):
 return func(*args, **kwargs)
 except InvalidParameterError as e:
 # When the function is just a wrapper around an estimator, we allow
 # the function to delegate validation to the estimator, but we replace
 # the name of the estimator by the name of the function in the error
 # message to avoid confusion.
 msg = re.sub(
 r"parameter of \w+ must be",
 f"parameter of {func.__qualname__} must be",
 str(e),
 )
 raise InvalidParameterError(msg) from e

 return wrapper

 return decorator




@validate_params(
 {
 "y_true": ["array-like"],
 "y_pred": ["array-like"],
 "sample_weight": ["array-like", None],
 "multioutput": [StrOptions({"raw_values", "uniform_average"}), "array-like"],
 },
 prefer_skip_nested_validation=True,
)
def mean_absolute_error(
 y_true, y_pred, *, sample_weight=None, multioutput="uniform_average"
):
 """Mean absolute error regression loss.

 Read more in the :ref:`User Guide <mean_absolute_error>`.

 Parameters
 ----------
 y_true : array-like of shape (n_samples,) or (n_samples, n_outputs)
 Ground truth (correct) target values.

 y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs)
 Estimated target values.

 sample_weight : array-like of shape (n_samples,), default=None
 Sample weights.

 multioutput : {'raw_values', 'uniform_average'} or array-like of shape \
 (n_outputs,), default='uniform_average'
 Defines aggregating of multiple output values.
 Array-like value defines weights used to average errors.

 'raw_values' :
 Returns a full set of errors in case of multioutput input.

 'uniform_average' :
 Errors of all outputs are averaged with uniform weight.

 Returns
 -------
 loss : float or ndarray of floats
 If multioutput is 'raw_values', then mean absolute error is returned
 for each output separately.
 If multioutput is 'uniform_average' or an ndarray of weights, then the
 weighted average of all output errors is returned.

 MAE output is non-negative floating point. The best value is 0.0.

 Examples
 --------
 >>> from sklearn.metrics import mean_absolute_error
 >>> y_true = [3, -0.5, 2, 7]
 >>> y_pred = [2.5, 0.0, 2, 8]
 >>> mean_absolute_error(y_true, y_pred)
 0.5
 >>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
 >>> y_pred = [[0, 2], [-1, 2], [8, -5]]
 >>> mean_absolute_error(y_true, y_pred)
 0.75
 >>> mean_absolute_error(y_true, y_pred, multioutput='raw_values')
 array([0.5, 1. ])
 >>> mean_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7])
 0.85...
 """
 y_type, y_true, y_pred, multioutput = _check_reg_targets(
 y_true, y_pred, multioutput
 )
 check_consistent_length(y_true, y_pred, sample_weight)
 output_errors = np.average(np.abs(y_pred - y_true), weights=sample_weight, axis=0)
 if isinstance(multioutput, str):
 if multioutput == "raw_values":
 return output_errors
 elif multioutput == "uniform_average":
 # pass None as weights to np.average: uniform mean
 multioutput = None

 return np.average(output_errors, weights=multioutput)

from abc import ABC, abstractmethod 关于抽象基类

在 Python 中，from abc import ABC, abstractmethod 是用于实现抽象基类（Abstract Base Class, ABC）的导入语句。让我们逐步解析它的含义和作用：

模块 abc abc 是 Python 的标准库模块，全称是 Abstract Base Classes，用于定义抽象基类。抽象基类是一种不能直接实例化的类，通常用于定义一组子类必须实现的接口或方法。
ABC ABC 是 abc 模块中的一个类，任何继承自 ABC 的类都会被标记为抽象基类。抽象基类不能被直接实例化，必须通过子类继承并实现其抽象方法后才能使用。
abstractmethod abstractmethod 是 abc 模块中的一个装饰器，用于将方法标记为抽象方法。抽象方法是子类必须实现的方法，否则子类也会被视为抽象类，无法实例化。
代码示例 以下是一个使用 ABC 和 abstractmethod 的简单例子：

from abc import ABC, abstractmethod

# 定义一个抽象基类
class Animal(ABC):
 @abstractmethod
 def make_sound(self):
 """子类必须实现这个方法"""
 pass

# 定义一个具体子类
class Dog(Animal):
 def make_sound(self):
 return "Woof!"

# 定义另一个具体子类
class Cat(Animal):
 def make_sound(self):
 return "Meow!"

# 测试代码
dog = Dog()
print(dog.make_sound()) # 输出: Woof!

cat = Cat()
print(cat.make_sound()) # 输出: Meow!

# 试图实例化抽象基类会报错
# animal = Animal() # TypeError: Can't instantiate abstract class Animal with abstract methods make_sound

代码解析

Animal 类：通过继承 ABC，它成为一个抽象基类。
make_sound 方法：被 @abstractmethod 装饰，表示子类必须实现这个方法。
子类 Dog 和 Cat：它们继承了 Animal，并实现了 make_sound 方法，因此可以被实例化。
不能实例化 Animal：如果尝试直接创建 Animal 的实例，会抛出错误，因为它是一个抽象类，且包含未实现的抽象方法。

用途

接口定义：确保子类实现特定的方法，强制执行某种契约。
代码规范：提高代码的可维护性和可读性，明确子类的行为要求。
多态性：支持多态设计，允许不同的子类以自己的方式实现抽象方法。

注意事项

如果子类没有实现抽象基类中的所有抽象方法，实例化该子类会抛出 TypeError。
抽象基类可以包含普通方法（非抽象方法），这些方法可以有默认实现。
@abstractmethod 必须与 ABC 一起使用，否则不会强制要求子类实现。

总结 from abc import ABC, abstractmethod 是 Python 中用于定义抽象基类的工具。ABC 是一个基类，用于创建抽象类；abstractmethod 是一个装饰器，用于标记必须由子类实现的方法。这种机制在面向对象编程中非常有用，尤其是在需要定义统一接口或强制子类实现特定方法时。

函数名前不同下划线’_‘数量所代表的含义

在 Python 中，函数名前加下划线（_）通常是为了表示特定的命名约定或用途，主要与代码的可读性、访问控制和命名空间管理有关。以下是函数名前加单下划线（_）和双下划线（__）以及不加下划线的区别和含义：

不加下划线的函数（普通函数）

含义：这是最常见的函数命名方式，表示函数是公开的（public），可以被模块内外任意访问和调用。
用途：用于定义模块或类的公共接口，任何代码都可以直接调用这些函数。
示例：
```
def public_function():
 print("这是一个公开函数")
```
- 任何地方都可以调用 public_function()，没有任何访问限制。

单下划线开头的函数（_function）

含义：以单下划线 _ 开头的函数表示它是受保护的（protected）或内部使用的。这是 Python 的命名约定，提示开发者这个函数主要用于模块或类内部，不建议外部直接调用。
实际效果：并没有真正的访问限制，外部代码仍然可以访问和调用，只是约定上表示“这个函数是内部实现细节，最好不要直接使用”。
用途：
- 用于模块内部的辅助函数，提示用户不要直接调用。
- 在类中表示受保护的方法，建议子类或内部逻辑使用。

示例：

class MyClass:
 def _protected_method(self):
 print("这是一个受保护的方法")

obj = MyClass()
obj._protected_method() 可以调用，但不推荐

虽然可以调用 _protected_method，但开发者看到单下划线会知道这是内部方法，不建议直接使用。

双下划线开头的函数（__function）

含义：以双下划线 __ 开头的函数表示私有（private），用于实现 Python 的**名称改写（name mangling）**机制。这是 Python 中一种更强的封装方式，旨在防止外部代码直接访问这些方法。
实际效果：Python 会将 __function 的名称改写为 _ClassName__function，以避免子类或外部代码意外覆盖或调用。这种机制并不是完全禁止访问，而是增加了访问难度。
用途：
- 用于类的私有方法，确保方法不会被子类意外重写或被外部直接调用。
- 强调方法是类的内部实现细节。

示例：

class MyClass:
 def __private_method(self):
 print("这是一个私有方法")

obj = MyClass()
 obj.__private_method() 会报错：AttributeError
obj._MyClass__private_method() 可以这样访问，但不推荐

直接调用 __private_method 会失败，因为名称被改写为 _MyClass__private_method。
仍然可以通过改写后的名称访问，但这违背了封装的意图。

双下划线开头和结尾的函数（__function__）

含义：以双下划线开头和结尾的函数是 Python 的特殊方法（magic methods 或 dunder methods），用于定义类的特殊行为或内置功能。这些方法由 Python 解释器在特定场景下自动调用。
用途：
- 实现类的内置行为，例如 __init__（构造函数）、__str__（字符串表示）、__len__（长度）等。
- 这些方法是公开的，但通常由 Python 内部调用，而不是开发者直接调用。

示例：

class MyClass:
 def __init__(self, name):
 self.name = name

 def __str__(self):
 return f"MyClass with name: {self.name}"

obj = MyClass("Test")
print(obj) 自动调用 __str__，输出: MyClass with name: Test

单下划线作为函数名（_）

含义：单独使用 _ 作为函数名或变量名，通常用于表示临时或占位符，在代码中不打算实际使用。
用途：
- 在循环或解包中忽略不需要的值。
- 有时在模块中定义 _ 作为临时函数名（不常见）。

示例：

for _ in range(5): 忽略循环变量
 print("Hello")

总结对比

前缀	含义	访问限制	典型用途
`function`	公开函数	无限制	模块或类的公共接口
`_function`	受保护函数	约定限制（可访问）	模块或类内部的辅助方法
`__function`	私有函数	名称改写（难以直接访问）	类内部的私有实现
`__function__`	特殊方法	无限制（由 Python 自动调用）	定义类的内置行为
`_`	占位符	无限制	忽略变量或临时函数

注意事项

约定 vs. 强制：Python 的下划线命名是约定而非强制。单下划线是提示，开发者应尊重但可以绕过；双下划线通过名称改写提供更强的封装，但仍可通过改写后的名称访问。
代码风格：遵循 Python 的 PEP 8 命名规范，使用下划线来提高代码可读性和维护性。
文化习惯：在 Python 社区中，尊重下划线约定是良好编程习惯的体现，避免直接访问 _ 或 __ 开头的方法。

示例综合对比

class Example:
 def public_method(self):
 print("公开方法")

 def _protected_method(self):
 print("受保护方法")

 def __private_method(self):
 print("私有方法")

 def __init__(self):
 print("特殊方法：初始化")

obj = Example() 调用 __init__
obj.public_method() 正常调用
obj._protected_method() 可以调用，但不推荐
 obj.__private_method() 报错
obj._Example__private_method() 可以访问，但不推荐

通过这些命名约定，Python 提供了灵活的封装机制，同时保持了语言的简洁性和开放性。

函数中的*号和**号

在 Python 中，* 和 ** 是用于处理函数参数的特殊符号。它们分别表示不同的含义，主要用于处理可变数量的参数和解包操作。以下是详细的介绍：

1. **单星号* 的作用** * 主要用在以下两种场景：

(1) *定义可变位置参数（args） 在函数定义中，*args 用于接收任意数量的位置参数。这些参数会被打包成一个元组（tuple），供函数内部使用。

def my_function(*args):
 print(args) # args 是一个元组

my_function(1, 2, 3)
# 输出: (1, 2, 3)

*args 中的 args 只是一个约定俗成的名字，你可以使用其他名字，比如 *values。
这些参数是按位置传递的，调用时不需要指定参数名。

(2) 解包可迭代对象 在函数调用时，* 可以用来解包一个可迭代对象（如列表、元组等），将其元素作为独立的位置参数传递给函数。

def add(a, b, c):
 return a + b + c

numbers = [1, 2, 3]
result = add(*numbers) # 等价于 add(1, 2, 3)
print(result)
# 输出: 6

2. **双星号** 的作用** ** 主要用在以下两种场景：

(1) **定义可变关键字参数（kwargs） 在函数定义中，**kwargs 用于接收任意数量的关键字参数。这些参数会被打包成一个字典（dictionary），供函数内部使用。

def my_function(**kwargs):
 print(kwargs) # kwargs 是一个字典

my_function(a=1, b=2, c=3)
# 输出: {'a': 1, 'b': 2, 'c': 3}

**kwargs 中的 kwargs 同样只是一个约定俗成的名字，你可以使用其他名字，比如 **options。
这些参数是通过键值对传递的，调用时需要指定参数名。

(2) 解包字典 在函数调用时，** 可以用来解包一个字典，将其键值对作为独立的关键字参数传递给函数。

def greet(name, age):
 print(f"Hello {name}, you are {age} years old.")

info = {"name": "Alice", "age": 25}
greet(**info) # 等价于 greet(name="Alice", age=25)
# 输出: Hello Alice, you are 25 years old.

3. ***和** 的结合使用** 在一个函数定义中，可以同时使用 *args 和 **kwargs，分别处理位置参数和关键字参数。

def my_function(*args, **kwargs):
 print("Positional arguments:", args)
 print("Keyword arguments:", kwargs)

my_function(1, 2, 3, a=4, b=5)
# 输出:
# Positional arguments: (1, 2, 3)
# Keyword arguments: {'a': 4, 'b': 5}

4. **注意事项**

顺序规则：在函数定义中，参数的顺序必须是：
1. 普通参数
2. *args
3. 带默认值的参数
4. **kwargs
示例：
```
def example(a, b, *args, c=10, **kwargs):
 pass
```
强制关键字参数：从 Python 3 开始，可以通过在 * 后面添加参数来强制要求某些参数必须通过关键字传递。例如：
```
def example(a, *, b):
 print(a, b)

example(1, b=2) # 正确
example(1, 2) # 错误，TypeError
```

总结

* 用于处理可变数量的位置参数或解包可迭代对象。
** 用于处理可变数量的关键字参数或解包字典。
它们可以单独使用，也可以结合使用，提供了灵活的函数参数处理方式。

如果你有更多具体问题，欢迎继续提问！

Pydantic 的Filed函数

Pydantic 的Filed函数，用于在数据模型中定义字段的额外信息、验证和约束。它可以用于设置字段的默认值、限制字段的取值范围、添加字段描述等。以下是一些常用的 Field 用法：

设置默认值

from pydantic import BaseModel, Field

class MyClass(BaseModel):
 my_field: str = Field(default="Hello, World!")

添加描述：

from pydantic import BaseModel, Field

class MyClass(BaseModel):
 my_field: str = Field(..., description="This is a sample field.")

在这个例子中，为 my_field 添加了描述 “This is a sample field.”。

添加验证约束：

from pydantic import BaseModel, Field

class MyClass(BaseModel):
 my_field: int = Field(..., gt=0, lt=10)

在这个例子中，my_field 的值必须大于 0 且小于 10，否则会引发验证错误。

使用自定义验证器：

from pydantic import BaseModel, Field, validator

class MyClass(BaseModel):
 my_field: str = Field(...)

 @validator("my_field")
 def check_length(cls, value):
 if len(value) < 5:
 raise ValueError("The length of my_field must be at least 5 characters.")
 return value

在这个例子中，添加了一个自定义验证器 check_length，用于检查 my_field 的长度。如果长度小于 5 个字符，将引发一个值错误。

这些只是 Field 的一些基本用法。使用 Pydantic，您可以根据需要添加更多自定义验证和约束，以确保数据模型中的字段符合预期。

python 中的`async` 和 `await` （异步编程）

异步操作（Asynchronous Operation）是指一种非阻塞的操作方式，允许程序在等待某些耗时任务（如 I/O 操作、网络请求等）完成的同时，继续执行其他任务。

在 Python 中，async 和 await 是用于处理异步编程的关键字。它们允许你编写非阻塞的代码，特别适用于 I/O 密集型任务（如网络请求、文件读写等），以提高程序的并发性能。

1. async的作用 async 关键字用于定义一个异步函数（也称为协程）。异步函数与普通函数不同，它不会立即执行，而是返回一个协程对象，该对象可以在事件循环中被调度执行。示例：

import asyncio

async def my_coroutine():
 print("Hello")
 await asyncio.sleep(1) # 模拟异步操作
 print("World")

# 调用异步函数并不会直接执行它，而是返回一个协程对象
coro = my_coroutine()

# 需要通过事件循环来运行协程
asyncio.run(coro)

在这个例子中，my_coroutine 是一个异步函数，使用 async 定义。调用 my_coroutine() 并不会立即执行函数体中的代码，而是返回一个协程对象。要真正执行这个协程，你需要使用 asyncio.run() 或者将其放入事件循环中。

2. await 的作用 await 关键字用于等待一个异步操作完成。它只能在 async 函数内部使用，并且后面必须跟一个可等待对象（如协程、任务、Future 等）。当遇到 await 时，当前协程会暂停执行，直到等待的操作完成。

示例：

import asyncio

async def fetch_data():
 print("开始获取数据...")
 await asyncio.sleep(2) # 模拟耗时的 I/O 操作
 print("数据获取完成")
 return {"data": "some data"}

async def main():
 result = await fetch_data() # 等待 fetch_data 协程完成
 print(f"结果: {result}")

asyncio.run(main())

在这个例子中，await fetch_data() 会让 main 协程暂停，直到 fetch_data 协程完成并返回结果。

3. 其他类似的参数或概念 除了 async 和 await，Python 的异步编程还涉及以下几个重要概念和工具：

asyncio 模块 asyncio 是 Python 标准库中的一个模块，提供了实现异步编程所需的基础设施，包括事件循环、任务调度等。常见的功能包括：

asyncio.run()：运行顶层的协程。
asyncio.create_task()：创建一个任务，用于并发执行多个协程。
asyncio.gather()：并发运行多个协程并收集结果。
asyncio.sleep()：模拟异步延迟。

示例：

import asyncio

async def task1():
 print("Task 1 开始")
 await asyncio.sleep(1)
 print("Task 1 完成")

async def task2():
 print("Task 2 开始")
 await asyncio.sleep(2)
 print("Task 2 完成")

async def main():
 # 并发执行两个任务
 await asyncio.gather(task1(), task2())

asyncio.run(main())

async for 和 async with

async for：用于异步迭代器，适用于需要异步生成数据的场景。
async with：用于异步上下文管理器，适用于需要异步资源管理的场景。

示例：async for

import asyncio

class AsyncIterable:
 def __aiter__(self):
 self.data = [1, 2, 3]
 return self

 async def __anext__(self):
 if not self.data:
 raise StopAsyncIteration
 await asyncio.sleep(1) # 模拟异步操作
 return self.data.pop(0)

async def main():
 async for item in AsyncIterable():
 print(item)

asyncio.run(main())

示例：async with

import asyncio

class AsyncContextManager:
 async def __aenter__(self):
 print("进入上下文")
 await asyncio.sleep(1)
 return self

 async def __aexit__(self, exc_type, exc_val, exc_tb):
 print("退出上下文")
 await asyncio.sleep(1)

async def main():
 async with AsyncContextManager() as manager:
 print("在上下文中执行")

asyncio.run(main())

concurrent.futures 模块 虽然不属于 async/await 的范畴，但 concurrent.futures 提供了另一种实现并发的方式，特别是通过线程池或进程池执行任务。

示例：

from concurrent.futures import ThreadPoolExecutor
import time

def blocking_task(seconds):
 print(f"开始阻塞任务 {seconds} 秒")
 time.sleep(seconds)
 print(f"阻塞任务完成")
 return seconds

def main():
 with ThreadPoolExecutor() as executor:
 future = executor.submit(blocking_task, 2)
 print("主线程继续执行其他任务")
 result = future.result() # 阻塞等待结果
 print(f"结果: {result}")

main()

总结

async 用于定义异步函数，返回协程对象。
await 用于等待异步操作完成，只能在 async 函数中使用。
其他相关概念包括 asyncio 模块、async for、async with 等，它们共同构成了 Python 异步编程的核心工具。

Python项目生成requirements.txt文件

1.使用pipreqs生成requirement.txt

```python
pip install pipreqs
pipreqs . # .表示当前路径
```
遇到问题
**1. 遇到编码错误问题**
> ![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/9b7c8a250113823a277df162dc9e1b20.png)
> 解决方法
> ```python pipreqs --encoding=iso-8859-1 ```
**2. 遇到'pipreqs' is not recognized as an internal or external command,operable program or batch file.**
> 使用以下命令：
> `python -m pipreqs.pipreqs . --encoding=utf8 --force`

pipreqs –help

pipreqs - Generate pip requirements.txt file based on imports

Usage:
 pipreqs [options] [<path>]

Arguments:
 <path> The path to the directory containing the application
 files for which a requirements file should be
 generated (defaults to the current working
 directory).

Options:
 --use-local Use ONLY local package info instead of querying PyPI.
 --pypi-server <url> Use custom PyPi server.
 --proxy <url> Use Proxy, parameter will be passed to requests
 library. You can also just set the environments
 parameter in your terminal:
 $ export HTTP_PROXY="http://10.10.1.10:3128"
 $ export HTTPS_PROXY="https://10.10.1.10:1080"
 --debug Print debug information
 --ignore <dirs>... Ignore extra directories, each separated by a comma
 --no-follow-links Do not follow symbolic links in the project
 --encoding <charset> Use encoding parameter for file open
 --savepath <file> Save the list of requirements in the given file
 --print Output the list of requirements in the standard
 output
 --force Overwrite existing requirements.txt
 --diff <file> Compare modules in requirements.txt to project
 imports
 --clean <file> Clean up requirements.txt by removing modules
 that are not imported in project
 --mode <scheme> Enables dynamic versioning with <compat>,
 <gt> or <non-pin> schemes.
 <compat> | e.g. Flask~=1.1.2
 <gt> | e.g. Flask>=1.1.2
 <no-pin> | e.g. Flask
 --scan-notebooks Look for imports in jupyter notebook files.

遇到的问题

导入路径问题（原本main函数调用它，现在直接运行该文件，导包路径变化）

问题描述 在运行 Python 文件时，可能会遇到以下错误：

ModuleNotFoundError: No module named 'utils'

原因：

Python 的模块导入机制依赖于当前工作目录和 sys.path 中的路径。
当直接运行某个文件时，Python 会将该文件所在目录添加到 sys.path，而不是项目的根目录，导致无法正确导入其他模块。

解决方法 (一般再临时调试时候会出现，我推荐使用方法三）

方法 1：修改 sys.path 在代码中手动将项目的根目录添加到 sys.path：

import sys
import os

current_dir = os.path.dirname(os.path.abspath(__file__))
project_root = os.path.abspath(os.path.join(current_dir, '..'))

if project_root not in sys.path:
 sys.path.append(project_root)

from utils.subgraph_extraction import *

优点：简单直接，适合快速调试。
缺点：不够优雅，可能不适合复杂项目。

方法 2：使用相对导入如果项目是一个包（包含 __init__.py），可以使用相对导入：

from ..utils.subgraph_extraction import *

然后从项目的根目录运行脚本：

python -m utils.Core_functions

优点：符合 Python 包管理规范，适合大型项目。
缺点：不能直接运行单个文件，需要调整运行方式。

方法 3：设置环境变量 PYTHONPATH 在运行脚本前，设置环境变量 PYTHONPATH 指向项目的根目录。比如这样，我原本再根目录调用这个文件，没有问题，但是现在我想要进入这个文件里面运行它就会报错：这样再运行就没问题了

Linux/MacOS：

export PYTHONPATH=/path/to/your/project
python utils/Core_functions.py

Windows（命令提示符）：

set PYTHONPATH=C:\path\to\your\project
python utils\Core_functions.py

Windows（PowerShell）：

$env:PYTHONPATH = "C:\path\to\your\project"
python utils\Core_functions.py

优点：无需修改代码，适合团队协作。
缺点：需要每次运行前设置环境变量。

方法 4：使用 IDE 配置工作目录通过 IDE 配置运行时的工作目录为项目的根目录。

PyCharm：
1. 打开运行配置（Run/Debug Configurations）。
2. 设置 Working Directory 为项目的根目录。

VSCode：在 .vscode/launch.json 中添加以下配置：

{
 "version": "0.2.0",
 "configurations": [
 {
 "name": "Run Core_functions",
 "type": "python",
 "request": "launch",
 "program": "utils/Core_functions.py",
 "cwd": "${workspaceFolder}"
 }
 ]
}

优点：适合开发环境，无需修改代码。
缺点：仅适用于特定 IDE。

方法 5：重构项目结构将所有模块组织为一个包，并通过入口脚本（如 main.py）统一调用。例如：

project/
├── main.py
├── utils/
│ ├── __init__.py
│ ├── Core_functions.py
│ └── subgraph_extraction.py

在 main.py 中：

from utils.Core_functions import some_function

if __name__ == "__main__":
 some_function()

然后始终通过 main.py 运行项目：

python main.py

优点：规范项目结构，避免路径问题。
缺点：需要对项目进行一定的重构。

总结

临时调试：推荐 方法 1 或 方法 3。
长期维护：推荐 方法 2 或 方法 5。
IDE 开发：推荐 方法 4。

根据具体需求选择合适的方法即可！

包与工程化 on 扎塔-Zata

python-lru_cache 缓存装饰器

Python lru_cache 缓存装饰器详解

1. 它解决了什么问题

2. 基本用法

3. 入参必须是可哈希的

4. 自带的辅助能力

5. maxsize 和 typed 怎么选

6. 实战例子：缓存配置文件解析

7. 三个常见陷阱

7.1 返回的是同一个对象，不是拷贝

7.2 外部状态变了，缓存不会感知

7.3 测试之间缓存会泄漏

8. lru_cache vs functools.cache（3.9+）

9. 在类的方法上慎用

10. 一图小结

python-将py文件编译为pyc文件并运行

py编译为pyc(为了代码加密)

问题提醒

1. 版本号问题：编译版本和runtime版本不一致会导致报错

打包过程

1. 新建compile_py.py文件并填入代码

2. 不编译py外文件，手动修改

python-相对导入错误attempted relative import with no known parent package

教程：解决 Python 相对导入错误 - “attempted relative import with no known parent package”

背景

问题原因

前置条件

解决方案

方法 1：以模块方式运行 (推荐)

步骤：

为什么有效？

方法 2：调整 PYTHONPATH

步骤：

注意：

方法 3：改为绝对导入

步骤：

优点与缺点：

方法 4：检查文件和结构

推荐方案

测试与验证

总结

python-在项目中应该如何定义文件路径

如何在python中定义文件路径

1. 理解相对路径和绝对路径

2. SQLite 数据库路径的定义方法

Python 示例

3. 最佳实践

a. 将路径定义为配置

b. 检查文件是否存在

c. 考虑打包或部署

d. 数据库初始化

4. 注意事项

5. 总结

python中将函数设置为定时任务

方案1：使用Python的schedule库

方案2：使用APScheduler库

方案3：使用系统级定时任务

Linux/Mac上使用cron

Windows上使用任务计划程序

方案4：使用Celery（对于大型应用）

实现建议

python-logging模块添加日志

基本概念

1. 使用 Python 的 logging 模块

2. 基本实现步骤

(1) 创建一个日志配置模块

(2) 在其他文件中使用日志

(3) 主程序入口

3. 高级配置（可选）

(1) 使用配置文件

(2) 日志按时间分割

(3) 避免重复日志

4. 注意事项

5. 总结

日志级别划分

各日志级别的使用场景

日志级别的工作机制

示例代码

如何选择日志级别

Python `lru_cache` 缓存装饰器详解

5. `maxsize` 和 `typed` 怎么选

8. `lru_cache` vs `functools.cache`（3.9+）

1. 使用 Python 的 `logging` 模块

从.py文件中获取函数对象和参数的字典

python 中的`async` 和 `await` （异步编程）