Python соединение строк: Как работает конкатенация строк в Python 3? Примеры.

Как работает конкатенация строк в Python 3? Примеры.

Конкатенация строк — самая распространенная операция в программировании на Python. Есть несколько варинатов как сложить две строки.

Конкатенация строк в Python

Варианты обьединения строк:

• + operator
• метод join()
• % оператор
• функция format()
• f-string (форматированные строковые литералы)

Конкатенация строк с помощью оператора ‘+’

Это самый простой способ. Давайте рассмотрим на примере:

s1 = 'Apple'
s2 = 'Pie'
s3 = 'Sauce'
s4 = s1 + s2 + s3
print(s4)

Результат: «Pythonist.ru нужен Питонисту»

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

s1 = input('Введите первую строку :\n')
Введите первую строку :
pythonist. ru
s2 = input('Введите вторую строку:\n')
Введите вторую строку:
 сайт для программистов
print('Конкатенированная строка =', s1 + s2)

 >>> s1 = input('Введите первую строку :\n')
Введите первую строку :
pythonist.ru
>>> s2 = input('Введите вторую строку:\n')
Введите вторую строку:
 сайт для программистов
>>> print('Конкатенированная строка =', s1 + s2)

Результат: Конкатенированная строка = pythonist.ru сайт для программистов

Очень удобный способ использование оператора «+». Единственный момент, который надо учитывать это то, что обе вводные должны быть строками.

>>>'Hello' + 4
Traceback (most recent call last):
  File "<input>", line 1, in 
TypeError: can only concatenate str (not "int") to str

Мы можем использовать str() function для представленя объекта в виде строки.

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

print('Питонист' + str(4))
class Data:
    id = 0
    def __init__(self, i):
        self.id = i
    def __str__(self):
        return 'Номер[' + str(self.id) + ']'
print('Питонист ' + str(Data(10)))

Результат:

>>> Питонист

>>> Питонист Номер[10]

Основная проблема оператора «+» в том, что используя его мы не можем добавить разделитель между строками. Например если мы хотим сконкатенировать строки “Hello” и “World” и поставить между ними пробел, то нам надо писать так «Hello» + » » + «World»

Конкатенация строк используя функцию join().

Мы можем использовать функцию join() для конкатенации строк и одновременного добавления разделителя между ними. Это полезная функция, когда мы имеем последовательность строк, например List или tuple строк.

Если вам не нужен разделитель, то можно использовать join() с пустой строкой.

s1 = 'Hello'
s2 = 'World'
print('Concatenated String using join() =', "".join([s1, s2]))
print('Concatenated String using join() and whitespaces =', " ".join([s1, s2]))

Результат:

Concatenated String using join() = HelloWorld

Concatenated String using join() and spaces = Hello World

Конкатенация строк используя оператор %

Мы можем использовать оператор % как для форматирования строк, так и для конкатенации. Он полезен когда нам нужно сложить две строки и вдобавок отфарматировать.

s1 = 'Hello'
s2 = 'World'
s3 = "%s %s" % (s1, s2)
print('String Concatenation using % Operator =', s3)
s3 = "%s %s from JournalDev - %d" % (s1, s2, 2018)
print('String Concatenation using % Operator with Formatting =', s3)

Результат:

String Concatenation using % Operator = Hello World

String Concatenation using % Operator with Formatting = Hello World from JournalDev — 2018

Конкатенация строк с помощью функции format()

Можно использовать функцию строк format() для конкатенации и форматирования.

 s1 = 'Hello'
s2 = 'World'
s3 = "{}-{}".format(s1, s2)
print('String Concatenation using format() =', s3)
s3 = "{in1} {in2}".format(in1=s1, in2=s2)
print('String Concatenation using format() =', s3)

Результат:

String Concatenation using format() = Hello-World
String Concatenation using format() = Hello World

Функция format() очень мощная и использовать ее только для сложения строк не самый лучший и быстрый вариант.

Конкатенация с использованием f-строк

Если вы используете Python3.6+ то вы можете использовать f-строки для конкатенации. Это новый способ форматирования строк. Он был представлен в PEP 498 – Literal String Interpolation.

s1 = 'Hello'
s2 = 'World'
s3 = f'{s1} {s2}'
print('String Concatenation using f-string =', s3)
name = 'Pankaj'
age = 34
d = Data(10)
print(f'{name} age is {age} and d={d}')

Результат:

String Concatenation using f-string = Hello World
Pankaj age is 34 and d=Data[10]

Python f-строки более чистый и легкий способ по сравнению с format()

Заключение

Форматирование строк в Python может быть сделано разными способами. Используйте один из них, в зависимости, что вам нужно сделать со строками. Если надо сконкатенировать и добавить разделитель, тогда используйте Join(). Если надо еще и отформатировать, тогда format() или f-строки. Учитывайте что f-строки можно использовать с версии Python3.6 или выше.

