Python使用tempfile安全、优雅地处理临时文件与临时目录_Python

在日常 python 开发里，很多人都会写出这样的代码：

with open("/tmp/data.txt", "w") as f:
    f.write("hello")

看起来没什么问题，甚至还挺顺手。
但只要程序稍微复杂一点，这种“手搓临时文件”的方式很快就会暴露出一堆隐患：文件名冲突、权限问题、清理不彻底、跨平台行为不一致、并发下踩坑……

这时候，tempfile 就不是“可有可无的小工具”，而是一个非常值得认真掌握的标准库模块。

这篇文章不打算停留在“会用”层面，而是带你把 tempfile 真正吃透：
从核心 api、底层行为、跨平台差异，到生产环境里的常见误区与最佳实践，一次讲明白。

一、为什么你真的需要tempfile

临时文件的典型使用场景非常多：

处理上传文件后，先落盘再解析
下载远程内容，做中间缓存
大文件处理中，避免一次性全部驻留内存
调用第三方命令行工具时，生成中间输入/输出文件
测试代码时，隔离运行环境
数据转换、压缩、解压、音视频处理时保存中间结果

很多人第一次写临时文件，都是直接拼路径：

import os
import time

filename = f"/tmp/{int(time.time())}.txt"
with open(filename, "w") as f:
    f.write("temporary data")

这种写法的问题非常明显：

1. 文件名可能冲突

如果多个进程或线程同时运行，时间戳甚至 uuid 的方案也未必绝对安全。

2. 容易留下垃圾文件

程序异常退出、逻辑分支遗漏，都可能导致临时文件没被清理。

3. 有安全风险

如果文件名可预测，恶意用户可能利用符号链接、抢占文件名等方式制造安全问题。

4. 跨平台行为复杂

linux 上能工作的代码，到了 windows 可能因为文件占用机制直接翻车。

而 tempfile 的价值就在这里：

✅ 自动生成安全的临时文件名
✅ 尽量减少竞争条件
✅ 提供自动清理机制
✅ 官方标准库，跨平台兼容性更可靠

一句话总结：

凡是“只打算短暂存在”的文件或目录，都应该优先考虑 tempfile。

二、tempfile到底是什么

tempfile 是 python 标准库中专门用来创建临时文件和临时目录的模块。

它主要提供两类能力：

类别	典型 api	用途
高层接口	`temporaryfile()`、`namedtemporaryfile()`、`temporarydirectory()`、`spooledtemporaryfile()`	绝大多数业务开发直接用
低层接口	`mkstemp()`、`mkdtemp()`	需要更细粒度控制时使用

如果你刚接触这个模块，可以先记住下面这张“路线图”：

只想要一个临时文件对象：temporaryfile
想要“有文件名”的临时文件：namedtemporaryfile
想要临时目录：temporarydirectory
小数据放内存、大数据自动落盘：spooledtemporaryfile
想自己控制文件描述符、权限、清理逻辑：mkstemp / mkdtemp

三、最常用的 4 个核心 api

1.tempfile.temporaryfile()

这是最基础的临时文件接口。

import tempfile

with tempfile.temporaryfile(mode="w+t", encoding="utf-8") as f:
    f.write("hello tempfile")
    f.seek(0)
    print(f.read())

输出：

hello tempfile

它的特点

返回的是一个文件对象
文件通常没有稳定可见的文件名
关闭后自动删除
很适合“只在当前进程内部使用”的场景

参数里最重要的几个

tempfile.temporaryfile(mode='w+b', buffering=-1, encoding=none, newline=none, suffix=none, prefix=none, dir=none)

常用关注点：

mode：文件打开模式，默认是二进制读写 w+b
encoding：文本模式时指定编码
suffix：文件后缀，比如 .txt
prefix：文件名前缀
dir：指定临时文件创建目录

一个常见细节：默认是二进制模式

很多人第一次写会这样：

with tempfile.temporaryfile() as f:
    f.write("abc")

这会报错，因为默认是二进制模式，写字符串不行。

正确写法要么写字节：

with tempfile.temporaryfile() as f:
    f.write(b"abc")

要么切成文本模式：

with tempfile.temporaryfile(mode="w+", encoding="utf-8") as f:
    f.write("abc")

适合什么场景

📌 临时缓存
📌 中间计算结果
📌 不需要暴露路径给外部程序
📌 希望作用域结束自动清理

