join: собрать строку из частей

В уроке 9 split разрезал строку на список частей. Естественный вопрос — а как собрать обратно? И не только обратно: список слов часто нужно превратить в фразу, колонки таблицы — в CSV-строку, куски пути — в адрес. Это работа метода join, обратной пары к split.

разделитель.join(список)

Запись join непривычна: метод вызывается у разделителя, а список передаётся аргументом. Читается так: «возьми эту строку-клей и склей ею элементы списка»:

words = ['собрать', 'фразу', 'из', 'слов']
print(' '.join(words))
print('-'.join(words))
print(''.join(words))

собрать фразу из слов
собрать-фразу-из-слов
собратьфразуизслов

Один список, три результата: с пробелом получилась фраза, с дефисом — составное слово, а с пустым разделителем '' части склеились вплотную. Разделитель вставляется между элементами — ни в начале, ни в конце лишнего клея не останется.

внутри join — только строки

join требует, чтобы каждый элемент был строкой. Число среди строк останавливает его с ошибкой:

try:
    print(', '.join(['кот', 3, 'ток']))
except TypeError as e:
    print('Ошибка:', e)

Ошибка: sequence item 1: expected str instance, int found

prices = [str(1250), str(300), str(80)]
print(' + '.join(prices))

1250 + 300 + 80

почему join, а не плюс

Склеить пару строк плюсом легко — так вы делали это в уроке 1. Но помните: строки неизменяемы, и каждая склейка создаёт новую строку, копируя всё накопленное. В цикле из тысячи кусков плюс скопирует текст тысячу раз — работа растёт как квадрат числа кусков. join выделяет память под результат один раз и копирует каждую часть тоже один раз.

log_lines = [
    '2026-03-14 вход',
    '2026-03-14 поиск',
    '2026-03-14 корзина',
    '2026-03-14 оплата',
    '2026-03-14 выход',
]
print('\n'.join(log_lines))

2026-03-14 вход
2026-03-14 поиск
2026-03-14 корзина
2026-03-14 оплата
2026-03-14 выход

Пять строк лога склеены переводами строк \n обратно в один текст. На пяти элементах разница с плюсом незаметна, на пяти тысячах join выигрывает в разы — поэтому правило простое: собираешь много кусков — бери join.

join — обратная пара к split

Методы работают в паре: split разрезает строку по разделителю в список, join склеивает список тем же или новым разделителем. Так меняют разделитель в данных:

path = '2026/03/14'
parts = path.split('/')
print(parts)
print('/'.join(parts))
print('-'.join(path.split('/')))

['2026', '03', '14']
2026/03/14
2026-03-14

Первая пара вызовов вернула дату как была: '/'.join собрал куски тем же слэшем. Вторая собрала уже дефисами — формат даты сменился одной строкой кода. Круговой приём «split, обработай части, join обратно» — основа чистки данных: strip для краёв и replace для середины работают по одному элементу за раз.

join и одиночная строка

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

print('-'.join('кот'))
print('.'.join('py'))

к-о-т
p.y

Карточка метода

Пара split и join закрывает цикл обработки текста: разобрать, почистить, собрать. Другой способ вставлять значения в текст — f-строки из урока 3; для готовых списков удобнее join, для шаблонов с переменными — f-строки.

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

Если split разбирает строку на части, то join собирает части обратно. Синтаксис выглядит непривычно, потому что метод вызывается у разделителя, а список передаётся аргументом: ' '.join(words). Читается это как инструкция: «возьми эту строку-клей и склей ею элементы списка». Обратный вариант — words.join(' ') — не существует вовсе, и это не опечатка, а сознательный выбор в языке.

words = ['собрать', 'фразу', 'из', 'слов']
print(' '.join(words))
print('-'.join(words))
print(''.join(words))

собрать фразу из слов
собрать-фразу-из-слов
собратьфразуизслов

Ключевая деталь, которую стоит проговорить: разделитель вставляется МЕЖДУ элементами и только между ними. Ни в начале, ни в конце лишнего клея не будет. Отсюда растёт классическая ошибка новичков: ', '.join(words) + ',' — «чтобы запятая была и в конце». Так делают, когда собирают SQL-запрос или CSV, и получают лишний разделитель, который ломает парсер на той стороне. Если разделитель нужен и в конце — собирайте список с заранее добавленным элементом.

Почему join, а не сложение в цикле

Это место, где Python раскрывает свою природу. Строки неизменяемы, поэтому s = s + часть не дописывает к существующей строке, а создаёт новую — и копирует старую целиком. Сто частей означают сто копирований уже накопленного текста: суммарно обрабатывается примерно половина всех данных × количество частей. join же сразу считает суммарную длину, выделяет память один раз и копирует каждый кусок ровно один раз.

На пяти элементах разницу не видно, и это ловушка: код с += в цикле работает годами, потому что данных мало. Потом выгрузка растёт до сотен тысяч строк, и процесс уезжает в память. Профилировщик показывает, что 90% времени уходит на копирование строк, которых никто не просил копировать. Лечение — одна строка: ' '.join(lines).

rows = [['хлеб', '45'], ['молоко', '89']]
csv = []
for name, price in rows:
    csv.append(','.join([name, price]))
print('\n'.join(csv))

хлеб,45
молоко,89

Обратите внимание на два уровня join. Внутренний склеивает поля одной строки запятой, внешний — готовые строки переводом строки. Обычно это выглядит некрасиво и в реальном коде заменяется на модуль csv, который сам экранирует запятые и кавычки внутри значений: csv.writer знает, что поле с запятой надо заключить в кавычки. Ручной join этого не делает — и на данных вроде «ООО Ромашка, Тверь» вы получите битый CSV.

join и генераторы: не обязательно список

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

def lines():
    for i in range(1, 4):
        yield f'строка {i}'

print('\n'.join(lines()))

строка 1
строка 2
строка 3

Наивная реализация join через цикл создаёт список из всех кусков — а потом склеивает его. То есть память на объём данных всё равно тратится, просто в виде списка. С генератором join этого не делает. Для файла в сто миллионов строк разница между «список из 100 миллионов строк» и «ничего» — это разница между «не влезает в память» и «работает».

letters = ['к', 'о', 'т']
print(''.join(letters))
print(''.join(letters[::-1]))
print('.'.join(reversed(letters)))

кот
ток
т.о.к

Три строки — три способа развернуть текст. Первые две используют срез letters[::-1] из урока про срезы, третья — функцию reversed, которая работает с любой последовательностью и не копирует её. Для списка из миллиона элементов разница между срезом и reversed в памяти заметна.

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

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