Как использовать метод join() в Python?

Когда я смотрел на программу Python, написанную моим коллегой, я заметил, что они использовали join(). Что делает join() в Python?

Метод join() — один из методов, предоставляемых типом данных string в Python. Метод join позволяет генерировать строку из элементов итерируемого объекта (например, списка, кортежа или набора). При вызове метода join() необходимо указать строку-разделитель, которая разделяет элементы итерируемого объекта в конечной строке, возвращаемой join().

Это станет совершенно ясно, если рассмотреть примеры кода ниже.

Что такое метод String join() в Python?

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

Ниже вы можете увидеть синтаксис метода join():

Элементы итерируемого объекта, переданные методу join(), должны быть строками. Если итерируемый объект содержит нестроковые значения, интерпретатор Python выдает TypeError.

Зачем использовать метод Python string join()?

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

Представьте, например, что у вас есть список слов, и вы хотите создать одну строку, объединив все слова в списке, разделенные пробелами. В этом случае пробел будет разделителем, который будет передан методу строки join().

Пример того, как это работает, можно увидеть на видео ниже:

Кроме того, тот факт, что вы можете выбрать разделитель, который будет добавлен между каждым элементом итерируемого объекта, делает метод join() гибким подходом к генерации строк Python.

Является ли join() строковым методом Python?

Метод join() — это метод типа данных string в Python. Это означает, что join() — это функция, связанная с объектами типа string.

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

separator.join(iterable)

А вот пример кода Python, который вызывает метод join():

test_string = " ".join(['Test', 'the', 'join()', 'method'])
print(test_string)

[output]
'Test the join() method'

В этом примере мы использовали пробел в качестве разделителя.

Чтобы вывести значение строки, возвращаемой методом join(), используется функция Python print().

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

Python предоставляет метод join() для объединения элементов списка строк с использованием символа в качестве разделителя.

Метод join() делает в одну строку то, что в противном случае пришлось бы делать с помощью цикла for и нескольких строк кода.

Давайте возьмем следующий список строк и воспользуемся функцией join(), чтобы сгенерировать из него одну строку:

modules = ["Python modules:", "Pandas", "subprocess", "json"]
print(" ".join(modules))

[output]
Python modules: Pandas subprocess json     

А вот как будет выглядеть итоговая строка, если в качестве разделителя использовать символ новой строки («\n»):

modules = ["Python modules:", "Pandas", "subprocess", "json"]
print("\n".join(modules))

[output]
Python modules:
Pandas
subprocess
json

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

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

modules = ["Python modules:", "Pandas", "subprocess", "json", 14578]
print("\n".join(modules))

[output]
Traceback (most recent call last):
  File "/opt/codefathertech/tutorials/join_method.py", line 5, in <module>
    print("\n".join(modules))
TypeError: sequence item 4: expected str instance, int found

Интерпретатор Python выдает исключение TypeError, поскольку ожидается, что элемент с индексом 4 в последовательности (итерируемый) будет строкой, но вместо этого это целое число.

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

Метод Python строки join() можно применять к любому итерируемому объекту, то есть он работает и с кортежами Python.

В приведенном ниже примере тестируется метод join() с кортежем Python:

modules = ("Python modules:", "Pandas", "subprocess", "json")
print("\n".join(modules))

[output]
Python modules:
Pandas
subprocess
json      

Вывод будет точно таким же, как при передаче списка Python в метод join().

Также метод join() можно использовать только с кортежем строк. Вот что произойдет, если применить метод join() к кортежу целых чисел:

numbers = (10, 20, 30, 40, 50)
print(" ".join(numbers))

[output]
Traceback (most recent call last):
  File "/opt/codefathertech/tutorials/join_method.py", line 5, in <module>
    print(" ".join(numbers))
TypeError: sequence item 0: expected str instance, int found

Python выдает исключение TypeError, поскольку ожидает строку, но вместо нее обнаруживает целое число.

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

Вы можете использовать метод Python строки join() для конкатенации (объединения) элементов набора. Кроме того, учитывая, что элементы в наборе не упорядочены, окончательная строка, возвращаемая методом join(), может быть разной каждый раз, когда вы выполняете свой код.

В приведенном ниже примере тестируется метод join() с набором Python:

modules = {"Python modules:", "Pandas", "subprocess", "json"}
print("\n".join(modules))

[output]
Python modules:
Pandas
subprocess
json      

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

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

# TEST 2 OUTPUT
Pandas
Python modules:
subprocess
json

# TEST 3 OUTPUT
Pandas
json
Python modules:
subprocess

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

Давайте посмотрим, что произойдет при объединении набора чисел:

