Самый эффективный способ объединения строк в Python

Question

Во время задания этого вопроса я использую Python 3.8

Когда я говорю «эффективный», я имею в виду только скорость, с которой соединяются строки или, если говорить более технически, я спрашиваю о сложности времени, а не о сложности пространства.

Единственные методы, которые я могу придумать на данный момент, - это следующие 3, учитывая, что:

a = 'start'
b = ' end'

Метод 1

result = a + b

Метод 2

result = ''.join((a, b))

Метод 3

result = '{0}{1}'.format(a, b)

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

Edit

После просмотра всех комментариев и ответы, я узнал несколько новых способов объединения строк, а также я узнал о библиотеке timeit . Я сообщу о своих личных находках ниже:

>>> import timeit

>>> print(timeit.Timer('result = a + b', setup='a = "start"; b = " end"').timeit(number=10000))
0.0005306000000473432

>>> print(timeit.Timer('result = "".join((a, b))', setup='a = "start"; b = " end"').timeit(number=10000))
0.0011297000000354274

>>> print(timeit.Timer('result = "{0}{1}".format(a, b)', setup='a = "start"; b = " end"').timeit(number=10000))
0.002327799999989111

>>> print(timeit.Timer('result = f"{a}{b}"', setup='a = "start"; b = " end"').timeit(number=10000))
0.0005772000000092703

>>> print(timeit.Timer('result = "%s%s" % (a, b)', setup='a = "start"; b = " end"').timeit(number=10000))
0.0017815999999584164

Кажется, что для этих небольших строк традиционный a + b метод является самым быстрым для конкатенации строк. Спасибо за все ответы!

Answer 1

Для ровно двух строк a и b просто используйте a + b. Альтернативы для объединения больше , чем 2 строки, избегая временного объекта str, создаваемого при каждом использовании +, а также поведения quadrati c из-за многократного копирования содержимого предыдущих операций в следующем результате.

(Там также f'{a}{b}', но он синтаксически тяжелее и не быстрее a + b.)

Answer 2

Почему бы тебе не попробовать? Вы можете использовать timeit.timeit () , чтобы многократно выполнять оператор и возвращать общую продолжительность.

Здесь мы используем s для установки переменных a и b (не входит в общее время), а затем запустите различные варианты 10 миллионов раз.

>>> from timeit import timeit
>>>
>>> n = 10 * 1000 * 1000
>>> s = "a = 'start'; b = ' end'"
>>>
>>> timeit("c = a + b",                 setup=s, number=n)
0.4452877212315798
>>>
>>> timeit("c = f'{a}{b}'",             setup=s, number=n)
0.5252049304544926
>>>
>>> timeit("c = '%s%s'.format(a, b)",   setup=s, number=n)
0.6849184390157461
>>>>
>>> timeit("c = ''.join((a, b))",       setup=s, number=n)
0.8546998891979456
>>>
>>> timeit("c = '%s%s' % (a, b)",       setup=s, number=n)
1.1699129864573479
>>>
>>> timeit("c = '{0}{1}'.format(a, b)", setup=s, number=n)
1.5954962372779846

Это показывает, что, если узким местом вашего приложения является конкатенация строк, вероятно, не стоит слишком беспокоиться о ...

• Наилучший случай - ~ 0,45 секунды для 10 миллионов итераций, или около 45 нс на операцию.
• Наихудший случай - ~ 1,59 секунды для 10 миллионов итераций, или около 159 нс на операцию. .

Если вы выполняете буквально миллионов операций, вы увидите улучшение скорости примерно на 1 секунду.

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

Answer 3

from datetime import datetime
a = "start"
b = " end"

start = datetime.now()
print(a+b)
print(datetime.now() - start)

start = datetime.now()
print("".join((a, b)))
print(datetime.now() - start)

start = datetime.now()
print('{0}{1}'.format(a, b))
print(datetime.now() - start)

# Output
# start end
# 0:00:00.000056
# start end
# 0:00:00.000014
# start end
# 0:00:00.000014

Похоже, что .join () и .format () в основном одинаковы и в 4 раза быстрее. Строка F, например:

print(f'{a} {b}')

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