2.tempfile.namedtemporaryfile()

如果说 temporaryfile() 是“匿名临时文件”，那 namedtemporaryfile() 就是“带名字的临时文件”。

import tempfile

with tempfile.namedtemporaryfile(mode="w+", encoding="utf-8") as f:
    print("文件路径：", f.name)
    f.write("hello")
    f.seek(0)
    print(f.read())

最大区别：它有name

这意味着你可以把这个文件路径传给别的函数、库、甚至外部命令行程序。

例如：

import tempfile
import pathlib

with tempfile.namedtemporaryfile(mode="w+", suffix=".txt", encoding="utf-8") as f:
    path = pathlib.path(f.name)
    f.write("temporary content")
    f.flush()
    print(path.read_text(encoding="utf-8"))

为什么要flush()

这是非常实战的一个点。

写入文件后，数据可能还在缓冲区里，没有立即刷到磁盘。
如果你要让别的代码通过路径去读这个文件，通常要先：

f.flush()

有时还会进一步加上：

import os
os.fsync(f.fileno())

尤其在你要调用外部程序、或者对“立刻落盘”要求很高的场景里，这一点很重要。

namedtemporaryfile()最容易踩的坑：windows

很多文章讲到这里一笔带过，但实际上这是最常见的线上/本地开发问题之一。

看下面这段代码：

import tempfile

with tempfile.namedtemporaryfile(mode="w+", encoding="utf-8") as f:
    print(f.name)
    with open(f.name, "r", encoding="utf-8") as another:
        print(another.read())

这段代码在 linux/macos 上大概率没问题，
但在 windows 上，很可能直接失败，因为文件仍被当前进程以特定方式占用，导致不能再次打开。

怎么解决

最常见方案是这样：

import tempfile

with tempfile.namedtemporaryfile(
    mode="w",
    encoding="utf-8",
    delete=false
) as f:
    temp_name = f.name
    f.write("hello from tempfile")

try:
    with open(temp_name, "r", encoding="utf-8") as reader:
        print(reader.read())
finally:
    import os
    os.unlink(temp_name)

这段代码的核心思路

创建一个“有名字”的临时文件
设置 delete=false，避免文件一关闭就被删除
关闭文件后，再以普通方式重新打开
最后手动删除

这是一种非常经典、非常可靠的跨平台写法。

delete=false什么时候用

适合这些情况：

你需要把路径传给其他进程
你需要关闭当前文件后再重新打开
你在 windows 上做兼容
你要保留临时文件方便排查问题

但请记住：

只要你用了 delete=false，清理责任就从 tempfile 转移到了你自己身上。

3.tempfile.temporarydirectory()

处理临时文件时，很多人会忘了：
真正复杂的业务里，往往不是一个临时文件，而是一整个临时工作目录。

比如：

解压 zip 到某个目录
批量生成多个中间文件
克隆仓库到临时目录里分析
图像处理流水线输出多张中间图
单元测试中构造一套临时目录结构

这时候，temporarydirectory() 就特别顺手。

import tempfile
from pathlib import path

with tempfile.temporarydirectory() as temp_dir:
    temp_path = path(temp_dir)
    file1 = temp_path / "a.txt"
    file2 = temp_path / "b.txt"

    file1.write_text("a", encoding="utf-8")
    file2.write_text("b", encoding="utf-8")

    print(list(temp_path.iterdir()))

退出 with 后，整个目录会被自动删除。

这个 api 的优势非常明显

✅ 适合组织多个中间文件
✅ 清理的是整个目录，不用一个个删
✅ 和 pathlib.path 配合非常舒服

实战建议

如果你的逻辑中会创建多个临时文件，优先用临时目录来包裹，而不是散落一堆临时文件。

原因很简单：

结构更清晰
清理更彻底
调试时更方便
出错时更容易整体保留现场

例如：

import tempfile
from pathlib import path

def process_files():
    with tempfile.temporarydirectory(prefix="myjob_") as temp_dir:
        temp_dir = path(temp_dir)

        raw_file = temp_dir / "raw.json"
        cleaned_file = temp_dir / "cleaned.json"
        result_file = temp_dir / "result.txt"

        raw_file.write_text('{"name": "python"}', encoding="utf-8")
        cleaned_file.write_text('{"name":"python"}', encoding="utf-8")
        result_file.write_text("done", encoding="utf-8")

        return result_file.read_text(encoding="utf-8")

