How does str.split() with no argument differ from str.split(' ')?

### Two methods wearing one name `str.split` has two genuinely different behaviours depending on whether you pass a separator, and the difference is not a detail — it changes the length of the result. **No argument (or `None`): whitespace mode.** Any *run* of whitespace acts as a single separator, and whitespace at the start and end of the string is ignored entirely. Whitespace here means spaces, tabs, newlines, carriage returns, form feeds, vertical tabs and the other characters Unicode calls whitespace — you are not limited to the ASCII space. The result can never contain an empty string. **An explicit separator: exact mode.** Every single occurrence of the separator delimits a field, adjacent separators produce empty fields, and a leading or trailing separator produces an empty field at that end. The separator may be several characters long and is matched as an exact substring; passing `''` raises `ValueError`. ```python ' a b '.split() # ['a', 'b'] ' a b '.split(' ') # ['', '', 'a', '', 'b', '', ''] 'a\t\nb'.split() # ['a', 'b'] 'a,,b'.split(',') # ['a', '', 'b'] ``` The empty string is the cleanest illustration of the split in semantics: `''.split()` returns `[]` — there were no tokens — while `''.split(',')` returns `['']` — there was one field and it was empty. Code that assumes a non-empty list after splitting a possibly-empty line is relying on which of the two it called. ### Choosing between them The rule follows from what an empty field *means* in your data. - **Free text, human-entered, ragged spacing** — command output, a log line, a pasted description. Use `split()`. Runs of spaces are noise, and collapsing them is the behaviour you want. - **Structured records where position matters** — a delimited feed, a config line, anything where a missing value is still a value. Use an explicit separator. `'1120,,blue'` must yield three fields, the middle one empty; whitespace mode would silently reshape the record. Getting this backwards is a real defect in an ingest path: splitting a delimited record on whitespace silently merges empty columns and shifts every later field left by one, which then lands in the wrong column downstream rather than raising anything. ### `maxsplit`, `rsplit`, and `splitlines` `maxsplit` caps how many splits happen; the remainder stays whole in the last element. `'a=b=c'.split('=', 1)` gives `['a', 'b=c']` — exactly right for a `key=value` line whose value may itself contain the delimiter. `str.rsplit` is the same method counting from the right, which is how you take the last field: `'a,b,c'.rsplit(',', 1)` gives `['a,b', 'c']`. In whitespace mode `maxsplit` still collapses runs. `str.splitlines` is a separate method for text, not a `split('\n')` alias: it splits on the whole family of line boundaries — `\n`, `\r`, `\r\n` and several Unicode separators — and by default does not leave a trailing empty element for a file ending in a newline. `'a\n'.splitlines()` is `['a']` while `'a\n'.split('\n')` is `['a', '']`. ### `partition` when there is exactly one delimiter `str.partition(sep)` always returns a three-tuple: everything before the first separator, the separator itself, and everything after. When the separator is absent you get `(whole_string, '', '')` — still three elements. That fixed shape is why it beats `split(sep, 1)` for parsing: you can unpack it unconditionally. ```python key, sep, value = line.partition('=') if not sep: raise ValueError(f'missing = in {line!r}') ``` With `split('=', 1)` the same code needs a length check first, because a line without a delimiter yields a one-element list and the unpack raises `ValueError`. `str.rpartition` splits at the **last** occurrence, which is the tool for pulling a trailing segment off an identifier. A subtle point worth having ready: `partition` distinguishes "the separator was present with an empty right-hand side" from "the separator was absent", because `sep` is `'='` in the first case and `''` in the second. A `split`-based parser has to reconstruct that distinction from the list length. ### Interview framing The question is a mechanics probe: an interviewer asking it wants to hear that the no-argument form is a distinct mode, not a default separator of `' '`. Reach for the empty-string case as your proof, then show judgement by naming which mode you would use for a ragged log line versus a delimited record, and mention `partition` as the unpack-safe option for single-delimiter parsing.