Risposte:
Utilizzare il join
metodo della stringa vuota per unire tutte le stringhe insieme alla stringa vuota in mezzo, in questo modo:
>>> a = ['a', 'b', 'c', 'd']
>>> ''.join(a)
'abcd'
' '.join(list)
uno spazio tra le virgolette
"".join(['a','b','c'])
significa Join all elements of the array, separated by the string ""
. Allo stesso modo, " hi ".join(["jim", "bob", "joe"])
creerà "jim hi bob hi joe"
.
Funziona in molte lingue popolari come JavaScript e Ruby, perché non in Python?
>>> ['a', 'b', 'c'].join('')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute 'join'
Abbastanza strano, in Python il join
metodo è sulla str
classe:
# this is the Python way
"".join(['a','b','c','d'])
Perché join
un metodo list
nell'oggetto non è simile a JavaScript o ad altri linguaggi di script popolari? È un esempio di come pensa la comunità Python. Poiché join restituisce una stringa, deve essere inserito nella classe stringa, non nella classe elenco, quindi il str.join(list)
metodo significa: unire l'elenco in una nuova stringa usando str
come separatore (in questo caso str
è una stringa vuota).
In qualche modo ho imparato ad amare questo modo di pensare dopo un po '. Posso lamentarmi di molte cose nel design di Python, ma non della sua coerenza.
string.join()
con la maggior parte delle raccolte con un join()
metodo in molti linguaggi dinamici. Per quanto riguarda gli iterabili, suppongo che non sia un problema per tali lingue perché è altrettanto facile (e leggibile) racchiudere l'iterabile in un costruttore di raccolte e una catena nel join()
metodo.
Se il tuo interprete Python è vecchio (1.5.2, ad esempio, che è comune su alcune vecchie distribuzioni Linux), potresti non essere join()
disponibile come metodo su qualsiasi vecchio oggetto stringa e dovrai invece usare il modulo stringa. Esempio:
a = ['a', 'b', 'c', 'd']
try:
b = ''.join(a)
except AttributeError:
import string
b = string.join(a, '')
La stringa b
sarà 'abcd'
.
Questo potrebbe essere il modo più veloce:
>> from array import array
>> a = ['a','b','c','d']
>> array('B', map(ord,a)).tostring()
'abcd'
''.join(['a','b','c'])
map(ord,a)
non è necessario, ma le esigenze di join map(chr,a)
. Ecco il mio benchmark pastebin.com/1sKFm8ma
''.join()
è molto più leggibile.
La funzione di riduzione funziona anche
import operator
h=['a','b','c','d']
reduce(operator.add, h)
'abcd'
(reduce + '' h)
o (apply + h)
avrebbe funzionato. Ma poi di nuovo, in Python, l'operatore add prende esattamente 2 operandi, quindi la necessità di ridurre. Altrimenti, potresti farlo operator.add(*h)
, dato che apply
è stato ufficialmente deprecato in Python a favore della sintassi estesa delle chiamate (aka en.wikipedia.org/wiki/Variadic_function )
Se l'elenco contiene numeri, è possibile utilizzare map()
con join()
.
Per esempio:
>>> arr = [3, 30, 34, 5, 9]
>>> ''.join(map(str, arr))
3303459
''.join([str(i) for i in arr])
h = ['a','b','c','d','e','f']
g = ''
for f in h:
g = g + f
>>> g
'abcdef'
''.join(h)
supererebbe di gran lunga il metodo di aggiunta uno a uno.
oltre a str.join
quale è il modo più naturale, una possibilità è quella di usare io.StringIO
e abusare writelines
per scrivere tutti gli elementi in una volta sola:
import io
a = ['a','b','c','d']
out = io.StringIO()
out.writelines(a)
print(out.getvalue())
stampe:
abcd
Quando si utilizza questo approccio con una funzione del generatore o un iterabile che non è un tuple
o un list
, si salva la creazione dell'elenco temporaneo che join
consente di allocare la giusta dimensione in una volta (e un elenco di stringhe di 1 carattere è molto costoso in termini di memoria ).
Se hai poca memoria e hai un oggetto valutato pigramente come input, questo approccio è la soluzione migliore.
Puoi anche usare operator.concat()
così:
>>> from operator import concat
>>> a = ['a', 'b', 'c', 'd']
>>> reduce(concat, a)
'abcd'
Se stai usando Python 3 devi anteporre:
>>> from functools import reduce
da quando il builtin reduce()
è stato rimosso da Python 3 e ora vive in functools.reduce()
.