已经用了 CSV 解析器，两行备注为什么还是粘成了一行？

"""Four local CSV reading paths; fictional string fields, no service or model."""
from pathlib import Path
import csv
import hashlib
import json
import platform
import sys

HEADER = ["id", "title", "note"]
RECORDS = [
    ["R1", "青禾", "ordinary"],
    ["R2", "comma,inside", "first\r\nsecond"],
    ["R3", 'say "hello"', "upper\nlower"],
    ["R4", "", "left\rright"],
]
EXPECTED = [HEADER, *RECORDS]
FORMAT = {"delimiter": ",", "quotechar": '"', "doublequote": True,
          "quoting": csv.QUOTE_MINIMAL, "skipinitialspace": False}


def parse_csv(lines):
    reader = csv.reader(lines, strict=True, **FORMAT)
    rows, ends = [], []
    for row in reader:
        rows.append(row)
        ends.append(reader.line_num)
    return rows, ends


def cell(rows, record, column):
    if record < len(rows) and column < len(rows[record]):
        return {"present": True, "value": rows[record][column]}
    return {"present": False, "value": None}


def inspect(name, rows, consumed_lines):
    differences = []
    for record in range(max(len(EXPECTED), len(rows))):
        expected_width = len(EXPECTED[record]) if record < len(EXPECTED) else 0
        actual_width = len(rows[record]) if record < len(rows) else 0
        for column in range(max(expected_width, actual_width)):
            expected, actual = cell(EXPECTED, record, column), cell(rows, record, column)
            if expected != actual:
                differences.append({"record_index": record, "column_index": column,
                                    "expected": expected, "actual": actual})
    return {"mode": name, "records_including_header": len(rows),
            "data_records": len(rows) - 1, "all_widths_three": all(len(row) == 3 for row in rows),
            "same_record_count": len(rows) == len(EXPECTED), "exact_values": rows == EXPECTED,
            "source_lines_after_each_record": consumed_lines,
            "rows": rows, "differences": differences}


def main():
    path = Path("tool-records.csv")
    with path.open("w", encoding="utf-8", newline="") as file:
        writer = csv.writer(file, lineterminator="\r\n", **FORMAT)
        writer.writerows(EXPECTED)
    raw = path.read_bytes()
    text = raw.decode("utf-8")  # No newline conversion in bytes.decode.
    physical_lines = text.splitlines()
    cases = [inspect("split_lines_and_commas", [line.split(",") for line in physical_lines], [])]
    rows, ends = parse_csv(physical_lines)
    cases.append(inspect("split_lines_then_csv", rows, ends))
    with path.open(encoding="utf-8", newline=None) as file:
        rows, ends = parse_csv(file)
    cases.append(inspect("default_newline_then_csv", rows, ends))
    with path.open(encoding="utf-8", newline="") as file:
        rows, ends = parse_csv(file)
    cases.append(inspect("preserved_newline_then_csv", rows, ends))

    naive, stripped, translated, preserved = cases
    assert len(physical_lines) == 8 and len(EXPECTED) == 5
    assert naive["data_records"] == 7 and not naive["all_widths_three"]
    assert stripped["same_record_count"] and stripped["all_widths_three"]
    assert [row[2] for row in stripped["rows"][2:]] == ["firstsecond", "upperlower", "leftright"]
    assert len(stripped["differences"]) == 3 and not stripped["exact_values"]
    assert [row[2] for row in translated["rows"][2:]] == ["first\nsecond", "upper\nlower", "left\nright"]
    assert len(translated["differences"]) == 2 and not translated["exact_values"]
    assert preserved["exact_values"] and not preserved["differences"]
    assert preserved["source_lines_after_each_record"] == [1, 2, 4, 6, 8]
    assert path.read_bytes() == raw  # Every reading path leaves the input bytes untouched.

    # Unclosed quoted input is a separate syntax failure; it is never repaired silently.
    malformed = 'id,title,note\r\nR5,plain,"unfinished\r\n'
    from io import StringIO
    try:
        parse_csv(StringIO(malformed, newline=""))
    except csv.Error as error:
        syntax_error = {"rejected": True, "type": type(error).__name__, "message": str(error)}
    else:
        raise AssertionError("unterminated quoted field was accepted")

    report = {"assertions": "passed", "python": sys.version.split()[0], "platform": platform.system(),
              "scope": "Four standard-library readers over one fixed local UTF-8 CSV. No spreadsheet UI, model, network or external business file.",
              "dialect": {"encoding": "utf-8", "delimiter": ",", "quotechar": '"',
                          "doublequote": True, "record_terminator": "\r\n", "reader_strict": True},
              "input_sha256": hashlib.sha256(raw).hexdigest(), "input_byte_count": len(raw),
              "input_hex": raw.hex(), "escaped_input": text, "expected": EXPECTED,
              "physical_lines_for_this_fixture": len(physical_lines), "cases": cases,
              "syntax_control": syntax_error}
    Path("csv-record-report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    Path("tool-records.hex.txt").write_text(raw.hex() + "\n", encoding="ascii")
    fields = ["mode", "data_records", "all_widths_three", "same_record_count", "exact_values", "changed_cells"]
    with Path("csv-record-summary.csv").open("w", encoding="utf-8", newline="") as file:
        writer = csv.DictWriter(file, fieldnames=fields)
        writer.writeheader()
        writer.writerows({**{key: case[key] for key in fields[:-1]}, "changed_cells": len(case["differences"])} for case in cases)
    # Escape each value as JSON so a difference row never hides its own CR/LF.
    with Path("csv-record-differences.csv").open("w", encoding="utf-8", newline="") as file:
        writer = csv.writer(file)
        writer.writerow(["mode", "record_index", "column_index", "expected_json", "actual_json"])
        for case in cases:
            for change in case["differences"]:
                writer.writerow([case["mode"], change["record_index"], change["column_index"],
                                 json.dumps(change["expected"], ensure_ascii=False),
                                 json.dumps(change["actual"], ensure_ascii=False)])
    print(json.dumps({"assertions": "passed", "read_paths": len(cases), "input_data_records": len(RECORDS),
                      "physical_lines": len(physical_lines), "stripped_changed_cells": 3,
                      "translated_changed_cells": 2, "preserved_changed_cells": 0,
                      "syntax_control_rejected": syntax_error["rejected"]}))


if __name__ == "__main__":
    main()