vacia - union de listas python




¿Cómo concatenar dos listas en Python? (19)

Así que hay dos formas fáciles.

  1. Usando + : Crea una nueva lista a partir de listas proporcionadas

Ejemplo:

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: a + b
Out[3]: [1, 2, 3, 4, 5, 6]

In [4]: %timeit a + b
10000000 loops, best of 3: 126 ns per loop
  1. Usando extend : Agrega una nueva lista a la lista existente. Eso significa que no crea una lista separada.

Ejemplo:

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: %timeit a.extend(b)
10000000 loops, best of 3: 91.1 ns per loop

Así vemos que de los dos métodos más populares, extend es eficiente.

¿Cómo concatenar dos listas en Python?

Ejemplo:

listone = [1, 2, 3]
listtwo = [4, 5, 6]

Gastos esperados:

>>> joinedlist
[1, 2, 3, 4, 5, 6]

Como una forma más general para más listas, puede colocarlas dentro de una lista y usar la función itertools.chain.from_iterable() 1 que, según THIS respuesta, es la mejor manera de acoplar una lista anidada:

>>> l=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> import itertools
>>> list(itertools.chain.from_iterable(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9] 

1. Tenga en cuenta que chain.from_iterable() está disponible en python => 2.6.En otras versiones use chain(*l)


Con Python 3.3+ puedes usar el rendimiento de :

listone = [1,2,3]
listtwo = [4,5,6]

def merge(l1, l2):
    yield from l1
    yield from l2

>>> list(merge(listone, listtwo))
[1, 2, 3, 4, 5, 6]

O, si desea admitir un número arbitrario de iteradores:

def merge(*iters):
    for it in iters:
        yield from it

>>> list(merge(listone, listtwo, 'abcd', [20, 21, 22]))
[1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 20, 21, 22]

En Python puedes concatenar dos matrices de dimensiones compatibles con este comando

numpy.concatenate([a,b])

Esto es bastante simple, creo que incluso se mostró en el tutorial :

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]

Me sorprende que parece que nadie propuso usar una lista de comprensión simple :

joined_list = [y for x in [list_one, list_two] for y in x]

Tiene todas las ventajas del enfoque más nuevo de usar generalizaciones de desempaquetado adicionales , es decir, puede concatenar un número arbitrario de diferentes iterables (por ejemplo, listas, tuplas, rangos, generadores) de esa manera, y no se limita a Python >= 3.5 .


Puede usar conjuntos para obtener una lista combinada de valores únicos

mergedlist = list(set(listone + listtwo))

Puede utilizar la función de extends

listone.extends(listtwo)

Si desea combinar las dos listas en forma ordenada, puede usar la función de combinación de la biblioteca heapq.

from heapq import merge

a = [1,2,4]
b = [2,4,6,7]

print list(merge(a,b))

Si desea una nueva lista manteniendo las dos listas antiguas:

def concatenate_list(listOne, listTwo):
    joinedList = []
    for i in listOne:
        joinedList.append(i)
    for j in listTwo:
        joinedList.append(j)

    sorted(joinedList)

    return joinedList

Si no puede usar el operador más ( + ), puede usar la función __add__ :

listone = [1,2,3]
listtwo = [4,5,6]

result = list.__add__(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

Alternativamente, si no le gusta el uso de dunders puede usar la importación del operator :

import operator

listone = [1,2,3]
listtwo = [4,5,6]

result = operator.add(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

Se podría argumentar que esto es un poco más legible.


Simplemente puede utilizar el operador + o += siguiente manera:

a = [1, 2, 3]
b = [4, 5, 6]

c = a + b

O:

c = []
a = [1, 2, 3]
b = [4, 5, 6]

c += (a + b)

Además, si desea que los valores de la lista fusionada sean únicos, puede hacerlo:

c = list(set(a + b))

También puede usar extend para agregar una list agregar el final de otra:

listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

Una forma realmente concisa de combinar una lista de listas es

list_of_lists = [[1,2,3], [4,5,6], [7,8,9]]
reduce(list.__add__, list_of_lists)

lo que nos da

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Usted puede ir para la función list.extend .

l1 = [1,2,3]
l2 = [4,5,6]
l1.extend(l2)
print l1

Salida:

[1,2,3,4,5,6]


Vale la pena señalar que la función itertools.chain acepta un número variable de argumentos:

>>> l1 = ['a']; l2 = ['b', 'c']; l3 = ['d', 'e', 'f']
>>> [i for i in itertools.chain(l1, l2)]
['a', 'b', 'c']
>>> [i for i in itertools.chain(l1, l2, l3)]
['a', 'b', 'c', 'd', 'e', 'f']

Si se ingresa un iterable (tupla, lista, generador, etc.), se puede usar el método de clase from_iterable :

>>> il = [['a'], ['b', 'c'], ['d', 'e', 'f']]
>>> [i for i in itertools.chain.from_iterable(il)]
['a', 'b', 'c', 'd', 'e', 'f']

a = [1,2,3,4,5,6]
b = [7,8,9,10]
c = a.extend(b)

imprimir (c) da

[1,2,3,4,5,6,7,8,9,10]

import itertools

A = list(zip([1,3,5,7,9],[2,4,6,8,10]))
B = [1,3,5,7,9]+[2,4,6,8,10]
C = list(set([1,3,5,7,9] + [2,4,6,8,10]))

D = [1,3,5,7,9]
D.append([2,4,6,8,10])

E = [1,3,5,7,9]
E.extend([2,4,6,8,10])

F = []
for a in itertools.chain([1,3,5,7,9], [2,4,6,8,10]):
    F.append(a)


print ("A: " + str(A))
print ("B: " + str(B))
print ("C: " + str(C))
print ("D: " + str(D))
print ("E: " + str(E))
print ("F: " + str(F))

Salida:

A: [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
B: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
C: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
D: [1, 3, 5, 7, 9, [2, 4, 6, 8, 10]]
E: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
F: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

lst1 = [1,2]

lst2 = [3,4]

def list_combinationer(Bushisms, are_funny):

    for item in lst1:
        lst2.append(item)
        lst1n2 = sorted(lst2)
        print lst1n2

list_combinationer(lst1, lst2)

[1,2,3,4]




list