Метод join() в Python

В языках программирования много типов данных: строки, числа разных форматов, булевы переменные типа True-False и ещё много других. Есть более сложные типы-структуры, которые состоят из нескольких элементов: списки, словари, кортежи, словари.Мы сегодня разбираем один из методов работы со строками в языке Python — join(). Метод соединяет строки в одну — или разделяет на символы, в зависимости от использования. Рассказываем, чем это может быть полезно в разработке и как пользоваться этим методом.

Введение в метод join()

Сначала кратко вспомним, что такое коллекции и итерируемые объекты в Python.

Основной способ использования join() — объединение нескольких уже существующих разрозненных строк в структурах-коллекциях.

Например, список из таких букв:

sequence = ['Э', 'т', 'о', ' ', 'К', 'О', 'Д']

можно объединить в одну связную строку:

Это КОД

Синтаксис метода join()

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

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

Metro, Goldwyn, Mayer

Сначала посмотрим на полный код для этой задачи. Если его запустить, он выведет текст выше:

# строка-разделитель — запятая с пробелом
separator = ", "

# список имён для объединения
elements = ["Metro", "Goldwyn", "Mayer"]

# объединяем имена через разделитель
split = separator.join(elements)

# выводим результат
print(split)

Теперь разберём, как это работает.

Второй способ применения — передать в метод join() одну целую строку, чтобы он разбил её по символам, между которыми находится строка-разделитель:

# строка-разделитель — запятая с пробелом
separator = ";"

# строка, которую мы хотим разбить на символы
string = 'Раз два'

# объединяем имена через разделитель
split = separator.join(string)

print(split)

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

Р;а;з; ;д;в;а

Использование join() с другими типами данных

Если попробовать передать в метод что-то кроме строк, он выдаст ошибку. Для примера возьмём код программы с именами и заменим один из элементов на число:

# строка-разделитель — запятая с пробелом
separator = ", "

# список имён для объединения
elements = ["Metro", "Goldwyn", 33]

# объединяем имена через разделитель
split = separator.join(elements)

# выводим результат
print(split)

Traceback (most recent call last):
  File "/Users/boombro190/Documents/Develop_Projects/Draft_Project/main.py", line 8, in <module>
    split = separator.join(elements)
            ^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: sequence item 2: expected str instance, int found

Один из вариантов решения — преобразовать типы данных в строку перед объединением. Например, это можно сделать с генератором списков. Мы проходим по всем значениям списка, переводим их в строки и соединяем черезjoin():

# создаём список разных типов данных
data = [10, 20.3, False, "строка"]

# проходим по всему списку, переводим все элементы
# в строковый тип и соединяем через строку " | "
result = " | ".join(str(item) for item in data)

# проверяем результат
print(result)

Получаем одну строку:

10 | 20.3 | False | строка

Полный курс по программированию на Python с нуля

Возвращаемое значение метода join()

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

Создадим новую строку из нескольких слов:

# исходный список
strings = ["using", "function", "single"]

# создаём новую строку из элементов списка
new_strings = " & ".join(strings)

# выводим новую строку
print(new_strings)  # яблоко и груша и банан

# исходный список остался прежним
print(strings)

Код выводит и новую, и старую строки. Видим, что первоначальный список остался без изменений:

using & function & single
['using', 'function', 'single']

Объединение списка строк

Разберём, как работает join() с разными коллекциями.

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

my_list = [1, 2, 3, 4, 5]

Мы уже собрали строку из списка нескольких строк, поэтому теперь придумаем кое-что посложнее. Иногда в предложении встречается больше одного знака между словами — например, не только пробелы, но ещё и запятые.

Соберём название фильма из такого списка:

words = ["The", "Good", "the", "Bad", "and", "the", "Ugly"]

Для этого используем такой инструмент списка, как срезы. Срез позволяет взять только часть элементов, например с 2-го по 3-й. Для этого нужно передать диапазон индексов элементов и не забыть, что нумерация идёт с 0 и что последний элемент этого диапазона в срез не включён. Чтобы взять 2-е и 3-е слово из нашего списка, нам нужен срез [1:3].

Как будет выглядеть полный код:

# создаём список слов
words = ["The", "Good", "the", "Bad", "and", "the", "Ugly"]

# сначала склеим Good и the через запятую
# это элементы 2 и 3, поэтому срез будет 1:3
middle = ', '.join(words[1:3])

