Методы строк в Python: count, split, join и partition

Обновлено: 9 сентября 2026 года

В этой части разберём методы:

count()
split()
rsplit()
splitlines()
join()
partition()
rpartition()

Они используются для поиска частей строки, разбиения текста и обратной сборки строк.

`count()`

1. Подсчёт количества вхождений

Метод:

count()

возвращает количество вхождений указанной подстроки.

Например:

text = 'banana'

print(text.count('a'))

Результат:

Метод всегда возвращает объект класса:

int

Если ничего не найдено:

text = 'banana'

print(text.count('x'))

Результат:

2. Можно искать не только один символ

Искомая подстрока может состоять из нескольких символов:

text = 'Python is great. Python is popular.'

print(text.count('Python'))

Результат:

Можно искать и более длинный фрагмент:

text = 'Python backend | Python backend | SQL'

print(text.count('Python backend'))

Результат:

count() чувствителен к регистру:

text = 'Python python PYTHON'

print(text.count('Python'))

Результат:

`start` и `end`

3. Ограничение области поиска

Метод позволяет указать:

text.count(sub, start, end)

Границы работают аналогично срезам.

Например:

text = 'Python Python Python'

print(text.count('Python', 7))

Поиск начинается с индекса 7.

Можно ограничить его с двух сторон:

print(text.count('Python', 7, 13))

start включается в область поиска, а end работает как невключительная правая граница. Официальная документация описывает их именно как границы среза.

Вхождения без пересечения

4. `count()` не считает пересекающиеся совпадения

text = 'AAAAA'

print(text.count('AA'))

Результат:

Можно представить поиск так:

AAAAA
^^     → первое совпадение
  ^^   → второе совпадение

Последняя A остаётся без пары.

Варианты со смещением на один символ:

 AAAA
 ^^

уже пересекались бы с предыдущими совпадениями, а count() считает только непересекающиеся вхождения.

Небольшой пример полиморфизма

5. Одинаковая операция у разных классов

Название:

count()

встречается не только у строк.

Например, у списка:

numbers = [10, 20, 10, 30, 10]

print(numbers.count(10))

Результат:

У кортежа:

statuses = ('ok', 'error', 'ok', 'ok')

print(statuses.count('ok'))

Результат:

У строки:

text = 'banana'

print(text.count('a'))

Результат:

Разные классы имеют методы с одинаковым названием и похожим назначением: посчитать количество вхождений.

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

Позже при изучении ООП мы разберём полиморфизм подробнее.

6. Пример из транспортной системы

Представим разные классы транспорта:

Truck
CargoShip
CargoPlane

Каждый транспорт устроен по-разному, но у каждого может существовать операция:

refuel()

Например:

truck.refuel()
ship.refuel()
plane.refuel()

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

refuel

Такой единый интерфейс делает код понятнее: одинаковые по смыслу операции стараются называть одинаково.

`split()`

7. Разбиение строки

Метод:

split()

разбивает строку и возвращает:

list

Например:

text = 'Python SQL Django'

result = text.split()

print(result)

Результат:

['Python', 'SQL', 'Django']

8. Знаки препинания сами по себе не удаляются

text = 'Python, SQL and Django.'

print(text.split())

Результат:

['Python,', 'SQL', 'and', 'Django.']

Запятая осталась частью:

'Python,'

а точка:

'Django.'

Обычный split() разделяет строку, но не выполняет полноценную очистку текста от знаков препинания.

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

`sep`

9. Собственный разделитель

В split() можно передать строку-разделитель:

text = 'Python,SQL,Django'

print(text.split(','))

Результат:

['Python', 'SQL', 'Django']

Теперь разбиение происходит именно по:

Сам разделитель в результирующем списке не сохраняется.

10. Разделителем может быть несколько символов

text = 'Python<>SQL<>Django'

print(text.split('<>'))

Результат:

['Python', 'SQL', 'Django']

Разделителем может быть даже целое слово или другой фрагмент:

text = 'PythonANDSQLANDDjango'

print(text.split('AND'))

Результат:

['Python', 'SQL', 'Django']

split() воспринимает переданную строку как один конкретный разделитель.

`split()` без разделителя

11. Пробельные символы

Поведение:

text.split()

особенное.

Возьмём строку:

text = 'Python   SQL\tDjango\nFastAPI'

Здесь есть:

несколько обычных пробелов;
\t — табуляция;
\n — перенос строки.

Вызовем:

print(text.split())

Результат:

['Python', 'SQL', 'Django', 'FastAPI']

Когда sep не указан или равен None, последовательности пробельных символов воспринимаются как один разделитель. В начале и конце результата также не создаются пустые строки из-за пробелов.

`split(' ')`

12. Явный пробел работает иначе

Теперь передадим обычный пробел:

text = 'Python   SQL\tDjango\nFastAPI'

print(text.split(' '))

Получим результат примерно такого вида:

['Python', '', '', 'SQL\tDjango\nFastAPI']

Теперь разделитель — конкретно один символ пробела:

' '

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

А:

\t
\n

разделителями уже не являются и остаются внутри элемента.

Официальная документация отдельно подчёркивает это различие: при явно заданном sep последовательные разделители не объединяются.

`maxsplit`

13. Ограничение количества разбиений

Метод split() принимает параметр:

maxsplit

Он указывает максимальное количество разбиений.

text = 'Python SQL Django FastAPI'

print(text.split(maxsplit=2))

Результат:

['Python', 'SQL', 'Django FastAPI']

Произошло только два разбиения:

Python | SQL | Django FastAPI

Поэтому максимальное количество элементов результата:

maxsplit + 1

При maxsplit=2 мы можем получить максимум три элемента.

14. `maxsplit` вместе с `sep`

Можно написать:

text = 'Python,SQL,Django,FastAPI'

print(text.split(',', 2))

или:

print(
    text.split(
        ',',
        maxsplit=2,
    )
)

Результат:

['Python', 'SQL', 'Django,FastAPI']

`rsplit()`

15. Разбиение справа

Метод:

rsplit()

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

Например:

path = 'project/src/api/main.py'

Обычный split():

print(path.split('/', maxsplit=1))

Результат:

['project', 'src/api/main.py']

А:

print(path.rsplit('/', maxsplit=1))

Результат:

['project/src/api', 'main.py']

rsplit() особенно полезен, когда нас интересует конец строки.

16. Без ограничения результат обычно совпадает

text = 'Python SQL Django'

print(text.split())
print(text.rsplit())

Оба метода вернут:

['Python', 'SQL', 'Django']

Если нужно выполнить все возможные разбиения, направление не влияет на конечный результат.

Поэтому главное практическое применение rsplit() появляется вместе с:

maxsplit

когда нужно ограничить количество разбиений именно с правой стороны.

`splitlines()`

17. Разбиение текста на строки

Метод:

splitlines()

предназначен специально для разбиения текста по границам строк.

text = 'Python\nSQL\nDjango'

print(text.splitlines())

Результат:

['Python', 'SQL', 'Django']

Это особенно полезно при работе:

с файлами;
с ответами API;
с результатами парсинга;
с текстовыми данными из разных систем.

18. `splitlines()` понимает разные границы строк

Метод работает не только с:

\n

Он распознаёт следующие границы строк:

\n       Line Feed
\r       Carriage Return
\r\n     Carriage Return + Line Feed
\v       Line Tabulation
\f       Form Feed
\x1c     File Separator
\x1d     Group Separator
\x1e     Record Separator
\x85     Next Line
\u2028   Line Separator
\u2029   Paragraph Separator

То есть splitlines() предназначен именно для обработки различных способов обозначения границ строк в текстовых данных.

`split('\n')` и `splitlines()`

19. Простая строка

В простом случае:

text = 'Python\nSQL\nDjango'

эти выражения дадут похожий результат:

text.split('\n')

и:

text.splitlines()

Но это не полностью одинаковые операции.

20. Перенос в конце строки

text = 'Python\nSQL\n'

Вызов:

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

даст:

['Python', 'SQL', '']

Потому что после последнего разделителя остаётся пустая часть.

А:

print(text.splitlines())

даст:

['Python', 'SQL']

Последний перенос строки не создаёт дополнительную пустую строку.

Это одно из важных отличий этих методов.

`keepends`

21. Сохранение символов переноса

По умолчанию splitlines() удаляет границы строк.

Но можно написать:

splitlines(keepends=True)

Например:

text = 'Python\nSQL\r\nDjango'

lines = text.splitlines(keepends=True)

print(lines)

Получим:

['Python\n', 'SQL\r\n', 'Django']

Теперь переносы строк сохранились внутри элементов.

22. Зачем сохранять переносы

Предположим, программа получила текст:

text = 'first\r\nsecond\nthird'

Здесь используются разные границы строк:

\r\n
\n

Если написать:

lines = text.splitlines(keepends=True)

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

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

`join()`

23. Сборка строк

join() выполняет задачу, противоположную разбиению: объединяет несколько строк в одну.

technologies = [
    'Python',
    'SQL',
    'Django',
]

result = ' '.join(technologies)

print(result)

Результат:

Python SQL Django

24. Почему `join()` вызывается от разделителя

Синтаксис:

separator.join(iterable)

В нашем примере:

' '.join(technologies)

строка:

' '

является разделителем.

Она будет вставлена между элементами переданного итерируемого объекта. Именно строка, от которой вызывается join(), определяет разделитель.

