Multiline Text Processing in Python: Splitting Lines with splitlines()

Standard text files typically end with a trailing newline. Notice the discrepancy:

file_data = "Header\nRecord 1\nRecord 2\n"

# 1. Using split('\n') produces a spurious trailing empty string
naive_split = file_data.split("\n")
print("split('\\n'):   ", naive_split)  # ['Header', 'Record 1', 'Record 2', '']

# 2. Using splitlines() recognizes trailing newline as line terminator
robust_split = file_data.splitlines()
print("splitlines():  ", robust_split) # ['Header', 'Record 1', 'Record 2']

Expected Output:

split('\n'):    ['Header', 'Record 1', 'Record 2', '']
splitlines():   ['Header', 'Record 1', 'Record 2']

When reading Windows-generated files (CRLF), split('\n') splits only on \n, leaving stray \r characters attached to the end of every parsed line:

windows_data = "Row1\r\nRow2\r\nRow3"

# split('\n') leaves unwanted \r in strings
bad_lines = windows_data.split("\n")
print("split('\\n') with CRLF:  ", bad_lines)  # ['Row1\r', 'Row2\r', 'Row3']

# splitlines() consumes the full \r\n cleanly
good_lines = windows_data.splitlines()
print("splitlines() with CRLF: ", good_lines) # ['Row1', 'Row2', 'Row3']

Expected Output:

split('\n') with CRLF:   ['Row1\r', 'Row2\r', 'Row3']
splitlines() with CRLF:  ['Row1', 'Row2', 'Row3']

mixed_stream = "First line\nSecond line\r\nThird line"

lines_with_breaks = mixed_stream.splitlines(keepends=True)
print("With keepends=True:", lines_with_breaks)

# Reconstructing original text perfectly:
reconstructed = "".join(lines_with_breaks)
print("Reconstruction matches:", reconstructed == mixed_stream)

Expected Output:

With keepends=True: ['First line\n', 'Second line\r\n', 'Third line']
Reconstruction matches: True

When handling file uploads or multiline textarea submissions from varying operating systems, convert mixed line breaks to clean POSIX \n lines:

def normalize_line_endings(content: str) -> str:
    # splitlines() consumes \r, \n, and \r\n uniformly
    lines = content.splitlines()
    return "\n".join(lines) + ("\n" if content.endswith(("\n", "\r")) else "")

raw_payload = "Name: Alice\r\nRole: Admin\rDepartment: Engineering\nStatus: Active"
posix_text = normalize_line_endings(raw_payload)
print("Normalized output:\n", repr(posix_text))

Expected Output:

Normalized output:
 'Name: Alice\nRole: Admin\nDepartment: Engineering\nStatus: Active'

Splitting code snippets into numbered, syntax-aligned lines:

def format_code_block(code: str, start_num: int = 1) -> str:
    lines = code.splitlines()
    max_digits = len(str(start_num + len(lines)))
    formatted = []
    for idx, line in enumerate(lines, start=start_num):
        formatted.append(f"{idx:>{max_digits}} | {line}")
    return "\n".join(formatted)

snippet = """def add(a, b):
    # Sum two values
    return a + b"""

print(format_code_block(snippet))

Expected Output:

1 | def add(a, b):
2 |     # Sum two values
3 |     return a + b

Grouping multiline log records where indented lines belong to the previous header:

def parse_grouped_logs(log_text: str) -> list[dict[str, str]]:
    entries = []
    current_entry = None
    for line in log_text.splitlines():
        if not line.strip():
            continue
        if line.startswith((" ", "\t")):
            # Indented continuation line (stack trace)
            if current_entry:
                current_entry["details"].append(line.strip())
        else:
            if current_entry:
                entries.append(current_entry)
            current_entry = {"header": line, "details": []}
    if current_entry:
        entries.append(current_entry)
    return entries

raw_log = """2026-10-13 12:00:01 ERROR Connection failed
    at socket.connect() line 45
    at client.init() line 12
2026-10-13 12:00:02 INFO System healthy"""

logs = parse_grouped_logs(raw_log)
print("Parsed log entries:", len(logs))
print("First entry stack trace lines:", len(logs[0]["details"]))

Expected Output:

Parsed log entries: 2
First entry stack trace lines: 2

class LineProcessor:
    @staticmethod
    def get_clean_lines(text: str) -> list[str]:
        """Splits text and strips surrounding whitespace per line."""
        return [line.strip() for line in text.splitlines() if line.strip()]

    @staticmethod
    def reconstruct_lines(lines_with_breaks: list[str]) -> str:
        """Reassembles lines preserved via keepends=True."""
        return "".join(lines_with_breaks)

    @staticmethod
    def count_paragraphs(text: str) -> int:
        """Counts non-empty lines separated by universal line breaks."""
        return len([ln for ln in text.splitlines() if ln.strip()])


# ==========================================
# SELF-CHECKING UNIT ASSERTIONS
# ==========================================
processor = LineProcessor()

# 1. Empty string yields empty list
assert "".splitlines() == []
assert "".splitlines(keepends=True) == []

# 2. Trailing newline behavior (no spurious empty item)
assert "Hello\nWorld\n".splitlines() == ["Hello", "World"]
assert "Hello\nWorld\n".split("\n") == ["Hello", "World", ""]

# 3. Universal newlines: CRLF, CR, LF
mixed = "Line1\nLine2\r\nLine3\rLine4"
assert mixed.splitlines() == ["Line1", "Line2", "Line3", "Line4"]

# 4. keepends=True round-trip integrity
lines_kept = mixed.splitlines(keepends=True)
assert lines_kept == ["Line1\n", "Line2\r\n", "Line3\r", "Line4"]
assert processor.reconstruct_lines(lines_kept) == mixed

# 5. Unicode line separator (\u2028) support
unicode_lines = "Paragraph1\u2028Paragraph2"
assert unicode_lines.splitlines() == ["Paragraph1", "Paragraph2"]

# 6. Clean line filtering
doc = "  Alpha  \n\n   Beta   \n\n\n  Gamma  \n"
assert processor.get_clean_lines(doc) == ["Alpha", "Beta", "Gamma"]
assert processor.count_paragraphs(doc) == 3

print("Clean lines extracted: ", processor.get_clean_lines(doc))
print("Paragraphs counted:    ", processor.count_paragraphs(doc))
print("All str.splitlines() unit assertions passed successfully!")