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

Коротко . split() — встроенный метод строк в Python, который разбивает строку на список подстрок по заданному разделителю. Синтаксис: строка.split(sep, maxsplit). Без аргументов метод режет строку по пробельным символам и убирает лишние пробелы, с аргументом — по указанному символу или подстроке. Исходная строка не меняется, потому что строки в Python неизменяемы: метод возвращает новый список.

Зачем нужно делить строку

Данные почти всегда приходят к программисту в виде текста, и почти всегда этот текст надо разобрать на части.

Пользователь ввел «Иванов Иван Иванович» одной строкой, а вам нужны отдельно фамилия и имя. Из выгрузки пришла строка 2026-08-12,Ташкент,450000 — три значения, склеенные запятыми. В логе сервера дата, уровень ошибки и сообщение лежат в одной строке. В ссылке https://proweb.uz/ru/courses/python последний фрагмент после слэша — название страницы, и его нужно достать.

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

Что такое метод split в Python

split() — это метод строки. Он находит в тексте разделитель, разрезает строку в этих местах и возвращает список получившихся кусков.

text = "Python это просто"

parts = text.split()

print(parts)

# ['Python', 'это', 'просто']

Метод — это функция, которая принадлежит объекту и вызывается через точку. split() принадлежит строкам, поэтому пишется как text.split(), а не split(text).

Важная деталь, которую новички упускают: строки в Python неизменяемы, поэтому split() не меняет исходную строку. Он возвращает новый список, и результат надо куда-то сохранить.

text = "Python это просто"

text.split() # результат подсчитан и выброшен

print(text) # 'Python это просто' — строка та же

parts = text.split() # вот так правильно

Синтаксис и параметры split

Полная сигнатура метода выглядит так:

строка.split(sep=None, maxsplit=-1)

Оба параметра необязательные:

• sep — разделитель. Может быть одним символом или целой подстрокой. Если не указан или равен None, Python режет строку по любым пробельным символам: пробелу, табуляции \t, переносу строки \n.
• maxsplit — максимальное количество разрезов. По умолчанию -1, то есть без ограничений. Если задать положительное число, метод сделает ровно столько разрезов, а весь остаток строки положит в последний элемент списка.

Возвращает метод всегда список (list), даже если разделитель в строке ни разу не встретился — тогда в списке будет один элемент, вся исходная строка.

Как разделить строку по пробелам

Если вызвать метод без аргументов, Python режет строку по любым пробельным символам и ведет себя при этом умно: несколько пробелов подряд считает за один разделитель, а пробелы в начале и конце строки просто игнорирует.

text = " много лишних пробелов "

print(text.split())

# ['много', 'лишних', 'пробелов']

А теперь то же самое, но с явно указанным пробелом:

print(text.split(" "))

# ['', '', '', 'много', '', '', '', 'лишних', '', '', 'пробелов', '', '']

Разница принципиальная. split() без аргументов создан для разбора текста на слова и лишние пробелы прощает. split(" ") работает буквально: режет по каждому пробелу, и там, где два пробела стоят рядом, между ними появляется пустая строка. Табуляцию \t он при этом вообще не заметит.

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

Как разделить строку по запятой или другому символу

Чаще всего разделитель в данных не пробел, а запятая, точка с запятой, слэш или двоеточие. Тогда его передают первым аргументом.

csv_line = "2026-08-12,Ташкент,450000"

print(csv_line.split(","))

# ['2026-08-12', 'Ташкент', '450000']

date = "2026-08-12"

print(date.split("-"))

# ['2026', '08', '12']

path = "ru/courses/python"

print(path.split("/"))

# ['ru', 'courses', 'python']

Разделителем может быть не только один символ, но и целая подстрока. Это выручает, когда символ-разделитель встречается и внутри самих данных:

log = "INFO :: сервер запущен :: 08:00"

print(log.split(" :: "))

# ['INFO', 'сервер запущен', '08:00']

Двоеточие внутри времени 08:00 строку не разорвало, потому что разделителем указана вся подстрока :: вместе с пробелами.

Отдельно запомните: в отличие от пустого вызова, явный разделитель не схлопывает повторы. Каждое вхождение дает новый элемент, даже если он пустой.

data = "один,,два,,,три"

print(data.split(","))

# ['один', '', 'два', '', '', 'три']

Отфильтровать пустые элементы можно генератором списка: [x for x in data.split(",") if x].

