Конкатенация и объединение строк в Python: операторы +, функции объединения и т.д.

Ниже описано, как конкатенировать и объединять строки str в Python.

Конкатенация и объединение нескольких строк: +,+=оператор
Конкатенация и объединение чисел и строк: +,+=оператор,str(),format(),f-строка
Конкатенация и объединение списков (массивов) строк в одну строку:join()
Конкатенировать и объединять списки (массивы) чисел в одну строку:join(),str()

Table of Contents

Конкатенация и объединение нескольких строк: +, +=оператор
Конкатенация чисел и строк\concatenation: +,+=оператор,str(),format(),f-строка
Конкатенировать и объединять списки (массивы) строк: join()
Конкатенировать и объединять списки (массивы) чисел в виде строк: join(),str()

Конкатенация и объединение нескольких строк: +, +=оператор

подключение: +оператор

Оператор ++ можно использовать для конкатенации следующих строковых литералов и строковых переменных

'…'
«…»

s = 'aaa' + 'bbb' + 'ccc'
print(s)
# aaabbbccc

s1 = 'aaa'
s2 = 'bbb'
s3 = 'ccc'

s = s1 + s2 + s3
print(s)
# aaabbbccc

s = s1 + s2 + s3 + 'ddd'
print(s)
# aaabbbcccddd

подключение: +=оператор

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

s1 += s2
print(s1)
# aaabbb

Если вы хотите добавить строку в конец строковой переменной, просто обработайте строковую переменную и любой строковый литерал (или другую строковую переменную) оператором +=.

s = 'aaa'

s += 'xxx'
print(s)
# aaaxxx

Последовательная конкатенация строковых литералов

Если вы просто пишете строковые литералы рядом друг с другом, они будут конкатенированы.

s = 'aaa''bbb''ccc'
print(s)
# aaabbbccc

Допускается наличие пробела между двумя строками или обратного слэша (считается продолжением).

s = 'aaa'  'bbb'    'ccc'
print(s)
# aaabbbccc

s = 'aaa'\
    'bbb'\
    'ccc'
print(s)
# aaabbbccc

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

Похожие статьи:Запись длинных строк на нескольких строках в Python

Этот метод записи невозможен для строковых переменных.

# s = s1 s2 s3
# SyntaxError: invalid syntax

Конкатенация чисел и строк\concatenation: +,+=оператор,str(),format(),f-строка

Операция + другого типа приводит к ошибке.

s1 = 'aaa'
s2 = 'bbb'

i = 100
f = 0.25

# s = s1 + i
# TypeError: must be str, not int

Если вы хотите объединить числовое значение (например, целочисленный тип int или тип с плавающей точкой float) со строкой, преобразуйте числовое значение в строковый тип с помощью str(), а затем объедините их с помощью оператора + (или оператора +=).

s = s1 + '_' + str(i) + '_' + s2 + '_' + str(f)
print(s)
# aaa_100_bbb_0.25

Если вы хотите преобразовать формат числа, например, заполнение нулями или десятичными знаками, используйте функцию format() или строковый метод format().

s = s1 + '_' + format(i, '05') + '_' + s2 + '_' + format(f, '.5f')
print(s)
# aaa_00100_bbb_0.25000

s = '{}_{:05}_{}_{:.5f}'.format(s1, i, s2, f)
print(s)
# aaa_00100_bbb_0.25000

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

s = '{}_{}_{}_{}'.format(s1, i, s2, f)
print(s)
# aaa_100_bbb_0.25

Подробнее о том, как задать формат, см. в следующей статье.

Похожие статьи:Преобразование формата в Python, формат (0-заполнение, экспоненциальная нотация, шестнадцатеричная и т.д.)

Начиная с Python 3.6, также появился механизм под названием f-строки (f-string), который еще проще в написании, чем format().

s = f'{s1}_{i:05}_{s2}_{f:.5f}'
print(s)
# aaa_00100_bbb_0.25000

s = f'{s1}_{i}_{s2}_{f}'
print(s)
# aaa_100_bbb_0.25

Конкатенировать и объединять списки (массивы) строк: join()

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

str.join(iterable) — Built-in Types — Python 3.10.2 Documentation

Ниже описано, как его написать.

'String to be inserted between'.join([List of strings to be concatenated])

Вызовите метод join() со строкой 'string to insert between' и передайте [list of strings to concatenate] в качестве аргумента.

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

l = ['aaa', 'bbb', 'ccc']

s = ''.join(l)
print(s)
# aaabbbccc

s = ','.join(l)
print(s)
# aaa,bbb,ccc

s = '-'.join(l)
print(s)
# aaa-bbb-ccc

s = '\n'.join(l)
print(s)
# aaa
# bbb
# ccc

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

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

Конкатенировать и объединять списки (массивы) чисел в виде строк: join(),str()

Ошибка возникает, если аргументом join() является список, элементы которого не являются строками.

l = [0, 1, 2]

# s = '-'.join(l)
# TypeError: sequence item 0: expected str instance, int found

Чтобы объединить список чисел в одну строку, примените функцию str() к каждому элементу списка, чтобы преобразовать числа в строку, а затем соедините их с помощью функции join().

s = '-'.join([str(n) for n in l])
print(s)
# 0-1-2

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

s = '-'.join((str(n) for n in l))
print(s)
# 0-1-2

s = '-'.join(str(n) for n in l)
print(s)
# 0-1-2

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