哎呀，写Python代码写到一半，那叫一个顺手，思路像泉水一样“哗哗”地往外冒。结果呢？突然一个急茬儿蹦出来，或者手一抖把终端窗口给关了（别告诉我你没干过这事儿！），又或者，更要命的，突然想起来另一个分支有个更重要的bug等我去救火。这时候，看着屏幕上这堆还没跑通、还没提交、甚至还没保存的半成品，心肝儿都在颤：这玩意儿，我辛辛苦苦码了半天，python怎么暂存一下，回头再来收拾它？总不能就这么丢了吧！

说起来，“暂存”这事儿，在开发世界里真是个刚需。它可不是简简单单的Ctrl+S保存一下文件那种事儿。更复杂点儿，更灵活点儿，能应对各种突发状况。而且，“暂存”的对象也不止是代码文件本身，有时候是程序运行到一半的状态，有时候是交互式环境里的变量，甚至仅仅是一些临时生成的数据。咱们就来掰扯掰扯，在Python的世界里，到底有几种姿势可以实现这个“暂存”大业。

说到代码暂存，Git那个玩意儿…

程序员嘛，谁不知道Git？这个版本控制系统简直是我们的左膀右臂。而Git里头，有个功能简直就是为了“暂存代码改动”而生的，那就是 git stash。

想象一下，你正改着一个功能，改到一半，代码乱糟糟的，有新加的文件，有修改的文件，甚至还有些你压根儿不打算提交的调试打印。突然，leader杀过来：“线上有个紧急bug，你赶紧切到master分支看看！”这时候你心里一万匹马奔腾而过，这堆没整完的代码咋办？直接git checkout master？那肯定报错，Git才不让你这么干呢，它怕你丢改动。

git stash 就是来救场的！它能把你当前工作目录里那些还没提交（Untracked或者Modified）的改动，像变魔术一样，“嗖”地一下藏起来，让你的工作目录瞬间变得干干净净，回到上一次提交的状态。

怎么用？简单得要死：

git stash

或者更明确点儿：

git stash save "我改了一半的功能X"

后面加个消息是个好习惯，特别是你stash了好几次之后，没有消息你鬼知道每个stash里藏的是啥。

藏起来了，你的工作目录就干净了，这时候你就可以放心地切换分支、拉代码、处理紧急任务了。等紧急任务搞定了，你想回来继续写那个功能X了，怎么办？再把它掏出来呗：

git stash list

这会列出你藏起来的所有stash，通常会像这样：stash@{0}: On branch_name: message。stash@{0}就是最近的一次。

你想把最近这次改动再弄出来，接着改？有两个选择：

git stash apply stash@{0}

或者更常用的：

git stash pop stash@{0}

apply 是应用stash里的改动，但stash本身还保留着。pop 呢，是应用完之后，就把这个stash从列表里删掉了，更像“取出来用完就扔”。我个人更喜欢 pop，用完了就清掉，看着清爽。不指定 stash@{0} 的话，默认就是操作最近的那个stash。

用 apply 或者 pop 的时候，有时候会遇到冲突（如果stash里的改动跟你当前分支的新代码有冲突的话），处理方式跟平时merge或rebase冲突一样。

git stash 还有些小技巧，比如 git stash -u 会连 untracked files（就是你新建了但还没 git add 的文件）一起stash进去。git stash -k 则只会stash tracked files 的改动，保留索引（staged area）和 untracked files。根据你的需求来选。

但我得说句实话，git stash 这玩意儿，我是又爱又恨。

爱它是因为它救过我的命，无数次在关键时刻帮我藏好了乱七八糟的代码。恨它是因为，如果stash太多了，简直跟垃圾堆一样，你根本不知道每个stash是干啥的，也容易忘掉，最后堆在那里碍眼。而且stash本身管理起来不像commit那么直观，冲突处理起来也可能有点烦人。

我的个人偏好是： 如果是小改动，很快就能完成或者扔掉的，我可能会直接放那不管（不推荐，哈哈，有点糙）。如果是稍微复杂点儿的改动，但我不确定方向的，我会新建一个临时分支，在那个分支上改，大不了最后把分支删了。只有那种“我操，我现在立刻马上就要切分支干别的，但手上这个东西绝对不能丢”的场景，我才会祭出 git stash。用完了一定要尽快 pop 出来或者 drop 掉 (git stash drop stash@{n})，别让它在那里长蘑菇。

所以，用 Git stash 暂存代码，确实是一个主流且强大的手段，但请记住，它更多的是一个临时救急的工具，不是长期存储代码的地方。

程序跑一半，状态怎么“腌”起来？