Как ограничить количество разбиений через maxsplit

Второй аргумент говорит, сколько разрезов сделать максимум. Все, что осталось после последнего разреза, попадет в последний элемент целиком.

line = "ошибка:файл не найден:путь неверный"

print(line.split(":"))

# ['ошибка', 'файл не найден', 'путь неверный']

print(line.split(":", 1))

# ['ошибка', 'файл не найден:путь неверный']

Классическая задача для maxsplit — разбор строки вида «ключ: значение», где значение само может содержать разделитель:

setting = "адрес: Ташкент, проспект Бунедкор, 41"

key, value = setting.split(":", 1)

print(key) # адрес

print(value) # Ташкент, проспект Бунедкор, 41

Без maxsplit=1 вы получили бы список неизвестной длины, и распаковка в две переменные сломалась бы.

Полезно держать в голове формулу: количество элементов = maxsplit + 1, если разделителей в строке хватает. Это делает результат предсказуемым по длине, что критично при распаковке.

Как разделить строку с конца: метод rsplit

rsplit() работает так же, но считает разрезы с конца строки. Без параметра maxsplit разницы между ними нет вообще — она проявляется только вместе с ограничением.

path = "home/user/docs/report.txt"

print(path.split("/", 1))

# ['home', 'user/docs/report.txt']

print(path.rsplit("/", 1))

# ['home/user/docs', 'report.txt']

Типичный сценарий для rsplit — отделить имя файла от пути или расширение от имени:

filename = "otchet.za.avgust.xlsx"

name, ext = filename.rsplit(".", 1)

print(name) # otchet.za.avgust

print(ext) # xlsx

Обычный split(".", 1) вернул бы здесь otchet и za.avgust.xlsx — совсем не то, что нужно.

Как разбить многострочный текст: метод splitlines

Когда надо разделить текст на отдельные строки, у Python есть отдельный метод — splitlines(). Он удобнее, чем split("\n"), по двум причинам.

text = "первая\nвторая\nтретья\n"

print(text.split("\n"))

# ['первая', 'вторая', 'третья', '']

print(text.splitlines())

# ['первая', 'вторая', 'третья']

Во-первых, splitlines() не добавляет пустой элемент, если текст заканчивается переносом строки, — а текстовые файлы заканчиваются им почти всегда. Во-вторых, он понимает разные варианты переноса: в Windows строки разделяются парой \r\n, и split("\n") оставит в конце каждой строки невидимый символ \r, который потом сломает сравнение. splitlines() эту проблему решает сам.

Правило простое: для текста из файла или из многострочного поля ввода берите splitlines().

Когда нужен ровно один разрез: метод partition

Есть еще один метод, о котором новички обычно не знают, — partition(). Он режет строку по первому вхождению разделителя и всегда возвращает кортеж ровно из трех элементов: часть до разделителя, сам разделитель и часть после.

config = "PORT=8080"

key, sep, value = config.partition("=")

print(key) # PORT

print(value) # 8080

Главное его преимущество — предсказуемость. Если разделителя в строке нет, partition() все равно вернет три элемента, просто два последних будут пустыми:

print("простотекст".partition("="))

# ('простотекст', '', '')

А split("=") в этом случае вернет список из одного элемента, и распаковка в две переменные упадет с ошибкой. Поэтому там, где вы точно знаете, что разрез нужен один, partition() безопаснее. Есть и зеркальный вариант — rpartition(), который ищет разделитель с конца.

Чем отличаются split, rsplit и partition

Этот вопрос любят задавать на собеседованиях. Разница сводится к трем пунктам.

split() идет слева направо, возвращает список произвольной длины. Основной инструмент: разбор CSV-строк, логов, ответов API.

rsplit() идет справа налево, тоже возвращает список. Нужен, когда важен конец строки: расширение файла, последний сегмент пути. Без maxsplit ведет себя идентично split().

partition() делает ровно один разрез слева направо и возвращает кортеж из трех элементов, включая сам разделитель. Нужен для конфигов вида «ключ=значение» и везде, где важна гарантированная длина результата.

Как разделить строку по нескольким разделителям

Иногда разделителей в данных сразу несколько разных: где-то запятая, где-то точка с запятой, где-то пробел. Обычный split() принимает только один разделитель, поэтому здесь есть два подхода.

