Python列表sort后变量变成None：用原地调用或sorted新列表修复

一、排序完成了，变量为什么却成了 None

在普通内置list上写下“数据 = 数据.sort()”，没有异常，下一行却发现数据是None。本文用Python 3.14.3的隔离实验说明原因：保留原对象就单独调用sort，需要接收排序结果就用sorted。修复后同时检查内容、返回值与别名，不把“排对了”当作全部验收。

这种症状不表示输入没有数据，也不是解释器把列表清空了。即使列表里有三个整数，排序照样可以成功，赋值后的名字仍然指向None。先去看产生这个变量的上一行，比继续在后面的循环里添加判空更有效。判空只能遮住症状，不能修正错误的返回值约定。

二、原地修改和变量赋值是两件事

sort改变当前列表的元素排列，返回值固定为None，而不是排好序的列表。赋值语句先执行右侧调用：原对象已经排序；再把调用结果绑定给左侧名字。于是“列表被修改”和“变量变成None”可以同时发生，没有矛盾。官方排序指南也明确用返回None提醒调用方：这是依靠副作用完成工作的接口。

如果别名此前指向同一列表，错误赋值不会让别名跟着指向None。别名仍能读到排序后的内容，因为它指向的是那个对象，不是另一个变量名。正确的原地写法是单独执行“数据.sort()”，后续继续使用数据。别名和数据保持同一身份，也都会看到新的顺序。

在函数里同样要先想清接口。只负责原地整理的函数，可以不返回结果；需要让调用者接收结果的函数，应明确返回列表，而不是直接返回sort的返回值。不要依靠调用方猜测。也不要用“数据.sort() or 数据”掩盖约定，两步表达更容易检查和维护。

空列表和只有一个元素的列表没有明显的次序变化，但sort仍然返回None。这也是为什么不能只用打印后的内容判断接口行为。示例把这两组边界分别验证，并检查外层身份。即使排序前后看起来一样，原地方法与新建方法仍是不同的操作。

三、要一个新列表，使用 sorted，但别当成深复制

sorted接受可迭代对象，返回新建的list。对于不修改输入的普通键函数，用它排列原列表不会改动原列表的顺序。因此“新表 = sorted(原表)”适合保留输入排列的场合。新表和原表的外层身份不同，不能再期待其他指向原表的变量自动看到新顺序。

新建的只是外层列表，收集的仍是原元素引用。元素若是字典，新表里的字典和原表里的对应字典还是同一个对象。修改字典内部的备注列表，会从两边观察到变化。这不是sorted回头修改了输入次序，而是两个容器共享元素。是否需要复制元素，要由数据所有权决定，排序本身不负责隔离。

可迭代也不等于可反复读取。把有限生成器交给sorted，会为了得到全部排序结果消耗它；再次遍历时可能已经没有元素。不能把“原列表次序不变”推广为“所有输入都没有任何状态变化”。无限输入也不能指望一次完整排序自动结束，应先限定数据范围。

四、key负责比较标准，reverse负责方向

按记录中的分数字段排列时，key应接收一个元素并返回可比较的键。正常完成的排序会为每个元素计算一次键，后续比较使用这些键，而不是每次比较都重新调用函数。示例把调用写入独立日志，核对次数和记录名；日志不是生产环境里推荐加入取键副作用的理由。

sort与sorted都保证稳定排序：键相等的元素保留输入中的相对顺序。reverse=True改变排序方向，但仍保留同键稳定性。示例用四条合成记录检查升序和降序，两个同分组在各自组内都不颠倒。只有几个互不相同的数字，检验不出这项约定。

不要写“数据.sort().reverse()”。sort先成功执行，随后却是在None上查找reverse，因而报AttributeError。直接使用sort(reverse=True)表达降序更清楚。即使拆成排序、reverse两步，第二步是把整个排列翻转，同键组内顺序也会翻转，并不等价于稳定的降序排序；reverse自身也返回None。

五、类型错误不是返回 None，异常也不保证回滚

None与整数混排是另一类问题。普通整数能够比较大小，None却没有自动排在最前或最后的默认规则。直接排序可能抛TypeError，此时不是“返回了None”，而是调用没有正常返回。key若有时返回None、有时返回整数，也会把同样的不可比较关系带入排序。先分清返回值与异常，再决定是改赋值方式，还是补充明确的数据策略。

