Concatenar elementos de una tupla en una lista en python

Tengo una lista de tuplas que tiene cadenas, por ejemplo:

[('this', 'is', 'a', 'foo', 'bar', 'sentences') ('is', 'a', 'foo', 'bar', 'sentences', 'and') ('a', 'foo', 'bar', 'sentences', 'and', 'i') ('foo', 'bar', 'sentences', 'and', 'i', 'want') ('bar', 'sentences', 'and', 'i', 'want', 'to') ('sentences', 'and', 'i', 'want', 'to', 'ngramize') ('and', 'i', 'want', 'to', 'ngramize', 'it')] 

Ahora deseo concatenar cada cadena en una tupla para crear una lista de cadenas separadas por espacios. Utilicé el siguiente método:

 NewData=[] for grams in sixgrams: NewData.append( (''.join([w+' ' for w in grams])).strip()) 

que está funcionando perfectamente bien.

Sin embargo, la lista que tengo tiene más de un millón de tuplas. Así que mi pregunta es si este método es lo suficientemente eficiente o hay alguna forma mejor de hacerlo. Gracias.

Para una gran cantidad de datos, debe considerar si necesita mantener todo en una lista. Si está procesando cada una a la vez, puede crear un generador que generará cada cadena unida, pero no las mantendrá ocupadas en la memoria:

 new_data = (' '.join(w) for w in sixgrams) 

Si también puede obtener las tuplas originales de un generador, también puede evitar tener la lista de sixgrams en la memoria.

La lista de comprensión crea cadenas temporales. Solo use ' '.join en ' '.join lugar.

 >>> words_list = [('this', 'is', 'a', 'foo', 'bar', 'sentences'), ... ('is', 'a', 'foo', 'bar', 'sentences', 'and'), ... ('a', 'foo', 'bar', 'sentences', 'and', 'i'), ... ('foo', 'bar', 'sentences', 'and', 'i', 'want'), ... ('bar', 'sentences', 'and', 'i', 'want', 'to'), ... ('sentences', 'and', 'i', 'want', 'to', 'ngramize'), ... ('and', 'i', 'want', 'to', 'ngramize', 'it')] >>> new_list = [] >>> for words in words_list: ... new_list.append(' '.join(words)) # <--------------- ... >>> new_list ['this is a foo bar sentences', 'is a foo bar sentences and', 'a foo bar sentences and i', 'foo bar sentences and i want', 'bar sentences and i want to', 'sentences and i want to ngramize', 'and i want to ngramize it'] 

El bucle anterior for se puede express como la siguiente lista de comprensión:

 new_list = [' '.join(words) for words in words_list] 

Puedes hacer esto eficientemente así

 joiner = " ".join print map(joiner, sixgrams) 

Todavía podemos mejorar el rendimiento utilizando la comprensión de lista como esta

 joiner = " ".join print [joiner(words) for words in sixgrams] 

La comparación de rendimiento muestra que la solución de comprensión de lista vista anteriormente es ligeramente más rápida que otras dos soluciones.

 from timeit import timeit joiner = " ".join def mapSolution(): return map(joiner, sixgrams) def comprehensionSolution1(): return ["".join(words) for words in sixgrams] def comprehensionSolution2(): return [joiner(words) for words in sixgrams] print timeit("mapSolution()", "from __main__ import joiner, mapSolution, sixgrams") print timeit("comprehensionSolution1()", "from __main__ import sixgrams, comprehensionSolution1, joiner") print timeit("comprehensionSolution2()", "from __main__ import sixgrams, comprehensionSolution2, joiner") 

Salida en mi máquina

 1.5691678524 1.66710209846 1.47555398941 

La ganancia de rendimiento es más probable debido al hecho de que, no tenemos que crear la función de unión desde la cadena vacía cada vez.

Edit: Aunque podemos mejorar el rendimiento de esta manera, la forma más pirónica es ir con generadores como en la respuesta de lvc .