Первый и основной — модуль регулярных выражений:

import re

data = "яблоки, груши; сливы персики"

print(re.split(r"[,;\s]+", data))

# ['яблоки', 'груши', 'сливы', 'персики']

Запись [,;\s]+ означает «один или несколько символов из набора: запятая, точка с запятой, пробельный символ». Квадратные скобки задают набор, плюс после них схлопывает идущие подряд разделители в один.

Второй подход проще и годится, когда разделители заранее известны и их два-три: сначала заменить все на один через replace(), потом разделить обычным split().

data = "яблоки,груши;сливы"

data = data.replace(";", ",")

print(data.split(","))

# ['яблоки', 'груши', 'сливы']

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

Как собрать строку обратно: метод join

Рано или поздно список нужно склеить обратно в строку. Для этого есть join(), и записывается он непривычно: метод вызывается у разделителя, а список передается аргументом.

parts = ['2026', '08', '12']

print("-".join(parts))

# 2026-08-12

words = ['Python', 'это', 'просто']

print(" ".join(words))

# Python это просто

join() работает только со списком строк. Если внутри окажется число, Python выдаст TypeError — числа надо заранее превратить в строки, например через map(str, numbers).

Связка «split — обработка — join» — один из самых частых шаблонов при работе с текстом:

text = " курсы python в ташкенте "

clean = " ".join(text.split())

print(clean)

# 'курсы python в ташкенте'

Здесь split() разобрал строку на слова, попутно выбросив лишние пробелы, а join() собрал ее обратно уже аккуратно. Три строки кода вместо ручного перебора символов.

Как превратить результат split в числа

Самая частая логическая ошибка новичка: после split() в списке лежат строки, а не числа, даже если выглядят они как числа.

data = "10,20,30"

numbers = data.split(",")

print(numbers) # ['10', '20', '30']

print(numbers[0] + numbers[1]) # '1020' — склеивание, не сложение

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

numbers = [int(x) for x in data.split(",")]

print(sum(numbers)) # 60

Тот же результат дает встроенная функция map(), которую подробно разбирает отдельная статья блога:

numbers = list(map(int, data.split(",")))

Если данные пришли от пользователя или из файла, вокруг чисел вполне могут быть пробелы. Тогда добавьте strip(), который срезает пробелы по краям:

data = "10, 20 , 30"

numbers = [int(x.strip()) for x in data.split(",")]

print(numbers) # [10, 20, 30]

Как разделить строку посередине

split() не умеет делить строку на две равные части — это другая задача. Наивное решение через срез и len() разрезает текст прямо посреди слова:

s = "PROWEB это учебный центр в Ташкенте"

half = len(s) // 2

print(s[:half]) # PROWEB это учебн

print(s[half:]) # ый центр в Ташкенте

Чтобы делить по словам, сначала разбейте строку на слова, найдите середину списка, а потом соберите половины обратно через join():

s = "PROWEB это учебный центр в Ташкенте"

words = s.split()

middle = len(words) // 2

first = " ".join(words[:middle])

second = " ".join(words[middle:])

print(first) # PROWEB это учебный

print(second) # центр в Ташкенте

Типичные ошибки при работе со split

Пустой разделитель . В отличие от JavaScript, в Python нельзя разделить строку на отдельные символы через split("") — это вызовет ValueError: empty separator. Чтобы получить список символов, используйте list("abc"), что даст ['a', 'b', 'c'].

Вызов split не у строки . Метод есть только у строк. Если из базы или JSON пришло число или None, скрипт упадет с AttributeError: 'int' object has no attribute 'split'. Проверяйте тип или приводите к строке через str(). Та же ошибка возникает, если split() где-то выше уже применили и переменная стала списком.

Ловушка пустой строки . Разбиение пустой строки по разделителю вернет не пустой список, а список с одним пустым элементом: "".split(":") даст [''], и len() будет равен единице. Об это ломаются проверки вида «если данных нет».

Распаковка без гарантии длины . Такой код упадет, если элементов окажется не два:

name, surname = user_input.split()

# ValueError: not enough values to unpack

Безопаснее использовать maxsplit, partition() или проверять длину списка перед распаковкой.

Забытый результат . text.split() без присваивания не делает ничего полезного: исходная строка остается прежней.

Когда split не подходит

У метода есть граница применимости, и важно ее видеть.