# затем соберём всю строку
result = ' '.join([words[0], middle] + words[3:])

# выводим результат на экран
print(result)

Что получилось:

The Good, the Bad and the Ugly

Использование join() с кортежами

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

my_tuple = (1, 2, 3, 4, 5)

Кортеж может хранить данные для запроса в базу данных, составления CSV-строки или URL. В этом случае можно использовать join(), который работает с кортежами так же, как со списками:

# кортеж с числами в виде строк
numbers = ("2025", "06", "04")

# объединяем элементы через дефис
result = "-".join(numbers)

# выводим результат
print(result)

Запускаем код и видим тот же результат, как если бы вместо кортежа был список:

2025-06-04

Использование join() с множествами

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

tags = {"Python", "программирование", "код"}

Теперь нюанс: join() соединяет элементы в том порядке, в каком они были переданы. Но у элементов множества нет своих номеров-индексов, поэтому порядок может быть любым. Например, такой код:

# множество с уникальными словами
tags = {"tuple", "list", "method"}

# объединяем элементы через запятую
tag_line = ", ".join(tags)

# выводим результат (порядок может быть другим)
print(tag_line)

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

list, tuple, method

method, list, tuple

tuple, list, method

При помощи множеств можно вывести уникальные теги или другие неповторяющиеся элементы из какого-то ресурса, например блога или статьи.

Использование join() со словарями

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

my_dict = {"имя": "Игорь", "age": 38, "работает": True}

Начиная с Python версии 3.7 и выше словари упорядочены. Индексы пар хранятся в том порядке, каком они были добавлены.

По умолчанию join() работает только с ключами, потому что они всегда имеют строковый тип. Но это можно изменить и указать в настройках, с чем именно нужно работать. Тогда join() сможет обрабатывать значения, если они тоже имеют тип данных «строка»:

Попробуем объединить ключи и значения из словаря:

# словарь с несколькими парами
iterable = {"key1": "methods", "key2": "list", "key": "tuple"}

# объединяем ключи и значения
keys_and_values = ", ".join(f"{k}: {v}" for k, v in iterable.items())

# выводим результат
print(keys_and_values)

Программа выводит ключи и значения, между которыми помещается строка-разделитель:

key1: methods, key2: list, key: tuple

Сравнение метода join() и оператора +

Есть ещё один способ объединения строк в Python — это оператор +. 

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

str1 = "Привет, "
str2 = "мир!"
result = str1 + " " + str2
print(result)

Получается объединённая строка:

Привет,  мир!

Разберём, что лучше использовать.

Производительность. Оператор + удобен для объединения 2–3 строк или использования в циклах. Но даже в цикле он всё равно будет медленнее join(), потому что на каждое действие создаёт новую строку. Join() заранее знает, сколько строк нужно объединить, и делает это за один раз.

Когда важна производительность или когда объединить нужно большое количество строк, лучше использовать join().

Другие способы объединения строк

Вот ещё два способа объединять строки, которые тоже могут использоваться в реальных задачах.

Использование f-строк

Это способ встраивания переменных прямо в текст. Мы пишем названия переменных в строке через специальный синтаксис с помощью ключа f, а Python потом выводит значения в памяти, на которые указывают эти переменные. 

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

name = "Алиса"
age = 25

# вставляем переменные напрямую
message = f"Меня зовут {name}, мне {age} лет."

print(message)

Что получаем:

Меня зовут Алиса, мне 25 лет.

Функция format()

Похоже на «конструктор» строк, в котором можно задать шаблон с местами для подстановки. Похоже на заполнение анкеты: вы указываете, куда вписать имя, возраст и другие значения.

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

# задаём шаблон с плейсхолдерами {}
template = "{} купил {} яблока"

# подставляем значения по порядку
text = template.format("Петя", 3)

print(text)

Запускаем код:

Петя купил 3 яблока

Вам слово

Приходите к нам в соцсети поделиться своим мнением о методе join() и почитать, что пишут другие. А ещё там выходит дополнительный контент, которого нет на сайте — шпаргалки, опросы и разная дурка. В общем, вот тележка, вот ВК — велком!

Любишь Python? Зарабатывай на нём!

Изучите самый модный язык программирования и станьте крутым бэкенд-разработчиком. Старт — бесплатно.

Попробовать бесплатно