Как объединить строки в Python – все способы конкатенации строк

Работа со строками нужна много где: создание логов, пользовательский текст, выдача текста читателю, парсинг страниц и так далее. Поэтому нет ничего удивительного в том, что объединение строк (их конкатенацию) можно производить сразу несколькими встроенными способами. Основные – это перегрузка оператора «+» и встроенный метод join в Python, хотя есть и более экстравагантные варианты, вроде объединения через print и обращения к методу перегрузки. Ниже мы перечислим все эти способы и вкратце отметим их эффективность – когда много строк объединяется в одну, и это нужно сделать 100 000 раз, эффективность начинает играть решающее значение.

Теория: что такое .join()

Практика: работа + и .join()

Если строк много

Производительность

Другие способы

Что почитать по теме

Подведем итоги

Теория: что такое .join()

Основных способов, как мы уже говорили, два: функция join в Python и оператор «+». О том, как именно их можно применять, вы увидите в «Практика: работа + и .join()», здесь же мы расскажем базу, без которой у вас не получится понять тонкости работы методов. Речь идет об объектно-ориентированном программировании.

ООП, методы, перегрузка

ООП – это парадигма (набор идей) программирования, согласно которой все сущности можно разбить на объекты. Объекты, в свою очередь, являются экземплярами классов. Эта парадигма пришла к нам из реальной жизни, как хрестоматийный пример – есть абстрактный класс «стул», который мы представляем себе как набор параметров, и есть конкретный объект «стул», об который мы отбиваем себе мизинчик ночью. ООП – большая тема, но нас в контексте объединения строк интересуют 2 конкретные вещи: методы и перегрузка.

Метод – это набор действий, которые может совершать определенный объект. Методы прописываются у класса, и каждый объект данного класса этими методами обладает. Перегрузка – это когда мы берем какие-нибудь операторы (например, «+»), и задаем им поведение при различных типах объектов. Перегрузку проще понять на практике: 2 + 2 = 4. Здесь ничего пояснять не надо – оператор «+» перегружен таким образом, что если слева и справа от него стоят 2 числа, то он складывает их и оправляет куда-то результат. А теперь давайте предположим, что у нас есть 2 объекта – первый, date_of_launch, хранит дату запуска сервера в формате дд.мм.гггг, а второй, uptime, хранит текущий аптайм (длительность с момента запуска) сервера в секундах. Мы хотим узнать текущую дату из этих данных, то есть нам нужно сложить данные из первого объекта с данными из второго объекта, причем 86 400 секунд из второго объекта равны одному дню первого объекта. Конечно, можно написать функцию, все это складывающую, и писать нам ее придется в любом случае, но если такое сложение приходится выполнять часто, то проще писать

date_of_launch + uptime, чем result = function_name(date_of_launch, uptime)

да и поменять местами аргументы в случае с функцией так просто уже не получится (не говоря уже о том, что функция должна лежать в каком-то классе/объекте). Перегрузка – это когда мы оператору «+» даем задачу: «если с одной стороны от тебя находится объект типа date_of_launch, а с другой лежит uptime, то ты запускаешь функцию их сложения, после чего возвращаешь результат». То есть мы засовываем функцию подсчета в знак «+».

Реализация .join() для конкатенации

Последний теоретический штрих, после которого мы перейдем к практике: все в Python является объектом. А раз все является объектом, то оно вполне может иметь встроенные функции и перегрузку операторов – вот мы и подошли к + и join в Python. Join в Питоне – это основной способ конкатенации нескольких строк. Синтаксис:

‘’.join(iterable)

где:

• ‘’ – строка, которая будет работать как разделитель.
• . – вызов встроенного метода строки.
• Join – имя метода.
• Iterable – объект, из которого будут браться строки для конкатенации.

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

“1”.join([“hello”,”world”])

то результатом будет hello1world. Заметьте, что в функцию передается строго один итерируемый (тот, который можно последовательно перебрать) объект, так уж устроена функция. Из этого следуют не совсем очевидные артефакты, например: в Python объединение словарей в строку возможно только по ключам, если не использовать дополнительные функции. То есть если вы скармливаете функции join словарь, то функция возьмет все ключи словаря и объединит их в одну строку, а значения отбросит. Чтобы объединить значения, вам нужно подать на вход

dict.values()

– функцию словаря, которая возвращает исключительно значения.

Реализация перегрузки для конкатенации

Ну и напоследок – про «+». У каждого объекта есть встроенная функция __add__, внутри этой функции описаны действия, которые нужно совершить, если встречается конструкция «объект + еще_какой-то_объект», то есть функция реализует перегрузку. В __add__ для string прописано, что если встречается конструкция «string + string», то нужно создать новую строку, в которой эти две строки будут объединены, и вернуть эту новую строку. Все.