Разбирать настоящий CSV-файл через split(",") можно только пока в данных нет запятых внутри значений. Строка "Ташкент, Узбекистан",450000 при таком подходе развалится неправильно, потому что split() ничего не знает про кавычки и экранирование. Для реальных таблиц в Python есть модуль csv и библиотека pandas.

По той же причине split() не годится для разбора HTML, JSON и XML: у них своя вложенная структура, и для каждого формата существует свой инструмент. А если правила разбиения сложные и зависят от контекста, вместо split() берите регулярные выражения.

Шпаргалка по разделению строк

• Разбить текст на слова — split() без аргументов
• Разделить по запятой, слэшу, двоеточию — split(",")
• Ограничить число разрезов — split(":", 1)
• Отрезать конец строки, например расширение файла — rsplit(".", 1)
• Разбить многострочный текст на строки — splitlines()
• Получить гарантированные три части по первому разделителю — partition("=")
• Разделить по нескольким разным разделителям — re.split(r"[,;\s]+", text)
• Разбить строку на отдельные символы — list(text)
• Собрать список обратно в строку — "-".join(parts)
• Убрать лишние пробелы внутри текста — " ".join(text.split())

Коротко о главном

split() превращает строку в список: без аргументов режет по пробелам и схлопывает лишние, с аргументом sep — по указанному символу или подстроке, а maxsplit ограничивает число разрезов и делает длину результата предсказуемой. Рядом стоит семейство близких методов: rsplit() считает с конца, splitlines() корректно разбивает многострочный текст, partition() всегда возвращает три элемента, re.split() справляется с несколькими разделителями сразу, а join() собирает список обратно в строку.

Две вещи, которые вызывают больше всего ошибок на старте: результат split() — это список строк, а не чисел, и исходная строка после вызова не меняется.

Работа со строками — базовый навык любого Python-разработчика: с нее начинается разбор данных, парсинг, автоматизация отчетов и написание ботов. Освоить язык с нуля до уровня реальных проектов можно на курсе Python в PROWEB — 8 месяцев, с 14 лет, с практикой и поддержкой в трудоустройстве. Если вы еще выбираете направление в IT, пройдите бесплатный IT-тест — он подскажет, что вам ближе.

Часто задаваемые вопросы

Что делает метод split в Python?

Разбивает строку на список подстрок по разделителю. Без аргументов режет по пробельным символам, с аргументом — по указанному символу или подстроке. Исходная строка при этом не меняется, метод возвращает новый список.

В чем разница между split() и split(" ")?

split() без аргументов считает несколько пробелов подряд за один разделитель, убирает пробелы по краям строки и обрабатывает табуляции и переносы строк. split(" ") режет буквально по каждому пробелу, поэтому между соседними пробелами появляются пустые строки, а табуляции он не заметит.

Как разделить строку на отдельные символы?

split("") в Python вызовет ошибку ValueError: empty separator. Чтобы получить список символов, используйте функцию list("текст").

Чем rsplit отличается от split?

rsplit() считает разрезы с конца строки. Без параметра maxsplit оба метода дают одинаковый результат, разница появляется только при ограничении числа разрезов. rsplit удобен, когда нужно отделить расширение файла или последний элемент пути.

Как разделить строку по нескольким разделителям?

Через модуль регулярных выражений: re.split(r"[,;\s]+", text) разобьет строку по запятым, точкам с запятой и пробелам одновременно. Если разделителей всего два-три и они известны заранее, можно сначала заменить их на один через replace(), а потом применить обычный split().

Как соединить список обратно в строку?

Методом join(), который вызывается у строки-разделителя: "-".join(['2026', '08', '12']) вернет 2026-08-12. Список должен состоять из строк, числа надо преобразовать заранее.

Почему после split числа складываются неправильно?

Потому что split() всегда возвращает список строк, даже если они выглядят как числа. Сложение двух строк дает склеивание, а не сумму. Преобразуйте элементы через int() или float().

Что вернет split для пустой строки?

Список с одним пустым элементом. Например, "".split(":") даст [''], а не пустой список, и длина такого списка равна единице. Этот крайний случай стоит учитывать в проверках.

Можно ли разбирать CSV-файл через split?

Только простые файлы без запятых внутри значений. Если значение содержит запятую и заключено в кавычки, split(",") разберет строку неверно. Для настоящих таблиц используйте модуль csv или библиотеку pandas.