split: разобрать строку

До сих пор мы работали со строкой как с целым. Но данные часто приходят пачкой в одной строке: CSV-запись «имя,город,сумма», строка лога через точку с запятой, время через двоеточия. Метод split разбивает строку на части по разделителю и возвращает их списком. Это обратная пара к методу join из урока 10: split собирает из строки список, join — из списка строку.

Сценарий: дата приходит строкой

Из внешней системы дата приходит строкой «2026-03-14», и её надо превратить в отдельные год, месяц и день. Строка не содержит этих значений — она их кодирует разделителем. Split как раз и есть операция «возьми текст между разделителями», и для дат, кодов и CSV-записей она подходит идеально.

d = '2026-03-14'
parts = d.split('-')
print(parts)
print(len(parts))
print(parts[0])

['2026', '03', '14']
3
2026

Три части — значит, три элемента списка, а нумерация элементов, как и у строк, с нуля. Первая часть — год. Распаковать прямо в переменные можно, если их ровно столько же, сколько частей: year, month, day = d.split('-').

split по разделителю

Схема: s.split(разделитель) — режь строку в каждом месте, где встретился разделитель, и отдай куски списком. Разложим CSV-строку:

order = 'имя,город,сумма'
parts = order.split(',')
print(parts)
print(type(parts))

['имя', 'город', 'сумма']
<class 'list'>

Результат — не строка, а список (тип list): упорядоченная коллекция значений. С элементами списка работают уже знакомые по срезам урока 2 индексы — первый элемент под номером ноль:

parts = 'Аня,Пермь,1250'.split(',')
print(parts[0])
print(parts[2])
print(len(parts))

Аня
1250
3

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

log = '2026-03-14;админ;вход'
print(log.split(';'))
print('14:30:00'.split(':'))

['2026-03-14', 'админ', 'вход']
['14', '30', '00']

split без аргумента: любые пробелы

Если разделитель не указать вовсе, split работает в особом режиме: режет по любым пробельным символам — обычным пробелам, табуляциям, переводам строк — и подряд идущие пробелы считает одним разделителем:

review = '  Доставка   быстрая,   но   коробка помята  '
print(review.split())

['Доставка', 'быстрая,', 'но', 'коробка', 'помята']

Края строки очистились сами, двойные пробелы не оставили пустых кусков — это самый безопасный способ посчитать слова: len(review.split()). Сравните с явным разделителем-пробелом:

line = 'а  б'
print(line.split(' '))
print(line.split())

['а', '', 'б']
['а', 'б']

try:
    print('кот'.split(''))
except ValueError as e:
    print('Ошибка:', e)

Ошибка: empty separator

Чего split не умеет

Split режет по символам и ничего не знает про кавычки и запятые внутри кавычек. Для CSV, где название компании может содержать запятую, это становится настоящей проблемой: строка развалится не там, где надо.

line = 'ООО "Ромашка", 2026'
print(line.split(','))

['ООО "Ромашка"', ' 2026']

Здесь повезло: запятая оказалась внутри кавычек, но не внутри названия. Стоит появиться «Ромашка, ООО» — и получится три части вместо двух. Для настоящего CSV есть отдельный модуль csv с методом csv.reader, который понимает кавычки, экранирование и переводы строк. Он медленнее наивного split, но даёт правильный результат.

maxsplit: ограничить число разрезов

Второй аргумент — maxsplit — разрешает не больше указанного числа разрезов. Спасает, когда разделитель встречается внутри данных, как запятая в адресе:

line = 'Пётр, Петров, Москва, ул. Ленина, 5'
print(line.split(',', 2))
print(line.split(',', 1))

['Пётр', ' Петров', ' Москва, ул. Ленина, 5']
['Пётр', ' Петров, Москва, ул. Ленина, 5']

С лимитом 2 строка разрезалась дважды, а весь хвост — адрес с его запятыми — остался одним куском. Обратите внимание: пробел после запятой остался в начале куска; убрать его можно strip из урока 6 или, для всей пачки, аккуратнее задать данные.

splitlines: разбор по строкам

Для многострочного текста есть отдельный метод — splitlines(): он делит текст по переводам строк и возвращает список строк:

report = 'Первая строка\nВторая строка\nТретья'
print(report.splitlines())
print(report.split('\n'))

['Первая строка', 'Вторая строка', 'Третья']
['Первая строка', 'Вторая строка', 'Третья']

Здесь оба способа дали одинаковый список. Разница проявляется, когда текст заканчивается переводом строки: splitlines не создаёт пустого хвоста, а split('\n') — создаёт:

multiline = 'а\nб\n'
print(multiline.splitlines())
print(multiline.split('\n'))

['а', 'б']
['а', 'б', '']

Разбор заказа: CSV в три переменные

Соберём приём целиком. CSV-строка заказа режется на части, и части удобно сразу разложить в отдельные переменные — Python распакует список, если переменных ровно столько, сколько частей:

csv_line = 'Анна,Казань,2450.50'
name, city, total = csv_line.split(',')
print(name, '-', city, '-', total)

Анна - Казань - 2450.50

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

csv_line = 'Анна,Казань,2450.50,доставка'
try:
    name, city, total = csv_line.split(',')
except ValueError as e:
    print('Ошибка:', e)

Ошибка: too many values to unpack (expected 3)