Разные разделители

25. Пробел

words = ['Python', 'SQL', 'Django']

print(' '.join(words))

Результат:

Python SQL Django

26. Запятая

print(', '.join(words))

Результат:

Python, SQL, Django

27. Другой набор символов

print(' | '.join(words))

Результат:

Python | SQL | Django

28. Пустая строка

parts = ['Py', 'th', 'on']

print(''.join(parts))

Результат:

Python

Если разделитель:

''

между элементами ничего не добавляется.

Разделитель можно сохранить в переменную

29. Обычный объект строки

Необязательно писать строковый литерал непосредственно перед .join():

technologies = (
    'Python',
    'SQL',
    'Django',
)

separator = ' -> '

result = separator.join(technologies)

print(result)

Результат:

Python -> SQL -> Django

separator — обычная переменная, ссылающаяся на объект str, поэтому от неё можно вызвать строковый метод.

`join()` и кортеж

30. Не только список

join() принимает итерируемый объект со строками.

Например, кортеж:

cities = (
    'Tbilisi',
    'Batumi',
    'Kutaisi',
)

print(' | '.join(cities))

Результат:

Tbilisi | Batumi | Kutaisi

Метод работает и с другими итерируемыми объектами, которые мы будем изучать позже.

При этом каждый элемент должен быть строкой. Если внутри окажется, например, int, возникнет TypeError.

Например:

values = ['Python', 10, 'SQL']

' '.join(values)

приведёт к ошибке.

Строка тоже является итерируемым объектом

31. `join()` со строкой

Передадим в join() другую строку:

word = 'banana'

print('.'.join(word))

Результат:

b.a.n.a.n.a

Строка итерируема по своим символам, поэтому разделитель вставляется между каждым символом.

Другой пример:

print('-'.join('Python'))

Результат:

P-y-t-h-o-n

Такой пример также используется в официальной документации Python.

Связка `split()` + `join()`

32. Разобрать → обработать → собрать

Эти два метода часто используются вместе.

text = 'Python SQL Django'

words = text.split()

result = ' | '.join(words)

print(result)

Результат:

Python | SQL | Django

Логика:

строка
↓
split()
↓
список строк
↓
какая-то обработка
↓
join()
↓
новая строка

Это очень распространённый алгоритм работы с текстом.

Удаление лишних пробельных символов

33. Нормализация пробелов

text = '   Python     SQL   Django   '

Сначала:

words = text.split()

print(words)

Получаем:

['Python', 'SQL', 'Django']

Затем:

result = ' '.join(words)

print(result)

Результат:

Python SQL Django

Таким способом можно:

убрать пробелы в начале;
убрать пробелы в конце;
заменить несколько пробельных разделителей одним обычным пробелом.

Короткая запись:

result = ' '.join(text.split())

Когда количество пробелов нужно сохранить

34. Явный разделитель

Предположим:

text = 'Python   SQL'

Если написать:

parts = text.split(' ')

print(parts)

Получим:

['Python', '', '', 'SQL']

Пустые строки сохраняют информацию о нескольких последовательных пробелах.

Теперь:

result = ' '.join(parts)

print(result)

получим исходную строку:

Python   SQL

То есть выбор между:

split()

и:

split(' ')

зависит от задачи.

Если лишние пробельные символы нужно убрать — используется обычный:

split()

Если конкретные пробелы важны как разделители и их структуру нужно сохранить — явный:

split(' ')

может быть подходящим вариантом.

`partition()`

35. Разделение на три части

Метод:

partition()

разделяет строку по первому найденному вхождению разделителя и всегда возвращает кортеж из трёх элементов:

часть до разделителя
сам разделитель
часть после разделителя

Например:

email = 'user@example.com'

result = email.partition('@')

print(result)

Результат:

('user', '@', 'example.com')

Разделитель:

не исчезает.

36. Практический пример

Допустим, получили строку:

header = 'Content-Type: application/json'

Нужно разделить название и значение:

name, separator, value = header.partition(': ')

print(name)
print(separator)
print(value)

Результат:

Content-Type
: 
application/json

partition() удобен, когда нужно сделать одно предсказуемое разделение и при этом сохранить сам разделитель.

Если разделитель не найден

37. Результат всё равно содержит три элемента

text = 'Python'

print(text.partition(':'))

Результат:

('Python', '', '')

Структура результата не изменилась:

1 элемент → исходная строка
2 элемент → пустая строка
3 элемент → пустая строка

partition() всегда возвращает кортеж из трёх элементов.

Это делает его результат очень предсказуемым.

38. Разделитель находится в конце

text = 'Python:'

print(text.partition(':'))

Результат:

('Python', ':', '')

Опять получаем ровно три элемента.

`rpartition()`

39. Поиск последнего разделителя