4.tempfile.spooledtemporaryfile()

这个类很有意思，也很实用，但很多人完全没用过。

它的设计思想是：

数据量小时放在内存里，超过阈值后再自动写入磁盘。

import tempfile

with tempfile.spooledtemporaryfile(max_size=1024, mode="w+t", encoding="utf-8") as f:
    f.write("small content")
    f.seek(0)
    print(f.read())

它有什么价值

这类对象非常适合处理“大小不确定”的数据流：

小文件直接在内存中处理，速度快
大文件自动溢出到磁盘，避免内存爆掉

典型使用场景

web 上传文件缓冲
导出报表时先写入缓存
中间数据量不确定的场景
想兼顾性能和内存安全

重点参数：max_size

tempfile.spooledtemporaryfile(max_size=1024 * 1024)

意思是：
在数据量不超过 1mb 时，先不落盘；
超过后，自动切换到底层真实临时文件。

手动触发落盘：rollover()

有时候你希望即使还没达到阈值，也立刻切换到磁盘文件：

import tempfile

with tempfile.spooledtemporaryfile(max_size=1024, mode="w+t", encoding="utf-8") as f:
    f.write("hello")
    f.rollover()   # 强制从内存切换到底层文件

这在调试或者与某些需要真实文件对象的库对接时很有帮助。

四、底层接口：mkstemp()和mkdtemp()

如果你需要更底层的控制，可以用这两个函数。

1.tempfile.mkstemp()

import os
import tempfile

fd, path = tempfile.mkstemp(suffix=".log")

try:
    with os.fdopen(fd, "w", encoding="utf-8") as f:
        f.write("log content")
    print(path)
finally:
    os.unlink(path)

返回值是什么

fd：底层文件描述符
path：文件路径

为什么说它更底层

因为它只是帮你安全地创建文件，
但不会像高层接口那样帮你包装好上下文管理和自动删除逻辑。

你需要自己做这些事。

它适合什么场景

你需要文件描述符级别的控制
你想精确管理打开方式
你要和较底层系统调用打交道
你不想依赖高级文件对象行为

2.tempfile.mkdtemp()

import shutil
import tempfile
from pathlib import path

temp_dir = tempfile.mkdtemp(prefix="demo_")
try:
    path = path(temp_dir)
    (path / "example.txt").write_text("hello", encoding="utf-8")
    print(path)
finally:
    shutil.rmtree(temp_dir)

注意点

mkdtemp() 创建目录后，不会自动清理。
你必须自己负责删除。

五、tempfile的常用参数详解

很多人平时只会写：

tempfile.namedtemporaryfile()

但实际工作里，下面这些参数非常有用。

1.suffix

指定后缀名。

tempfile.namedtemporaryfile(suffix=".csv")

这在很多第三方工具里非常重要。
因为有些程序会根据后缀判断文件类型。

例如：

.json
.csv
.png
.mp4

不要小看这个参数，很多“为什么工具读不出来”的问题，最后都卡在后缀名上。

2.prefix

指定前缀名。

tempfile.namedtemporaryfile(prefix="report_")

这在调试时很有帮助，你更容易从一堆临时文件里识别哪个是自己生成的。

3.dir

指定临时目录位置。

tempfile.namedtemporaryfile(dir="/custom/tmp")

使用场景包括：

默认临时目录空间不足
想把临时文件放到 ssd 提升性能
容器环境里指定挂载目录
合规要求：中间文件必须落在特定路径

4.mode

决定是文本还是二进制。

模式	含义
`w+b`	二进制读写，默认
`w+`	文本读写
`wb`	二进制只写
`w`	文本只写

经验建议

图片、压缩包、excel、pdf、音视频：用二进制模式
json、txt、csv（简单文本写入）：用文本模式
不确定时，优先确认你写入的是 str 还是 bytes

六、临时文件到底创建在哪里

很多人会有个疑问：

tempfile 到底把文件放哪儿了？

你可以这样查看：

import tempfile

print(tempfile.gettempdir())

在不同系统上，常见结果如下：

系统	可能的默认临时目录
linux	`/tmp`
macos	`/var/folders/...`
windows	`c:\\users\\用户名\\appdata\\local\\temp`

