Ответ 1
Посмотрите на Guido essay на оптимизацию python, он охватывает преобразование списков чисел в строки. Если у вас нет оснований для этого, используйте пример join.
Большинство питоновских способов конкатенации строк
Учитывая этот безобидный небольшой список:
>>> 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) и тарифные решения, дающие краткие объяснения.
В этом случае, является ли наиболее питоновское решение лучшим решением для кодирования?
Ответы
Ответ 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 или другая аналогичная специализированная функция для массивов)