本文示例选择“整数升序，缺失值置后”，并只接受严格的int或None，连bool也显式拒绝。键是二元组：先区分是否缺失，再比较整数；缺失项使用固定整数占位，避免再次比较None与整数。这是教学输入约定，不是任意混合类型的通用转换器，字符串和浮点数要另定业务规则。

原地排序抛异常后，原列表可能已经部分改变，不能承诺自动恢复原顺序。示例故意用局部无序数据触发比较失败，并打印失败后的输入，作为当前解释器的观测，不把具体残留排列写成跨版本保证。key自身也可能抛异常，此前已执行的日志等副作用不会撤销。

若需要保留原列表排列，可以先用sorted建立候选结果，成功后再决定是否接收。但这仍不回滚取键函数对元素或外部资源的操作。排序期间也不要在key中查看或修改正在排序的列表；官方明确提示CPython下这种效果未定义，能检测到修改时可能报ValueError，不是可靠的流程控制办法。

六、完整实验：一份脚本检查两条修复路径

把下面完整代码保存为example.py，执行“python3 example.py”。脚本只用标准库，不写业务文件、不连接数据库或网络；每通过一项才计数，缺少预期异常会直接失败。这里使用显式条件，不依赖assert，因此不能通过关闭断言让错误变成成功。

随文脚本在Python 3.14.3运行，合计二十六项通过。计数包括空表和单项分别验证两种接口，四种接口与方向组合分别验证取键及稳定性，三种非法输入分别验证拒绝。异常后的列表只是打印观测，不计为“回滚通过”。这些是内存容器实验，不是真实数据库、文件排序或并发业务验收。

import sys

通过 = []


def 核验(名称, 条件):
    if not 条件:
        raise RuntimeError("未通过：" + 名称)
    通过.append(名称)
    print("通过：" + 名称)


def 应抛(类型, 操作):
    try:
        操作()
    except 类型:
        return True
    raise RuntimeError("没有抛出预期异常：" + 类型.__name__)


def 缺失放后(值):
    # 本例只接受严格的 int 或 None，bool 也拒绝。
    if 值 is not None and type(值) is not int:
        raise TypeError("只接受 int 或 None")
    return (值 is None, 0 if 值 is None else 值)


print("解释器：", sys.version.split()[0])
数据 = [3, 1, 2]
别名 = 数据
数据 = 数据.sort()
核验("错误赋值只把名字绑定到None", 数据 is None and 别名 == [1, 2, 3])

数据 = [3, 1, 2]
别名 = 数据
返回值 = 数据.sort()
核验("sort返回None且别名身份保留", 返回值 is None and 数据 is 别名 and 别名 == [1, 2, 3])

原表 = [3, 1, 2]
新表 = sorted(原表)
核验("sorted新建外层且原顺序不变", 新表 is not 原表 and 新表 == [1, 2, 3] and 原表 == [3, 1, 2])

原表 = [{"分": 2, "备注": []}, {"分": 1, "备注": []}]
新表 = sorted(原表, key=lambda 项: 项["分"])
新表[0]["备注"].append("共享")
核验("sorted保留原元素引用", 新表[0] is 原表[1] and 原表[1]["备注"] == ["共享"])

for 输入 in ([], [7]):
    数据 = 输入.copy()
    别名 = 数据
    核验("sort边界" + repr(输入), 数据.sort() is None and 数据 is 别名 and 数据 == 输入)
    新表 = sorted(数据)
    核验("sorted边界" + repr(输入), 新表 == 输入 and 新表 is not 数据)

记录 = [("甲", 2), ("乙", 1), ("丙", 2), ("丁", 1)]
for 方式 in ("sort", "sorted"):
    for 降序 in (False, True):
        调用 = []

        def 取键(项):
            调用.append(项[0])  # 独立日志，不检查或修改正在排序的列表。
            return 项[1]

        数据 = 记录.copy()
        if 方式 == "sort":
            数据.sort(key=取键, reverse=降序)
            结果 = 数据
        else:
            结果 = sorted(数据, key=取键, reverse=降序)
        预期 = ["甲", "丙", "乙", "丁"] if 降序 else ["乙", "丁", "甲", "丙"]
        核验(方式 + "逐元素一次取键及稳定性 reverse=" + str(降序),
             调用 == [项[0] for 项 in 记录] and [项[0] for 项 in 结果] == 预期)

