已经深复制，两位助手的草稿为什么还是一起变？

"""Ordinary dict/list plan graphs; copy boundaries are not concurrency boundaries."""
from copy import deepcopy
from pathlib import Path
import csv
import json
import sys


def template():
    return {"title": "draft", "steps": [{"task": "check", "status": "todo"}], "notes": []}


def locations(source, result):
    found = {}
    for prefix, plans in (("source", source), ("result", result)):
        found[prefix] = plans
        for i, plan in enumerate(plans):
            base = f"{prefix}[{i}]"
            found[base] = plan
            found[base + ".steps"] = plan["steps"]
            found[base + ".steps[0]"] = plan["steps"][0]
            found[base + ".notes"] = plan["notes"]
    return found


def relationships(source, result):
    names, seen = [], []
    for path, obj in locations(source, result).items():
        label = next((f"object-{i + 1}" for i, previous in enumerate(seen) if obj is previous), None)
        if label is None:
            seen.append(obj)
            label = f"object-{len(seen)}"
        names.append({"path": path, "object_label": label, "kind": type(obj).__name__})
    return names


def snapshot(source, result):
    # JSON captures values only. The separate relationship table records identity.
    return json.loads(json.dumps({"source": source, "result": result}))


def one_case(name, method, shared_steps_only=False):
    first = template()
    if shared_steps_only:
        second = template()
        second["steps"] = first["steps"]
        source = [first, second]  # Distinct plan dictionaries, one shared checklist.
    else:
        source = [first, first]  # Two list positions, only one original plan.
    result = method(source)
    assert result == source
    graph = relationships(source, result)
    source_objects = list(locations(source, source).values())
    result_objects = list(locations(result, result).values())
    external_isolation = not any(a is b for a in source_objects for b in result_objects)
    flags = {"same_result_plans": result[0] is result[1],
             "same_result_steps": result[0]["steps"] is result[1]["steps"],
             "same_result_notes": result[0]["notes"] is result[1]["notes"],
             "result_mutables_detached_from_source": external_isolation}
    stages = [{"stage": "before", "values": snapshot(source, result)}]
    result[0]["steps"][0]["status"] = "done"
    stages.append({"stage": "edit_first_step", "values": snapshot(source, result)})
    result[0]["notes"].append("checked-by-first")
    stages.append({"stage": "append_first_note", "values": snapshot(source, result)})
    affected_steps = [path for path, obj in locations(source, result).items()
                      if path.endswith(".steps[0]") and obj["status"] == "done"]
    affected_notes = [path for path, obj in locations(source, result).items()
                      if path.endswith(".notes") and obj == ["checked-by-first"]]
    return {"case": name, "input_shape": "shared_steps_only" if shared_steps_only else "repeated_plan",
            "all_values_initially_equal": True, "flags": flags, "relationships": graph,
            "stages": stages, "affected_steps": affected_steps, "affected_notes": affected_notes}


def main():
    cases = [
        one_case("assignment", lambda plans: plans),
        one_case("shallow_collection", lambda plans: list(plans)),
        one_case("shallow_each_plan", lambda plans: [dict(plan) for plan in plans]),
        one_case("deep_collection", deepcopy),
        one_case("deep_each_plan", lambda plans: [deepcopy(plan) for plan in plans]),
        one_case("distinct_plans_shared_steps", deepcopy, shared_steps_only=True),
    ]
    expected = {
        "assignment": (True, True, True, False, 4, 4),
        "shallow_collection": (True, True, True, False, 4, 4),
        "shallow_each_plan": (False, True, True, False, 4, 4),
        "deep_collection": (True, True, True, True, 2, 2),
        "deep_each_plan": (False, False, False, True, 1, 1),
        "distinct_plans_shared_steps": (False, True, False, True, 2, 1),
    }
    rows = []
    for case in cases:
        actual = tuple(case["flags"].values()) + (len(case["affected_steps"]), len(case["affected_notes"]))
        assert actual == expected[case["case"]], (case["case"], actual)
        rows.append({"case": case["case"], **case["flags"],
                     "changed_step_paths": len(case["affected_steps"]),
                     "changed_note_paths": len(case["affected_notes"])})
    # Value equality alone cannot identify the graph before mutation.
    assert cases[3]["stages"][0]["values"] == cases[4]["stages"][0]["values"]
    report = {"python": sys.version.split()[0], "assertions": "passed",
              "scope": "Six deterministic ordinary dict/list cases; sequential mutations; no workers, threads, model, files or sockets are copied.",
              "identity_labels": "Local stable labels per case, not memory addresses or persistent IDs.", "cases": cases}
    Path("copy-aliases-report.json").write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    with Path("copy-aliases-summary.csv").open("w", newline="", encoding="utf-8") as file:
        writer = csv.DictWriter(file, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)
    graph_rows = [{"case": case["case"], **row} for case in cases for row in case["relationships"]]
    with Path("copy-aliases-objects.csv").open("w", newline="", encoding="utf-8") as file:
        writer = csv.DictWriter(file, fieldnames=list(graph_rows[0]))
        writer.writeheader()
        writer.writerows(graph_rows)
    print(json.dumps({"assertions": "passed", "cases": len(cases), "graph_rows": len(graph_rows),
                      "deep_collection_changed_step_paths": len(cases[3]["affected_steps"]),
                      "deep_each_changed_step_paths": len(cases[4]["affected_steps"])}))


if __name__ == "__main__":
    main()