Efficiently Parsing Comma-Separated Pairs in Python with List Comprehensions and Generators

Learn how to parse space-delimited comma-separated pairs in Python using list comprehensions, assignment and generator expressions—no repeated split() calls.

Parsing pairs of comma-separated values into a list of string tuples is a common micro-task, but it’s easy to either write a verbose loop or fall into a less efficient one-liner that repeats work. Below is a compact, readable approach that avoids redundant split() calls, adds a simple sanity check when needed, and scales to line-by-line file processing without unnecessary memory overhead.

Problem

Suppose the input comes as space-separated tokens, each a pair of values joined by a comma:

805i,9430 3261i,9418 3950i,9415 4581i,4584i 4729i,9421 6785i,9433 8632i,9434 9391i,9393i

The goal is to read these into a list of pairs of strings using a one-liner list comprehension, but without calling split() twice per token.

Baseline code showing the issue

This straightforward loop does the job for a single line, but it’s verbose if you prefer a comprehension:

line_text = line.strip()
fields = line_text.split()

pairs_list = []
for tok in fields:
    left, right = tok.split(',')
    pairs_list.append((left, right))

What’s really going on

The tempting one-liner that indexes split() results twice repeats the split operation per element, which is unnecessary. The aim is to keep code compact while doing the split once per token. There are a few clean ways to express this: use an assignment expression to cache the split result, or use a nested generator expression to produce split results once and then consume them. If you know there are exactly two values per token, tuple unpacking keeps it concise. When processing real input, a minimal sanity check helps ensure only valid pairs are captured, and in such a case it’s clearer to step away from a single line.

Solution

Using an assignment expression to bind the split result exactly once:

pairs_list = [(parts[0], parts[1]) for cell in fields if (parts := cell.split(','))]

Using a nested generator expression to generate the split only once per token:

pairs_list = [(grp[0], grp[1]) for grp in (cell.split(',') for cell in fields)]

If you know every token contains exactly two comma-separated pieces, tuple unpacking is the most direct form:

pairs_list = [(a, b) for a, b in (cell.split(',') for cell in fields)]

For a final application that reads from a file and discards malformed entries, it’s clearer to avoid cramming everything into one line. Generator variables help structure the work efficiently and avoid holding intermediate containers in memory:

with open("data.text") as fh:
    chunks = (token.split(',') for ln in fh for token in ln.split())
    result = [tuple(chunk) for chunk in chunks if len(chunk) == 2]

print(result)

If the input may contain more than two comma-separated items per token, but you only want the first two, slicing makes that intent explicit:

pairs_list = [tuple(seg.split(',')[:2]) for seg in fields]

Why this matters

These patterns avoid repeated work, keep the code compact, and remain readable for routine parsing tasks. Assignment expressions or a nested generator expression let you split each token once and reuse the result. When you’re streaming from a file, generator variables let you validate and transform data without allocating unnecessary intermediate lists. Adding a small sanity check like len(...) == 2 makes the pipeline more robust without sacrificing clarity.

Takeaways

Prefer a single split per token and choose a form that matches your guarantees: assignment expressions or nested generators if you need the split result as a value, and tuple unpacking if each token is guaranteed to be a pair. When working with real-world inputs, include a simple length check, and don’t hesitate to expand to a couple of lines for maintainability. The result is succinct, efficient code that’s easy to reason about and scale.