反转结果 = sorted(记录, key=lambda 项: 项[1])
反转结果.reverse()
核验("整体反转会颠倒同键组", [项[0] for 项 in 反转结果] == ["丙", "甲", "丁", "乙"])
核验("key结果混合None与int也会失败", 应抛(TypeError, lambda: sorted([{"键": 1}, {"键": None}], key=lambda 项: 项["键"])))

for 方式 in ("sort", "sorted"):
    数据 = [1, 3, 2, None]
    操作 = 数据.sort if 方式 == "sort" else lambda: sorted(数据)
    核验(方式 + "混合None与int拒绝直接比较", 应抛(TypeError, 操作))
    print(方式 + "异常后输入观测（不保证回滚）：", 数据)

数据 = [None, 3, -1, None, 0]
核验("显式策略让None放末尾", sorted(数据, key=缺失放后) == [-1, 0, 3, None, None])
for 非法 in ("2", False, 2.0):
    核验("显式策略拒绝" + repr(非法), 应抛(TypeError, lambda: sorted([非法], key=缺失放后)))

for 方式 in ("sort", "sorted"):
    数据 = [3, 1, 2]
    调用 = []

    def 坏键(值):
        调用.append(值)
        if 值 == 1:
            raise ValueError("教学用取键失败")
        return 值

    操作 = (lambda: 数据.sort(key=坏键)) if 方式 == "sort" else (lambda: sorted(数据, key=坏键))
    核验(方式 + "取键失败传播且已发生日志不撤销", 应抛(ValueError, 操作) and 调用 == [3, 1])

生成器 = (值 for 值 in [3, 1, 2])
新表 = sorted(生成器)
核验("sorted消耗有限生成器", 新表 == [1, 2, 3] and list(生成器) == [])

数据 = [3, 1, 2]
核验("sort后链式reverse会报错", 应抛(AttributeError, lambda: 数据.sort().reverse()) and 数据 == [1, 2, 3])
数据 = [3, 1, 2]
返回值 = 数据.sort(reverse=True)
核验("降序使用reverse关键字", 返回值 is None and 数据 == [3, 2, 1])
返回值 = 数据.reverse()
核验("reverse本身也不返回列表", 返回值 is None and 数据 == [1, 2, 3])
print("合计通过：", len(通过))

七、失败分支按现象定位

排查时先看调用有没有正常完成，再看名字绑定和对象内容。不要遇到任何异常都改成sorted：它能改变结果的承接方式，却不会替你定义None的排序位置，也不会修复一个本来就会抛错的key函数。下面的分支表用于缩小问题，不替代数据校验。

八、提交修改前的验收清单

验证不能只比较最终数字顺序。保留原地路径时检查别名身份；选择新建路径时检查原顺序以及共享元素边界。把错误赋值和链式调用留作负例，能防止后来重构时重新引入同一问题。需要并发或外部资源保证的项目，还要单独设计业务测试，不能借这份脚本代替。

• 确认对象是普通内置list，明确调用方是否需要共享更新。
• 分别检查返回值、外层身份、排序内容以及空表和单项。
• 检查同键记录在升序与reverse=True下保持相对顺序。
• 检查混合类型和取键异常，不对sort失败后的排列作保证。
• 检查sorted仅新建外层，以及生成器会被消费。

九、参考文献与适用边界

事实核对采用Python官方3.14系列文档，实际执行解释器为3.14.3；在线文档页眉的维护小版本不等于本地测试版本。讨论仅覆盖本文普通内置容器、合成输入和顺序执行条件，不外推自定义列表子类的重写行为，也不宣称排序具备业务事务能力。

• Python 3.14 Built-in Types：list.sort，原地修改、取键、稳定性、异常及排序期间访问限制。
• Python 3.14 Built-in Functions：sorted，新list、可迭代输入与稳定性。
• Python 3.14 Sorting Techniques，返回None、每元素一次取键以及reverse的稳定性。