rpartition() работает аналогично, но использует последнее вхождение разделителя.

Например:

file_path = 'project/backend/api/main.py'

result = file_path.rpartition('/')

print(result)

Результат:

('project/backend/api', '/', 'main.py')

Так удобно отделить последнее имя от остального пути.

40. `partition()` и `rpartition()`

text = 'one-two-three'

partition():

print(text.partition('-'))

Результат:

('one', '-', 'two-three')

Использовано первое вхождение:

one - two-three

rpartition():

print(text.rpartition('-'))

Результат:

('one-two', '-', 'three')

Использовано последнее вхождение:

one-two - three

Если `rpartition()` ничего не нашёл

41. Три элемента сохраняются

text = 'Python'

print(text.rpartition(':'))

Результат:

('', '', 'Python')

Это отличается от partition().

partition() при отсутствии разделителя:

('Python', '', '')

rpartition():

('', '', 'Python')

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

Где особенно удобны `partition()` и `rpartition()`

partition() хорошо подходит, когда структура выглядит примерно так:

ключ: значение
логин@домен
команда=значение

Например:

login, separator, domain = 'user@example.com'.partition('@')

rpartition() удобен, когда важна последняя часть:

путь/к/файлу
имя.расширение
несколько/уровней/последний

Например:

folder, separator, filename = (
    'project/api/main.py'.rpartition('/')
)

Главное по второй части

count() считает непересекающиеся вхождения подстроки и возвращает int.

split() разбивает строку и возвращает список.

Без явного разделителя:

text.split()

он работает с последовательностями пробельных символов.

С явным:

text.split(',')

разделяет только по указанной строке.

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

rsplit() особенно полезен вместе с maxsplit, когда разделять нужно с правой стороны.

splitlines() предназначен специально для границ строк, а:

splitlines(keepends=True)

позволяет сохранить сами символы переноса.

join() собирает итерируемый объект строк обратно в одну строку:

separator.join(iterable)

Связка:

split()
+
join()

часто используется для обработки и нормализации текста.

partition() всегда возвращает:

до разделителя
разделитель
после разделителя

для первого вхождения.

rpartition() делает то же самое для последнего вхождения.

count()

1. Подсчёт количества вхождений

2. Можно искать не только один символ

start и end

3. Ограничение области поиска

Вхождения без пересечения

4. count() не считает пересекающиеся совпадения

Небольшой пример полиморфизма

5. Одинаковая операция у разных классов

6. Пример из транспортной системы

split()

7. Разбиение строки

8. Знаки препинания сами по себе не удаляются

sep

9. Собственный разделитель

10. Разделителем может быть несколько символов

split() без разделителя

11. Пробельные символы

split(' ')

12. Явный пробел работает иначе

maxsplit

13. Ограничение количества разбиений

14. maxsplit вместе с sep

rsplit()

15. Разбиение справа

16. Без ограничения результат обычно совпадает

splitlines()

17. Разбиение текста на строки

18. splitlines() понимает разные границы строк

split('\n') и splitlines()

19. Простая строка

20. Перенос в конце строки

keepends

21. Сохранение символов переноса

22. Зачем сохранять переносы

join()

23. Сборка строк

24. Почему join() вызывается от разделителя

Разные разделители

25. Пробел

26. Запятая

27. Другой набор символов

28. Пустая строка

Разделитель можно сохранить в переменную

29. Обычный объект строки

join() и кортеж

30. Не только список

Строка тоже является итерируемым объектом

31. join() со строкой

Связка split() + join()

32. Разобрать → обработать → собрать

Удаление лишних пробельных символов

33. Нормализация пробелов

Когда количество пробелов нужно сохранить

34. Явный разделитель

partition()

35. Разделение на три части

36. Практический пример

Если разделитель не найден

37. Результат всё равно содержит три элемента

38. Разделитель находится в конце

rpartition()

39. Поиск последнего разделителя

40. partition() и rpartition()

Если rpartition() ничего не нашёл

41. Три элемента сохраняются

Где особенно удобны partition() и rpartition()

Главное по второй части

`count()`

`start` и `end`

4. `count()` не считает пересекающиеся совпадения

`split()`

`sep`

`split()` без разделителя

`split(' ')`

`maxsplit`

14. `maxsplit` вместе с `sep`

`rsplit()`

`splitlines()`

18. `splitlines()` понимает разные границы строк

`split('\n')` и `splitlines()`

`keepends`

`join()`

24. Почему `join()` вызывается от разделителя

`join()` и кортеж

31. `join()` со строкой

Связка `split()` + `join()`

`partition()`

`rpartition()`

40. `partition()` и `rpartition()`

Если `rpartition()` ничего не нашёл

Где особенно удобны `partition()` и `rpartition()`