Большинство питоновских способов конкатенации строк

Учитывая этот безобидный небольшой список:

>>> lst = ['o','s','s','a','m','a']

Моя цель состоит в том, чтобы pythonically конкатенировать маленьких дьяволов одним из следующих способов:

а. plain ol 'string, чтобы выполнить задание, короткий, без импорта

>>> ''.join(lst)
'ossama'

В. лямбда, лямбда, лямбда

>>> reduce(lambda x, y: x + y, lst)
'ossama'

С. глобализация (ничего не делать, импортировать все)

>>> import functools, operator
>>> functools.reduce(operator.add, lst)
'ossama'

Просьба предложить другие питонические способы достижения этой великодушной задачи.

Пожалуйста, оцените (уровень pythonic) и тарифные решения, дающие краткие объяснения.

В этом случае, является ли наиболее питоновское решение лучшим решением для кодирования?

Ответ 1

Посмотрите на Guido essay на оптимизацию python, он охватывает преобразование списков чисел в строки. Если у вас нет оснований для этого, используйте пример join.

Ответ 2

''.join(lst)

единственный питонический путь:

ясно (что делают все большие мальчики и что они ожидают увидеть),
простой (дополнительный импорт не требуется, стабильный во всех версиях),
быстрый (написанный на C) и
кратким (на пустой строке объединяются элементы итерации!).

Ответ 3

Конечно, это join. Откуда мне знать? Позвольте сделать это по-настоящему глупо:
Если проблема заключалась только в добавлении 2 строк, вы, скорее всего, используете str1 + str2. Что нужно, чтобы перейти на следующий уровень? Инстинктивно, для большинства (я думаю), будет использовать sum. Посмотрим, как это получится:

In [1]: example = ['a', 'b', 'c']
In [2]: sum(example, '')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython console> in <module>()
TypeError: sum() can't sum strings [use ''.join(seq) instead]

Ничего себе! Python просто сказал мне, что использовать!:)

Ответ 4

Здесь наименее Pythonic путь:

out = ""
for x in range(len(lst)):
  for y in range(len(lst)):
    if x + y == len(lst)-1:
        out = lst[y] + out

Ответ 5

Я сам использую метод "join", но из python 2.6 существует базовый тип, который мало используется: bytearray.

Bytearrays может быть невероятно полезным - для строк, содержащих тексты, поскольку лучше всего иметь в этом случае в юникоде, путь "присоединиться" - это путь, но если вы имеете дело с двоичными данными, то bytearrays может быть более питоническим и более эффективным:

>>> lst = ['o','s','s','a','m','a']
>>> a = bytearray(lst)
>>> a
bytearray(b'ossama')
>>> print a
ossama

это встроенный тип данных: импорт не требуется - просто используйте его - и вы можете использовать bytearray isntead из списка для начала - поэтому они должны быть более эффективными, чем "join", поскольку нет копирование данных, чтобы получить строковое представление для bytearray.

Ответ 6

Отличный ответ от SilenGhost BUT, всего несколько слов о представленной альтернативе reduce

Если у вас очень хорошая ОЧЕНЬ хорошая причина для объединения строк с использованием + или operator.add (наиболее частая, у вас мало, фиксированное количество строк), вы должны всегда использовать join.

Просто потому, что каждый + создает новую строку, которая представляет собой конкатенацию двух строк, если только объединение не создает только одну окончательную строку. Итак, представьте, что у вас есть 3 строки:

A + B + C
-->
D = A + B
final = D + C

Хорошо, кажется, не очень много, но у вас есть резервная память для D. Кроме того, из-за использования python строк, создания новой, промежуточной строки, это как-то дорого...

Теперь, с 5 строками

A + B + C + D + E
-->
F = A + B
G = F + C
H = G + D
final = H + E

Предполагая лучший сценарий (если мы делаем (A + B) + (C + D) + E, мы закончим с тремя промежуточными строками одновременно в памяти), которые генерируют 3 промежуточных строки... Вы нам нужно создать новый объект python, зарезервировать пространство памяти, несколько раз освободить память... Также накладные расходы на вызов функции Python (что не мало)

Теперь подумайте об этом с 200 строками. Мы закончим смехотворное большое количество промежуточных строк, каждый из которых потребляет много времени, чтобы быть полным списком на python, и вызывая множество функций operator.add, каждый из которых имеет накладные расходы... Даже если вы используете функции reduce, это не поможет. Это проблема, которая должна управляться с помощью другого подхода: join, который генерирует только ONE полную строку python, последнюю и вызывает ONE функцию python.

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