Text processing

Enables extracting individual lines from a string without worrying about varied newline characters

Log analysis: parsing multi‑line log entries Configuration parsing: reading line‑separated config files

Data pipelines, command‑line utilities, web back‑ends that handle user‑submitted text, and any Python code that processes multi‑line strings

text.splitlines(keepends)

... .splitlines(...)

text: str – the source string; keepends: bool optional – whether to retain line‑break characters in the resulting list items

• for line in text.splitlines():
• read()
• strip()
• join()

• Using `text.split('\n')` – simpler but fails on Windows line endings
• using `re.split(r'\r?\n'
• text)` – more flexible but adds regex overhead

1. Forgetting to assign the result, so the split has no effect → data is unchanged. 2. Assuming `splitlines()` removes all newline characters, but with `keepends=True` it retains them → unexpected trailing characters. 3. Using `split('\n')` on Windows files, causing stray '\r' characters in lines → downstream parsing errors. 4. Expecting an empty string to yield a list with an empty element, but it returns [] → loop logic may skip processing. 5. Calling `splitlines()` on a bytes object without decoding first → TypeError.

`str.split('\n')` – splits only on '\n' and does not handle '\r\n'; `re.split(r'\r?\n', text)` – regex‑based split that can be customized further

Coming from JavaScript: using `str.split('\n')` may miss Windows line endings — Python’s `splitlines()` correctly handles '\r\n', '\r', and '\n' automatically.

• string methods
• text processing utilities
• line handling

1) Do not use `splitlines()` when you need to preserve the original file object’s iterator semantics (use `file.readlines()` instead). 2) The `keepends` flag adds a small memory overhead because each line retains its newline characters. 3) An empty input string yields an empty list, not a list containing an empty string – code must handle this edge case.

Correct use of `splitlines()` lets developers reliably break down any text into lines, simplifying parsing, analysis, and transformation pipelines while avoiding bugs caused by inconsistent newline handling.

Think of `splitlines()` as a paper cutter that slices a sheet of text into individual strips without leaving any cutter marks unless you ask it to keep the marks.

The default `keepends=False` strips all line‑break characters; setting it to `True` retains them, which can be useful for reconstructing the original text later.