Ещё один штрих: сумма пришла строкой — '2450.50'. Считать с ней можно только после превращения в число, например float(total). Иначе плюс сложит тексты: '2450.50' + '100' даст '2450.50100' — помните урок 1 про конкатенацию.

Split и числа

Разобрав строку, получают части — а части остаются строками. Дальше с ними почти всегда нужно считать, и вот тут возникает типовая ошибка: отсортировать цены, сложенные как текст, получится неправильно, потому что «1000» и «250» сравнятся как символы, а не как числа.

prices = ['1250.50', '980', '2400']
nums = [float(p) for p in prices]
print(min(nums))
print(max(nums))

980.0
2400.0

Сначала каждая часть превращается в число, потом список чисел сравнивается как числа. Порядок операций тут принципиален: если сортировать строки, девятьсот окажутся больше двухтысячных, потому что «9» больше «2».

Карточка разборов строки

Обратную операцию — склеить список обратно в строку с любым разделителем — делает join. Ему и посвящён урок 10.

Мини-практика: заказы из списка строк

Три заказа пришли одной строкой каждый: код, товар, количество. Разберите их по запятой, переведите количество в число и выведите по строке на заказ в формате «код: количество шт.».

orders = ['ORD-1,чай,2', 'ORD-2,кофе,1', 'ORD-3,сыр,3']
for order in orders:
    code, item, qty = order.split(',')
    print(f'{code}: {int(qty)} шт.')

ORD-1: 2 шт.
ORD-2: 1 шт.
ORD-3: 3 шт.

Здесь встретились сразу три приёма: split разбирает строку на части, распаковка раскладывает их в три переменные, а int превращает количество из текста в число. Количество здесь выводится, но в реальной задаче с ним сразу считают — и если бы строки сортировали как текст, порядок был бы неверным.

Как разделить строку в Python: split

split — обратная операция к join: берёт строку и режет её на список по разделителю. Разделитель можно задать явно, а можно не задавать — тогда Python режет по любой последовательности пробельных символов и отбрасывает пустые куски. Разница между этими двумя режимами — источник половины багов при разборе CSV и логов.

raw = '  чай  80  кофе  150  '
parts = raw.split()
print(parts)
print(len(parts))

['чай', '80', 'кофе', '150']
4

Без разделителя split режет по пробелам и их комбинациям, а пустые куски выбрасывает. Именно выбрасывает: ' чай 80 '.split() даст три слова, а не пять с пустыми. Это удобно для текста и опасно для структурированных данных — в CSV пустое поле между двумя запятыми это значение, а не мусор.

maxsplit: разрезать не всё

Второй аргумент split ограничивает количество разрезов. Это то, что нужно, когда разделитель встречается внутри значения: в дате 2026-03-14 дефис встречается дважды, а разумно разрубить строку только один раз.

line = 'name=anna;city=kazan;age=30'
print(line.split(';'))
print(line.split(';', 1))
print(line.split('='))

['name=anna', 'city=kazan', 'age=30']
['name=anna', 'city=kazan;age=30']
['name', 'anna;city', 'kazan;age', '30']

Третий вывод показывает, почему split без указания разделителя опасен для структурированных данных: = встречается трижды, и куски получились не те, что ожидались. Правило простое: если в данных есть разделитель, всегда указывайте его явно. split() без аргументов — только для свободного текста.

splitlines: многострочный текст по строкам

Отдельный метод — splitlines(). Он режет текст по переводам строк и не создаёт пустых элементов в конце, где файл обычно заканчивается переводом строки. Разница с split('\n') видна на файлах Windows: там перевод строки — это два символа, \r\n, и обычный split('\n') оставит в кусках висящий \r.

log = '''2026-03-14 INFO старт
2026-03-14 ERROR диск
2026-03-14 INFO стоп'''
rows = log.splitlines()
print(len(rows))
print(rows[1])
print(rows[1].split(' ', 2))

3
2026-03-14 ERROR диск
['2026-03-14', 'ERROR', 'диск']

Третья строка — комбинация, которой пользуются постоянно: сначала режем лог на строки, потом строку на поля. Обратите внимание на split(' ', 2) — максимум два разреза, чтобы в поле «сообщение» попал весь остаток строки вместе с пробелами. Без ограничения сообщение развалилось бы на слова.

rsplit стоит знать рядом с split: он режет справа налево и полезен, когда разделитель может быть внутри последнего поля. Классика — разбор пути файла или лога: путь разрубают rsplit('/', 1), чтобы отделить имя файла от каталога, а не наоборот.

path = '/home/anna/report.txt'
print(path.split('/'))
print([p for p in path.split('/') if p])

['', 'home', 'anna', 'report.txt']
['home', 'anna', 'report.txt']

Первая строка показывает особенность split с разделителем: пустые куски остаются, и ведущий слэш даёт пустой элемент в начале. Отфильтровать их — работа [p for p in parts if p]. Симметричная операция — os.path.split, но раздел про строки, а не про файловую систему; в реальном коде для путей я бы всё-таки взял pathlib.

И последнее. split возвращает список — изменяемый. Попытка сделать s.split(',').sort() ничего не даст: метод sort у списка не возвращает новый список, а меняет его на месте и возвращает None. Правильно — sorted(s.split(',')). Мелочь, но на неё спотыкаются даже те, кто знает методы строк наизусть.

split режет строку по разделителю и возвращает список частей; без аргумента он делит текст на слова по пробелам, а splitlines — на строки по переносам.