有时候，我们需要暂存的不是代码本身，而是程序运行时的“状态”或者处理到一半的“数据”。比如你写了个脚本，要处理1000个文件，跑了500个文件了，电脑突然要重启，或者你发现前面处理的有点问题想停下来改改。总不能每次都从头开始吧？这时候，我们就需要把程序当前的进度、处理结果、甚至内部的变量值都保存下来，下次能从中断的地方继续。

Python里，有一个特别常用的模块来干这事儿，叫做 pickle。

pickle 的作用，简单来说，就是把Python的对象序列化（serialize），变成一串字节流，然后你可以把这串字节流存到文件里。反过来，需要的时候，再把文件里的字节流反序列化（unserialize或unpickle），变回原来的Python对象。

这简直是给程序状态打“时间胶囊”啊！你可以把一个列表、一个字典、一个类的实例、甚至是函数对象（虽然不常用且有坑）都通过 pickle 存起来。

怎么用？

“`python
import pickle

假设这是你程序运行到一半的状态或数据

my_data = {
‘progress’: 500,
‘results’: [‘result_a’, ‘result_b’, …],
‘config’: {‘param1’: 10, ‘param2’: ‘value’}
}

暂存状态：把对象pickle到文件

with open(‘checkpoint.pkl’, ‘wb’) as f:
pickle.dump(my_data, f)
print(“程序状态已暂存到 checkpoint.pkl”)

假设程序中断了，下次启动时…

恢复状态：从文件unpickle回对象

try:
with open(‘checkpoint.pkl’, ‘rb’) as f:
loaded_data = pickle.load(f)
print(“程序状态已从 checkpoint.pkl 恢复”)
print(“恢复的数据:”, loaded_data)
# 现在你可以根据 loaded_data[‘progress’] 继续处理了
except FileNotFoundError:
print(“未找到暂存文件，从头开始”)
loaded_data = None # 或者初始化状态
“`

pickle 用起来确实方便，能存的对象种类也多。很多机器学习库保存模型状态就喜欢用它。

但是，pickle 也有它蛋疼的地方，不得不防：

1. 安全性问题： 千万！千万！别去 pickle.load() 一个你不信任来源的文件。因为pickle的字节流里可能包含能执行任意代码的指令。想象一下，有人发给你一个恶意的.pkl文件，你一加载，电脑就中招了。这可不是闹着玩的。
2. 兼容性： 用不同版本的Python或者不同版本的库pickle出来的文件，在另一个环境里可能unpickle失败。特别是复杂的自定义类，改了类定义后，之前pickle的对象可能就加载不回来了。
3. 可读性差： pickle是二进制格式，你打不开文件看里面是啥，调试起来不方便。

所以，如果你要暂存的状态比较简单，比如只是列表、字典、数字、字符串，那么用 json 模块或者存成CSV、文本文件可能更靠谱。JSON是跨语言、跨平台的，可读性也极好，虽然它不支持所有Python对象类型（比如不能直接存集合set、日期时间对象需要特殊处理、自定义类实例更不行）。但如果是为了通用性和安全性，JSON往往是更好的选择。

“`python
import json

simple_data = {
‘count’: 100,
‘items’: [‘apple’, ‘banana’]
}

暂存简单数据用JSON

with open(‘simple_state.json’, ‘w’, encoding=’utf-8′) as f:
json.dump(simple_data, f, indent=4) # indent让文件更易读

恢复

try:
with open(‘simple_state.json’, ‘r’, encoding=’utf-8′) as f:
loaded_simple_data = json.load(f)
print(“简单状态已恢复:”, loaded_simple_data)
except FileNotFoundError:
print(“未找到简单状态文件”)

“`

说到底，用pickle还是json或者其他格式来暂存程序状态，取决于你要存啥，以及你对安全性、可读性、兼容性的要求。 如果是内部工具、自己用，pickle图个方便；如果是要和外部交互，或者需要长期保存且保证兼容性，考虑JSON或其他标准格式。再复杂点儿，可能就要请出数据库了，比如用个轻量级的 SQLite 数据库文件，把中间结果和状态存进去，那才叫一个稳当。

交互式环境里的“随手存”

经常玩Jupyter Notebook或者IPython的同学可能更关心另一个问题：我在里头敲了一堆代码，定义了好多变量，跑出了些中间结果，比如DataFrame啥的，结果电源线被人踢掉了，或者浏览器崩了，这内存里的东西，python怎么暂存啊？

最直接、最常用的方法当然是：保存你的Notebook文件（.ipynb）！ 这个文件会把你的代码、输出、markdown文本都保存下来。下次打开，虽然变量不在内存了，但代码都在，重新运行一下就好。这算是一种“代码+输出”的暂存。