也可以查看候选目录

import tempfile
print(tempfile.gettempprefix())

另外，tempfile 会参考一些环境变量，比如：

tmpdir
temp
tmp

这意味着在容器、ci、云函数或某些部署环境里，临时目录位置可能和平时本地开发不一样。

生产环境建议

🔍 不要假设临时目录一定是 /tmp
🔍 不要假设临时目录空间一定够大
🔍 涉及大文件时，最好显式指定 dir

七、实战场景一：处理上传文件

假设你在写一个 web 服务，用户会上传一个 csv 文件，你需要先落盘，再交给 pandas 处理。

import tempfile
import pandas as pd

def handle_uploaded_file(file_obj):
    with tempfile.namedtemporaryfile(suffix=".csv", delete=false) as temp_file:
        temp_file.write(file_obj.read())
        temp_path = temp_file.name

    try:
        df = pd.read_csv(temp_path)
        return df.head().to_dict()
    finally:
        import os
        os.unlink(temp_path)

为什么这里不用temporaryfile()

因为很多库更适合直接接受路径而不是一个已经打开的文件对象。
而 namedtemporaryfile() 正好能提供路径。

为什么delete=false

因为在某些平台上，如果文件一直处于打开状态，再交给别的库去打开可能出问题。
先关闭，再读，是更稳妥的方式。

八、实战场景二：调用外部命令

这是 tempfile 非常典型的使用方式。

比如你要调用 ffmpeg、wkhtmltopdf、libreoffice、pandoc 这类外部工具。

import os
import subprocess
import tempfile

with tempfile.namedtemporaryfile(suffix=".txt", mode="w", encoding="utf-8", delete=false) as input_file:
    input_file.write("hello subprocess")
    input_path = input_file.name

try:
    result = subprocess.run(
        ["cat", input_path],
        capture_output=true,
        text=true,
        check=true
    )
    print(result.stdout)
finally:
    os.unlink(input_path)

经验结论

与外部程序交互时：

优先用 namedtemporaryfile
经常需要 delete=false
写完后确保 flush() 或关闭文件
最后务必清理

这类代码在 linux 上也许“随便写都能跑”，
但想要真正跨平台、可维护，还是得按规矩来。

九、实战场景三：单元测试隔离环境

测试代码时，最烦的事情之一就是“跑完留下脏文件”。

这时候 temporarydirectory() 非常适合。

import tempfile
from pathlib import path

def generate_report(output_dir):
    output_path = path(output_dir) / "report.txt"
    output_path.write_text("report content", encoding="utf-8")
    return output_path

def test_generate_report():
    with tempfile.temporarydirectory() as temp_dir:
        report_path = generate_report(temp_dir)
        assert report_path.exists()
        assert report_path.read_text(encoding="utf-8") == "report content"

这样写的好处

✅ 测试之间互不干扰
✅ 不污染项目目录
✅ 失败后容易定位问题
✅ 非常适合 pytest / unittest

十、实战场景四：大文件缓存与内存控制

如果你处理的数据大小不固定，spooledtemporaryfile() 很值得考虑。

import tempfile

def process_stream(chunks):
    with tempfile.spooledtemporaryfile(max_size=1024 * 1024, mode="w+b") as f:
        for chunk in chunks:
            f.write(chunk)

        f.seek(0)
        return f.read(100)

这个设计的妙处在于：

小数据走内存，快
大数据自动切盘，稳

对于上传、导出、数据转换这类业务，这个思路非常实用。

十一、最容易踩的 8 个坑

下面这些问题，几乎都是实际开发里高频出现的。

坑 1：忘了默认是二进制模式

with tempfile.temporaryfile() as f:
    f.write("hello")  # 报错

正确做法：

with tempfile.temporaryfile(mode="w+", encoding="utf-8") as f:
    f.write("hello")

坑 2：写完就让别的程序读，但没flush

with tempfile.namedtemporaryfile(mode="w+", encoding="utf-8") as f:
    f.write("data")
    # 这里立刻把路径交给别的逻辑，可能读不到完整内容

正确姿势：

f.flush()

必要时加：

import os
os.fsync(f.fileno())

坑 3：用了delete=false却忘记删除

这个问题在开发环境可能只是“目录脏了”，
在生产环境里可能就是磁盘一点点被吃满。