Практика: работа + и .

join()

Как пользоваться + и .join() для соединения строк:

• Передаем список, возвращает «abc»:

  “”.join([a, b, c])

• Используем разделитель, возвращает «Hello1world!»:

  “1”.join([“Hello”, “world!”])

• Передаем кортеж, возвращает «Hello, world!». Обратите внимание, что пробел вставляется строго между строками, перед результатом и после него пробела нет:

  “ ”.join((“Hello”, ”world!”))

• Передаем словарь, возвращает «key1key2», значения отбрасываются:

  “”.join({“key1”:”a”, “key2”:”b”})

• Последовательно передаем строки оператору «+», результат: «Hello world !». Заметьте, пробелы нужно расставлять в строках самому:

  “Hell” + “o” + “ ” + “world” + “ !”

Если строк много

И +, и join одинаково умеют справляться с множеством строк. Если используете +, то нужно писать string1 + string2 + string3 + … + stringN. Если же используете join, то нужно передать в функцию любой итерируемый объект (обычно – список) с любым количеством строк, и они будут объединены.

vowels = ["a", "e", "i", "o", "u"]

vowelsCSV = ",".join(vowels)

print("Vowels are = ", vowelsCSV)

Производительность

Join производительнее, чем +. Это справедливо практически для всех функций в Python: чем более специфична функция, тем более она производительна. NumPy (библиотека с математическими операциями) вообще в 5-10 раз более производительна, чем стандартные математические операции Python. Причина повышенной производительности – в том, что join имеет возможность заранее посчитать необходимое место в памяти для всех операций, а + вынужден обращаться к памяти каждый раз, когда встречает новую строку. При использовании «+» в цикле происходит примерно следующее:

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

Поэтому у join меньше обращений к памяти (системных вызовов к операционной системе), отсюда и более высокая производительность.

Другие способы

Здесь мы перечислим варианты, которые не стоит использовать для конкатенации строк без большой на то необходимости. Они – неочевидные и неоптимизированные, вы ухудшите и читаемость кода, и производительность.

Оператор %

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

“%s%s%s” % (“Hello ”, ”world”, ”!”)

На место каждой %s подставляются строки, которые мы указываем в скобках, по порядку.

Функция format()

Почти то же, что и предыдущий вариант, но дает немного больше гибкости:

“{2}{1}{0}”. format(“!”, ”world”, “Hello ”)

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

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

Дальнейшая эволюция предыдущих двух методов. F-строки в Python – это строки, которые можно гибко форматировать. F-строка объявляется через f перед

“”: f”some random string here”

В такие строки можно вставлять переменные:

string1 = “Hello”

string2 = “!”

result = f”{string1} world{string2}”

Print

Print в Python не так прост, как может показаться на первый взгляд. Его возможности по конкатенации строк могу пригодиться вам, если вы будете выводить информацию в файл. Разберемся в следующем куске кода:

with open('result.txt', 'w', encoding='utf-8') as file1:

for i in range(1, 4):

print(i, i**2, i**3, sep=”->”, end=” | ”, file=file1)

В результате выполнения в файл запишется: 1->1->1 | 2->4->8 | 3->9->27

Что произошло? В первой строке мы просто открываем файл безопасным образом – он автоматически закроется, когда код будет выполнен. Далее мы запускаем цикл от 1 до 3, для каждого числа мы выводим его квадрат и 3-ю степень. Для этого мы используем print и 2 именованных аргумента: sep и end. Sep – это разделитель, который вставляется между аргументами, которые мы передаем в print, по умолчанию sep – пробел. End – это то, что вставляется в конце строки, по умолчанию это перевод курсора на новую строку (\n). Поскольку мы переопределили их, вместо пробела между аргументами вставляется «->», а вместо перевода строки вставляется « | ». Последний аргумент указывает принту на файл, в который нужно выводить информацию.

Что почитать по теме

• Объяснение f-string на Хабре.
• Обсуждение конкатенации на Stackoverflow.

FAQ

Можно ли изменять строки в Python?

Нет, строки в Python – неизменяемые, поэтому результат конкатенации нужно сохранять в другую переменную или сразу подавать в метод.

Каким методом пользуются чаще всего?

Если производительность не важна, то используют «+». Если операций – много, и производительность начинает иметь значение, то используют join.

Подведем итоги

Тезисно:

• Основные методы конкатенации – «+» и join.
• Чтобы использовать «+», нужно просто поместить слева и справа от него строки для объединения.
• Для того, чтобы использовать join, нужно вызвать его у строки, и в качестве аргумента подать итерируемый объект, содержащий строки.
• При выводе в файл можно конкатенировать строки с помощью print и именованных параметров sep, end и file.

Python String join()