但有时候，你可能就想保存内存里的某个变量的值，不想重新跑一遍前面的代码。比如一个计算了半天的大型数据结构。

在IPython/Jupyter里，有个好用的“魔术命令”（Magic Commands）可以帮你：%store。

“`python

在Jupyter/IPython里

my_result = [i * i for i in range(10000)]
print(len(my_result))

把变量 my_result 存起来

%store my_result

现在你可以关掉Notebook，或者开个新的Kernel/Notebook

在新的环境里

恢复之前存的变量

%store -r my_result
print(len(my_result)) # 变量 my_result 就回来了！

你也可以看看存了哪些变量

%store

删除某个存的变量

%store -d my_result

删除所有存的变量

%store -c
“`

%store 实际上是把变量的值pickle到IPython的配置文件目录下的一个db文件里。下次启动IPython/Jupyter时，如果配置正确，它会尝试加载这些变量。这对于在不同的Notebook之间或者不同的IPython session之间传递变量非常方便。

另外，如果你想把某个Cell的代码保存成一个独立的.py文件，可以用 %save 魔术命令：%save my_script.py 1-5 7 （把当前Notebook中Cell 1到5和Cell 7的代码保存到 my_script.py）。这虽然不是“暂存”运行状态，但能帮你快速把你敲好的代码“暂存”到文件里。

临时数据的文件落地

最后一个比较常见的“暂存”场景，是程序运行过程中产生的临时数据。比如你写了个爬虫，爬到的数据先别直接入库，先存到一个临时文件里，等爬完了再统一处理或者检查。或者处理大数据文件时，分块读取，每处理完一块，就把中间结果写到一个临时文件里，避免所有结果都堆在内存里撑爆。

Python的 tempfile 模块就是干这个的。它可以创建临时文件和临时目录，用完后系统会自动清理（或者你可以指定手动清理）。这比你自己随便打开一个文件起个名叫 temp_output.txt 要规范安全得多，特别是避免文件名冲突的问题。

“`python
import tempfile
import os

创建一个临时文件，文件会在关闭或者程序退出时自动删除

with tempfile.TemporaryFile(‘w+’) as fp:
fp.write(‘Hello temporary world!\n’)
fp.seek(0)
print(fp.read())
# 文件在这里是存在的，可以读写
# 一旦with块结束，文件就被删除了

创建一个带名字的临时文件，可以用文件名访问

delete=False 表示程序退出时不自动删除，需要手动清理

with tempfile.NamedTemporaryFile(mode=’w+’, delete=False) as fp:
print(‘临时文件名:’, fp.name)
fp.write(‘这是一个带名字的临时文件。\n’)
# 你可以在with块外面用 fp.name 访问这个文件
temp_filename = fp.name

print(f”临时文件 {temp_filename} 还在，用完记得 os.remove(‘{temp_filename}’)”)

别忘了手动删除！

os.remove(temp_filename)

创建一个临时目录

with tempfile.TemporaryDirectory() as tmpdir:
print(‘临时目录:’, tmpdir)
# 在这个目录里可以创建文件、子目录
temp_filepath = os.path.join(tmpdir, ‘my_temp_data.txt’)
with open(temp_filepath, ‘w’) as f:
f.write(“数据123″)
print(f”临时目录里的文件 {temp_filepath} 已创建”)
# with块结束，整个临时目录及其内容都被删除了
“`

使用 tempfile 模块来暂存运行时产生的临时数据，既安全又方便，能有效管理生命周期，避免垃圾文件的堆积。

总结一下唠叨这么多：

你看，“python怎么暂存”这个问题，其实没有一个放之四海而皆准的答案。得看你具体想“暂存”个啥，以及是为了啥目的。

• 如果是代码改动，你写了一半不想提交，但又想切换分支，那 git stash 是你的不二之选。记住它的临时性，用完就清理。
• 如果是程序运行状态或复杂数据对象，想中断后恢复，pickle 是个便捷的工具，但要注意安全和兼容性。如果数据简单且需要通用性/可读性，考虑 json 或其他格式。再复杂点，可能得靠数据库。
• 如果在交互式环境里想保存变量，%store 魔术命令很方便，或者直接保存Notebook。
• 如果是程序运行产生的临时数据文件，用 tempfile 模块来规范管理。

理解每种方法的适用场景、优缺点，然后选择最适合你当前情况的那个。别怕试错，写代码的过程，不就是不断尝试、不断找到更优雅（或者至少是能跑起来不崩溃）的方法的过程吗？希望这些“暂存”的招数，能在你敲代码敲到头秃、突然被打断时，给你一点小小的帮助，让你那些未完成的宝贝，都能安然无恙地躺好，等着你回来宠幸它们！