建议把清理写进 finally：

path = none
try:
    with tempfile.namedtemporaryfile(delete=false) as f:
        path = f.name
    # do something
finally:
    if path:
        import os
        try:
            os.unlink(path)
        except filenotfounderror:
            pass

坑 4：windows 下重复打开失败

这是最经典的兼容性问题。
记住一个原则：

需要通过路径再次访问时，优先考虑先关闭文件，再重新打开。

临时目录不是长期存储方案。
它可能被系统清理、被运维策略清理、被容器重建清理。

所以：

❌ 不要把临时文件当作业务持久化数据
✅ 临时文件只应该承担中间态职责

坑 6：误以为离开函数作用域就一定删掉

如果你没有用 with，或者对象引用没及时释放，
清理时机可能比你想象得更晚。

不推荐这样写：

f = tempfile.namedtemporaryfile()
# 依赖垃圾回收自动关闭删除

推荐始终用上下文管理器：

with tempfile.namedtemporaryfile() as f:
    ...

坑 7：高并发场景下自己拼文件名

不要自作聪明写这种逻辑：

filename = f"/tmp/task_{user_id}.txt"

你可能会遇到：

覆盖别人的文件
并发写冲突
安全问题
脏数据互串

只要是临时文件，就让 tempfile 负责命名。

坑 8：以为临时文件永远在磁盘上

比如 spooledtemporaryfile()，前期可能根本还在内存里。
你如果写了依赖“真实文件路径”的逻辑，就会出问题。

所以在设计时一定要分清：

你需要的是“文件对象”
还是“可访问路径”

这两个需求，选的 api 可能完全不同。

十二、tempfile的安全价值，别只停留在“方便”

很多人理解 tempfile，只看到“自动删除，很方便”。
但它更重要的一层价值，是安全性。

如果你手工写临时文件，比如：

path = "/tmp/my_temp.txt"

就可能面临以下风险：

文件名可预测
竞争条件
被其他用户抢先创建
被恶意符号链接利用
产生权限问题

而 tempfile 在设计上就尽量规避了这些问题，尤其是底层的 mkstemp() 这类接口，本质上就是更安全地创建唯一文件。

结论很直接

临时文件不只是“方便文件”，更是“安全文件”。

十三、怎么选 api：一张表看懂

下面这张表，可以当成日常选型速查表。

需求	推荐 api	说明
只在当前进程里短暂使用文件对象	`temporaryfile()`	简单直接，自动清理
需要一个真实文件路径	`namedtemporaryfile()`	可传给其他库或外部程序
需要临时工作目录	`temporarydirectory()`	多文件场景首选
小数据先放内存，大数据自动落盘	`spooledtemporaryfile()`	兼顾性能和内存
需要底层文件描述符控制	`mkstemp()`	更灵活，但要自己清理
只想创建目录并完全自己管理	`mkdtemp()`	手动清理目录

十四、生产环境里的最佳实践

下面这些建议，基本都是真实项目里总结出来的。

1. 优先使用with

这不仅是“写法优雅”，更是为了确保异常时也能清理资源。

with tempfile.temporarydirectory() as temp_dir:
    ...

2. 需要跨进程/跨库访问时，用namedtemporaryfile(delete=false)

然后在 finally 里删除。

这是非常稳的工程化方案。

3. 多个中间文件时，用临时目录，不要散着建

一个任务一个临时目录，目录中再组织多个文件，是最清晰的。

4. 大文件处理，不要无脑全放内存

能用 spooledtemporaryfile() 的场景，可以大幅减少内存压力。

5. 显式指定后缀名

特别是外部工具、三方库、测试场景里，这一点很容易救命。

suffix=".json"
suffix=".csv"
suffix=".png"

6. 清理逻辑写在finally

尤其当你使用 delete=false、mkstemp()、mkdtemp() 时。

7. 调试时可以暂时保留临时文件

线上默认清理，排查问题时允许通过配置关闭清理，这是一种很常见的做法。

例如：

import os
import tempfile

debug_keep_temp = os.getenv("debug_keep_temp") == "1"

temp_file = tempfile.namedtemporaryfile(delete=not debug_keep_temp)

这个思路在定位复杂问题时很好用。

十五、一个完整示例：下载、处理、输出、清理

下面给一个稍微完整一点的示例，模拟真实业务流：

