5 способов конкатенировать строки в Python 3
Конкатенация строк — операция, «склеивающая» несколько строк в одну. Это нельзя назвать особенностью языка, поскольку она присутствует и в PHP, и в Java и много где еще. Для сегодняшнего топа я собрал все способы конкатенации, кроме самых нелепых. Представляю вашему вниманию 5 способов конкатенации строк в Python 3. Сегодня мы рассмотрим варианты множественной конкатенации с применением соединительной строки.
Начнем с проверенной классики — оператора сложения для последовательной конкатенации. Думаю, всем известно, как это работает. Недостаток данного способа — в функции должно быть фиксированное число строк. Вы должны точно знать, сколько в списке строк. Я надумал 2 варианта реализации. Первый — с передачей в аргументы функции всех строк через запятую:
def conc1_1(one, tho, three, four, symbol): return one + symbol + two + symbol + three + symbol + four
Второй — со списком строк в аргументах:
def conc1_2(strings, symbol): return strings[0] + symbol + strings[1] + symbol + strings[2] + symbol + strings[3]
Здесь мы используем строковый метод join(), выполняющий конкатенацию с использованием соединительной строки. Это самое короткий и логичный ответ на такой случай:
def conc2(strings, symbol): return symbol.join(strings)
Если нам не известно количество строк в списке, и почему-то мы не используем метод join() (не могу себе представить такую ситуацию), то этот вариант для нас. Он аналогичен работе метода join()
Как это работает? Присваиваем переменной результата значение первой строки из списка и поочередно конкатенируем к нему соединительный символ и следующие в списке строки, пока не закончится список:
def conc3(strings, symbol): res = strings[0] for i in strings[1::]: res = res + symbol + i return res
Давайте вспомним, что с версии Python 2.6 существует метод format(), предоставляющий возможности форматирования строк. Строки из его аргументов подставляются в исходную строку вместо <>. Поставив рядом две и более пары фигурных скобок, можно соединить 2 и более строк. Аргументы могут быть по умолчанию, а могут быть нумерованными или именованными.
Я написал 2 варианта программы с использованием аргументов по умолчанию и нумерованных:
def conc4_1(strings, symbol): res = strings[0] for i in strings[1::]: res = «<><><>«.format(res, symbol, i) return res
def conc4_2(strings, symbol): res = strings[0] for i in strings[1::]: res = «<0>«.format(res, symbol, i) return res
А здесь напомню про форматирование строк без метода format(), позаимствованное из C (это я прочитал на форуме). Работает оно точно так же, как и встроенный метод, но не позволяет передавать нумерованные и именованные аргументы. В общем вот:
def conc5(strings, symbol): res = strings[0] for i in strings[1::]: res = «%s%s%s» % (res, symbol, i) return res
Примечание: кроме всех указанных способов, я что-то написал. и сам не до конца понял, что я написал. Затем я понял, что накодил чушь. Я проверил, заранее говорю — этот способ самый медленный из всех, поэтому я решил не включать его в основной топ, но все же, вот он:
def conc6(strings, symbol): res = strings[0] list_of_strings = list(strings) for i in range(1, len(strings)): list_of_strings.insert(i + i — 1, symbol) for i in list_of_strings[1::]: res = res + i return res
Статистика быстродействия
Для начала — как измерить время работы программы? Об этом я расскажу в следующей статье. Ну а пока что измерим время работы данного куска кода, где i — одна из шести функций (conc1_2, conc2, conc3, conc4_1, conc4_2, conc5):
Соединить две строки и вывести резульат
Операция объединения строк по-умному называется конкатенацией. В Python для конкатенации используется оператор + (плюс):
s1 = 'qwertyuiopasd' s2 = 'fghjklzxcvbnm' print(s1 + s2) qwertyuiopasdfghjklzxcvbnm Можно положить результат в переменную и вывести уже её:
s1 = 'qwertyuiopasd' s2 = 'fghjklzxcvbnm' s3 = s1 + s2 print(s3) Отслеживать
ответ дан 31 авг 2017 в 11:20
12.9k 10 10 золотых знаков 40 40 серебряных знаков 77 77 бронзовых знаков
Что тут происходит? У тебя истерика?)
31 авг 2017 в 11:42
а как числа складывать?
31 авг 2017 в 15:29
- python
- python-3.x
-
Важное на Мете
Похожие
Подписаться на ленту
Лента вопроса
Для подписки на ленту скопируйте и вставьте эту ссылку в вашу программу для чтения RSS.
Дизайн сайта / логотип © 2023 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2023.11.15.1019
Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.
Как работает конкатенация строк в 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 "", line 1, in TypeError: can only concatenate str (not "int") to str
Мы можем использовать str() function для представленя объекта в виде строки.
Давайте посмотрим как конкатенировать строку и число или другой объект.
print('Питонист' + str(4)) class Data: def __init__(self, i): self.id = i def __str__(self): return 'Номер[' + str(self.id) + ']' print('Питонист ' + str(Data(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 = " ".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' ' print('String Concatenation using f-string =', s3) name = 'Pankaj' age = 34 d = Data(10) print(f' age is and 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
На данный момент этот блок не поддерживается, но мы не забыли о нём! Наша команда уже занята его разработкой, он будет доступен в ближайшее время.
Как вы, наверное, знаете один из принципов в Python: “Должен быть один и только один способ сделать что-либо”. Можете убедиться в этом, выполнив в в интерпретаторе import this (вы увидите Дзен Python). Несмотря на это, иногда вам всё равно приходится выбирать между несколькими способами сделать что-то, и не всегда очевидно, какой способ лучше. Недавно один студент спросил меня, какой способ конкатенации строк в Python самый эффективный. Я решил поделиться результатом своего маленького исследования и с вами.
Для начала вспомним, какие способы объединения строк предоставляет нам Python. Во-первых, это оператор + :
>> 'abc' + 'def' 'abcdef' Также мы можем использовать оператор % , который, конечно, может использоваться не только для соединения строк, но и для этого тоже:
>>> "%s%s" % ('abc', 'def') 'abcdef' Есть и ещё более современная замена % — это str.format :
>>> ''.format('abc', 'def') 'abcdef' Так же, как и % , этот метод гораздо мощнее, чем обычный + , но тем не менее строки соединяют и с его помощью.
Как же мы будем замерять время? В Jupyter (так же известном, как IPython) мы можем использовать магическую команду timeit для запуска кода. Для запуска я подготовил четыре функции, каждая из которых складывает строки разным образом. Исходные строки хранятся в глобальных переменных ( x и y ), а локальная (для каждой функции) переменная z содержит результат сложения. Затем функция возвращает результат.
def concat1(): z = x + y return z def concat2(): z = "%s%s" % (x, y) return z def concat3(): z = "<><>".format(x, y) return z def concat4(): z = "".format(x, y) return z Конечно concat3() и concat4() фактически одинаковы, но я решил проверить и то, влияет указание порядка строк на скорость или нет. Затем я определил наши глобальные переменные:
x = 'abc' y = 'def' И запустил наши функции:
%timeit concat1() %timeit concat2() %timeit concat3() %timeit concat4() Результат оказался следующим:
- concat1: 153 наносекунды;
- concat2: 275 наносекунд;
- concat3: 398 наносекунд;
- concat4: 393 наносекунды.
Здесь мы можем видеть, что concat1() , который использует оператор + , выполняется гораздо быстрее остальных. Это немного расстроило меня, потому что мне очень нравится str.format , однако теперь в задачах, которые требуют огромного количества обработки строк, от него придётся отказаться.
Возможно, такие результаты могут быть связаны с тем, что короткие строки не создаются в Python каждый раз снова, а хранятся в специальной таблице? Давайте попробуем изменить наши глобальные переменные следующим образом:
x = 'abc' * 10000 y = 'def' * 10000 Теперь мы получим следующие результаты:
- concat1: 2.64 микросекунды;
- concat2: 3.09 микросекунды;
- concat3: 3.33 микросекунды;
- concat4: 3.48 микросекунды;
Да, каждый из методов теперь работал гораздо дольше, однако общий результат не изменился — оператор + по прежнему лидирует. Заметим так же, что разница во времени между третьим и четвёртым методом, как и ожидалось, пренебрежимо мала.
После этого я попробовал не объявлять переменные глобальными, а задавать их в теле метода, но на результаты это всё равно не повлияло. Разумеется, можно проводить ещё много разных опытов (например, попробовать сложить больше, чем две строки), однако этого уже достаточно, чтобы иметь примерное представление о скоростях работы различных способов сложения строк в языке Python.