Как парсить пары значений, разделённые запятой, в Python без лишних split

Как превратить токены a,b в список пар строк в Python: однострочные list comprehension без лишних split, оператор :=, генераторы и чтение файла потоками.

Разбор пар значений, разделённых запятыми, в список строковых кортежей — типичная микро‑задача, но легко либо написать многословный цикл, либо скатиться к менее эффективному однострочнику, который дублирует работу. Ниже — компактный и понятный подход, который избегает лишних вызовов split(), при необходимости добавляет простой контроль корректности и масштабируется до построчной обработки файлов без лишних накладных расходов по памяти.

Проблема

Предположим, что входные данные приходят как разделённые пробелами токены, каждый из которых — это пара значений, соединённых запятой:

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

Нужно считать их в список пар строк с помощью однострочного list comprehension, но не вызывать split() дважды для каждого токена.

Базовый код, демонстрирующий проблему

Этот прямолинейный цикл справляется с одной строкой, но выглядит многословно, если вы предпочитаете comprehension:

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

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

Что здесь на самом деле происходит

Заманчивый однострочник, который дважды индексирует результат split(), повторяет операцию разделения для каждого элемента — это излишне. Задача — сохранить код компактным, выполняя split ровно один раз на токен. Есть несколько чистых способов: использовать выражение присваивания, чтобы закешировать результат split, или вложенное генераторное выражение, которое порождает результат один раз, а затем потребляется. Если вы уверены, что в каждом токене ровно два значения, распаковка кортежа делает запись лаконичной. При обработке реальных данных минимальная проверка здравого смысла помогает отфильтровать только корректные пары — и в таком случае понятнее выйти за рамки одной строки.

Решение

Использование выражения присваивания, чтобы связать результат split ровно один раз:

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

Вариант с вложенным генератором, который делит токен лишь однажды:

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

Если каждый токен точно содержит две подстроки, разделённые запятой, распаковка — самый прямой путь:

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

В финальном варианте, который читает из файла и отбрасывает некорректные записи, лучше не пытаться уместить всё в одну строку. Промежуточные генераторы помогают организовать работу эффективно и не держать лишние контейнеры в памяти:

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)

Если в токене может быть больше двух элементов, разделённых запятыми, а нужны только первые два, срез явно выражает это намерение:

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

Почему это важно

Эти приёмы избегают повторной работы, держат код компактным и при этом читаемым для повседневного парсинга. Выражения присваивания или вложенный генератор позволяют разделять каждый токен единожды и переиспользовать результат. При потоковом чтении из файла генераторы дают возможность валидировать и преобразовывать данные без лишних промежуточных списков. Небольшая проверка вроде len(...) == 2 делает конвейер устойчивее, не жертвуя ясностью.

Выводы

Предпочитайте один split на токен и выбирайте форму под ваши гарантии: выражение присваивания или вложенный генератор — когда нужен сам результат split, и распаковка — если каждый токен гарантированно пара. В реальных данных добавляйте простую проверку длины и не стесняйтесь развернуть решение в пару строк ради поддерживаемости. В итоге получается краткий, эффективный код, которым легко оперировать и масштабировать.