创建临时目录
下载或生成原始数据
处理中间文件
输出结果
自动清理全过程

import json
import tempfile
from pathlib import path

def run_pipeline():
    with tempfile.temporarydirectory(prefix="pipeline_") as temp_dir:
        temp_dir = path(temp_dir)

        raw_path = temp_dir / "raw.json"
        cleaned_path = temp_dir / "cleaned.json"
        result_path = temp_dir / "result.txt"

        raw_data = {
            "name": "tempfile",
            "category": "python stdlib",
            "tags": ["file", "temp", "safe"]
        }

        raw_path.write_text(
            json.dumps(raw_data, ensure_ascii=false, indent=2),
            encoding="utf-8"
        )

        data = json.loads(raw_path.read_text(encoding="utf-8"))
        data["tags"] = [tag.upper() for tag in data["tags"]]

        cleaned_path.write_text(
            json.dumps(data, ensure_ascii=false, indent=2),
            encoding="utf-8"
        )

        result_path.write_text(
            f"模块：{data['name']}\n标签数量：{len(data['tags'])}",
            encoding="utf-8"
        )

        return result_path.read_text(encoding="utf-8")

print(run_pipeline())

这个例子虽然简单，但思路非常适合工程实践：

所有中间态都收敛在一个临时目录
逻辑结束自动清理
文件结构清晰
便于扩展为更复杂的数据流水线

十六、我最推荐的使用心法

如果只让我给 tempfile 提 4 条经验，我会给这 4 条：

1. 临时文件不是“随便找个路径”

而是一种需要认真管理的资源。

2. 先问自己：你要的是“文件对象”还是“文件路径”

这个问题一想清楚，api 选型基本就对了。

3. 多文件任务优先考虑temporarydirectory()

这往往比到处建临时文件更优雅。

4. 涉及跨平台时，对namedtemporaryfile()要格外谨慎

尤其是 windows 下的再次打开问题，别等上线后才踩坑。

十七、结尾

tempfile 不是那种“看一眼文档就结束”的模块。
它表面上很小，实际却和文件系统、安全性、资源管理、跨平台兼容性、性能取舍都密切相关。

很多 python 开发者平时对它的印象只是：

“哦，就是创建临时文件的那个模块。”

但真正把它用好之后你会发现，它解决的从来不只是“临时”这两个字，而是：

如何安全地生成文件
如何优雅地管理生命周期
如何在复杂业务里避免脏数据和资源泄漏
如何写出更稳的跨平台代码

如果你以前还在手写 /tmp/xxx.txt，那从今天开始，真的可以停下来了。

十八、附：一份速查清单

创建匿名临时文件

import tempfile

with tempfile.temporaryfile(mode="w+t", encoding="utf-8") as f:
    f.write("hello")
    f.seek(0)
    print(f.read())

创建带名字的临时文件

import tempfile

with tempfile.namedtemporaryfile(mode="w+t", encoding="utf-8") as f:
    print(f.name)

创建临时目录

import tempfile

with tempfile.temporarydirectory() as d:
    print(d)

创建小文件走内存、大文件自动落盘的临时文件

import tempfile

with tempfile.spooledtemporaryfile(max_size=1024, mode="w+t", encoding="utf-8") as f:
    f.write("hello")

底层方式创建临时文件

import os
import tempfile

fd, path = tempfile.mkstemp()
try:
    with os.fdopen(fd, "w", encoding="utf-8") as f:
        f.write("hello")
finally:
    os.unlink(path)

十九、总结

tempfile 最值得掌握的，不是“怎么创建”，而是“什么时候该用哪一个”。

你可以这样记：

只在进程内临时使用：temporaryfile
需要路径给别的程序/库：namedtemporaryfile
一整个临时工作空间：temporarydirectory
想平衡内存和磁盘：spooledtemporaryfile
想自己接管底层控制：mkstemp / mkdtemp

当你把这些边界理解清楚以后，tempfile 就会从一个“不起眼的小模块”，变成你写文件相关代码时非常可靠的一把工具刀。

以上就是python使用tempfile安全、优雅地处理临时文件与临时目录的详细内容，更多关于python tempfile处理临时文件与目录的资料请关注代码网其它相关文章！


验证码：

Python使用tempfile安全、优雅地处理临时文件与临时目录

2026年03月13日 • Python •我要评论