В этом руководстве мы узнаем о методе Python String join() с помощью примеров.

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

Пример

 text = ['Python', 'is', 'a', 'fun', 'programming', 'language']
 
 # соединяем элементы текста пробелом
печать(' '. присоединиться(текст)) 
# Вывод: Python — интересный язык программирования 

---

Синтаксис String join()

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

  string.join(iterable)  

---

Параметры join()

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

Некоторые примеры итерируемых объектов:

• Собственные типы данных — Список, Кортеж, Строка, Словарь и Набор.
• Файловые объекты и объекты, которые вы определяете с помощью __iter__() или __getitem()__ метод.

Примечание

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

---

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

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

Если итерируемый объект содержит какие-либо нестроковые значения, возникает исключение TypeError .

---

Пример 1: Работа метода join()

 # .join() со списками
numList = ['1', '2', '3', '4']
разделитель = ', '
 
 печать (separator.join (numList)) 
# .join() с кортежами
numTuple = ('1', '2', '3', '4')
 
 печать (separator.join (numTuple)) 
с1 = 'абв'
с2 = '123'
# каждый элемент s2 разделен s1
# '1'+ 'abc'+ '2'+ 'abc'+ '3'
 
 print('s1.join(s2):', s1.join(s2)) 
# каждый элемент s1 разделен s2
# 'а'+ '123'+ 'б'+ '123'+ 'б'
 
 print('s2.join(s1):', s2.join(s1)) 
 

Вывод

  1, 2, 3, 4
1, 2, 3, 4
s1.join(s2): 1abc2abc3
s2.join(s1): a123b123c  

---

Пример 2: Метод join() с наборами

 # . join() с наборами
тест = {'2', '1', '3'}
с = ', '
 
 печать (s.join (тест)) 
тест = {'Питон', 'Ява', 'Руби'}
с = '->->'
 
 печать (s.join (тест)) 
 

Выход

  2, 3, 1
Python->->Ruby->->Java  

Примечание: Набор — это неупорядоченный набор элементов, поэтому вы можете получить другой вывод (порядок случайный).

---

Пример 3: Метод join() со словарями

 # .join() со словарями
тест = {'мат': 1, 'это': 2}
с = '->'
# соединяет только ключи
 
 печать (s.join (тест)) 
тест = {1: 'коврик', 2: 'это'}
с = ', '
# выдает ошибку, так как ключ не является строкой
 
 print(s.join(test)) 
 

Вывод

  мат->то
Traceback (последний последний вызов):
  Файл "...", строка 12, в 
TypeError: элемент последовательности 0: ожидаемый экземпляр str, найдено int  

Метод join() пытается соединить ключи (не значения) словаря с разделителем строк.

Примечание . Если ключ строки не является строкой, возникает исключение TypeError .

Метод Python String join()

Сохранить статью

Нравится Статья

Striver

master

415 опубликованных статей

Читать

Обсудить

Улучшить статью

Сохранить статью

Нравится Статья

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

Синтаксис: string_name .join(iterable)

Параметры:  

• Iterable — объекты, способные возвращать свои элементы по одному. Некоторые примеры: List, Tuple, String, Dictionary , и Set

Возвращаемое значение: Метод join() возвращает строку, объединенную с элементами iterable .

Ошибка типа : Если итерируемый объект содержит какие-либо нестроковые значения, возникает исключение TypeError.

Пример 1: Соединение с помощью пустой строки

Здесь мы соединяем список элементов, используя метод соединения.

Python3

список1 = [ 'g' , 9 0005 ‘е’ , 'е' , 'к' , 's' ] print ("".join(list1))   список1 = "гики" печать ( "$" .join(list1))

Вывод:

 гиков
$g$e$e$k$s$ 

Временная сложность: O(n)
Вспомогательный пробел: O(n)

Пример 2:

Соединение строки с списками с помощью join()

Здесь мы соединяем кортежи элементов с помощью метода join(), в котором мы можем поместить любой символ для соединения со строкой.

Python3

список1 = ( '1' , 90 005 ‘2’ , '3' , '4' )   с = "-"   с = s.join(list1)   print (s)

Вывод: 

 1-2-3-4 

Временная сложность: O(n)
Вспомогательное пространство: O(n)

Пример 3:

Соединение строки с наборами с помощью join() 90 009

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

Примечание: Набор содержит только уникальное значение, поэтому из двух 4 печатается одно 4.

Python3

список1 = { '1' , '2' , '3' , '4' , '4' 90 005 }   с = "-#- "   s = s.join(list1)   print 90 005 (с)

Вывод:

 1-#-3- #-2-#-4 

Временная сложность: O(n)
Вспомогательный пробел: O(n)

Пример 4: Соединение строки со словарем с помощью функции join()

При соединении строки со словарем она будет соединяться с ключами словаря Python, а не со значениями.