numbers = {10, 20, 30, 40, 50}
print(" ".join(numbers))

[output]
Traceback (most recent call last):
  File "/opt/codefathertech/tutorials/join_method.py", line 5, in <module>
    print(" ".join(numbers))
TypeError: sequence item 0: expected str instance, int found

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

Как объединить символы строки в Python?

Прежде чем я объяснил, что вы можете передать итерируемый объект в метод join(). Строка Python также является итерируемым объектом, поэтому мы должны иметь возможность также передавать string() в метод join().

Давайте попробуем это!

word = "python"
print(" ".join(word))

[output]
p y t h o n

В этом коде мы использовали пробел в качестве разделителя и передали строковое слово методу join().

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

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

Давайте добавим несколько чисел в эту строку…

Ожидаете ли вы увидеть ту же ошибку, которую мы видели раньше при передаче списка, кортежа или набора, содержащего числа, в метод join()?

word = "python3.11"
print(" ".join(word))

[output]
p y t h o n 3. 1 1

Мы не видим никаких ошибок после добавления цифр к строковому слову, поскольку каждая цифра является символом, а не целым числом.

Вы можете убедиться в этом, используя встроенную функцию Python type() и цикл for.

word = "python3.11"

for character in word:
    print(character, type(character))

[output]
p <class 'str'>
y <class 'str'>
t <class 'str'>
h <class 'str'>
o <class 'str'>
n <class 'str'>
3 <class 'str'>
. <class 'str'>
1 <class 'str'>
1 <class 'str'>

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

В этом разделе мы рассмотрим, что происходит при передаче словаря Python в метод строки join().

Начните с создания словаря:

numbers = {"one": 1, "two": 2, "three": 3}

Затем передайте этот словарь методу join() и используйте символ пробела в качестве разделителя.

print(" ".join(numbers))

[output]
one two three

В выводе метода join() вы можете увидеть ключи словаря.

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

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

numbers = {1: 'one', 2: 'two', 3: 'three'}
print(" ".join(numbers))

[output]
Traceback (most recent call last):
  File "/opt/codefathertech/tutorials/join_method.py", line 5, in <module>
    print(" ".join(numbers))
          ^^^^^^^^^^^^^^^^^
TypeError: sequence item 0: expected str instance, int found

Выполнение этого кода Python завершается ошибкой TypeError, поскольку метод join() пытается объединить ключи словаря, которые в этом примере являются целыми числами, а не строками.

Метод String join() быстрее, чем += в Python?

Метод Python строки join() быстрее оператора +=, когда дело касается конкатенации строк.

Давайте рассмотрим два примера, чтобы сравнить два подхода друг с другом на примере небольшой итерации (100 элементов) и более крупной итерации (100 000 элементов).

Начнем со 100 элементов:

import time

# Using the join() method
start_time = time.time()
test_string = ', '.join(['test' for _ in range(100)])
end_time = time.time()
print('Time using the join() method: ', end_time - start_time)

# Using the += operator
start_time = time.time()
s = ''
for _ in range(100):
    test_string += 'test'
end_time = time.time()
print('Time using the += operator: ', end_time - start_time)

В приведенном выше коде мы импортируем модуль времени, а затем вычисляем разницу между end_time и start_time, чтобы сравнить время выполнения метода join() по сравнению с оператором +=.

Time using the join() method:  1.2874603271484375e-05
Time using the+operator:  2.7894973754882812e-05

Из этого вывода видно, что метод join() быстрее оператора +=.

Давайте посмотрим, увеличится ли разница во времени, если мы увеличим количество элементов в итерируемом массиве до 100 000:

Time using the join() method:  0.005889892578125
Time using the+operator:  0.017504215240478516

И снова метод join() быстрее оператора +=.

Причина, по которой метод join() быстрее оператора + при конкатенации строк, заключается в том, что строка Python является неизменяемым типом данных. Это означает, что после создания строки ее нельзя изменить, и каждый раз, когда вы используете оператор +=, Python создает новую строку. С другой стороны, метод join() выполняет конкатенацию строк за одну операцию.

Заключение

Метод Python join() очень полезен для конкатенации строк и обеспечивает преимущества в производительности по сравнению с подходом, основанным на операторе +=.

Помните, что для использования метода join() вам нужно работать с итерируемым объектом строк. Если итерируемый объект содержит числа, Python выдаст исключение TypeError, как вы видели несколько раз в примерах, которые мы рассмотрели в этом руководстве.

Продолжайте практиковать метод строки join(), и довольно скоро он станет одной из основных конструкций, которые вы будете использовать в своих программах на Python.