ver - substituir valores numa lista python




Como concatenar duas listas em Python? (19)

Com o Python 3.3+, você pode usar o rendimento 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]

Ou, se você quiser suportar um número arbitrário 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]

Como faço para concatenar duas listas em Python?

Exemplo:

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

Resultado esperado:

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

Como já foi apontado por muitos, itertools.chain() é o caminho a percorrer se é necessário aplicar exatamente o mesmo tratamento para ambas as listas. No meu caso, eu tinha um rótulo e uma bandeira que eram diferentes de uma lista para outra, então eu precisava de algo um pouco mais complexo. Como se vê, nos bastidores itertools.chain() simplesmente faz o seguinte:

for it in iterables:
    for element in it:
        yield element

(veja https://docs.python.org/2/library/itertools.html ), então me inspirei aqui e escrevi algo ao longo destas linhas:

for iterable, header, flag in ( (newList, 'New', ''), (modList, 'Modified', '-f')):
    print header + ':'
    for path in iterable:
        [...]
        command = 'cp -r' if os.path.isdir(srcPath) else 'cp'
        print >> SCRIPT , command, flag, srcPath, mergedDirPath
        [...]

Os principais pontos a serem entendidos aqui são que as listas são apenas um caso especial de iteráveis, que são objetos como qualquer outro; e for ... in loops for ... in python podem trabalhar com variáveis ​​tuple, então é simples fazer loop em múltiplas variáveis ​​ao mesmo tempo.


Em Python, você pode concatenar duas matrizes de dimensões compatíveis com este comando

numpy.concatenate([a,b])

Então, existem duas maneiras fáceis.

  1. Usando + : Cria uma nova lista das listas fornecidas

Exemplo:

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 estender : Acrescenta nova lista à lista existente. Isso significa que não cria uma lista separada.

Exemplo:

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

Assim, vemos que dos dois métodos mais populares, extend é eficiente.


Estou surpreso, parece que ninguém propôs usar uma simples compreensão de lista :

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

Ele tem todas as vantagens da mais nova abordagem de usar Generalizações Adicionais de Desempacotamento - ou seja, você pode concatenar um número arbitrário de iteráveis ​​diferentes (por exemplo, listas, tuplas, intervalos, geradores) dessa maneira - e não está limitado a Python >= 3.5 .


Isso é bem simples, acho que até foi mostrado no tutorial :

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

Se você não pode usar o operador mais ( + ), você pode usar a função __add__ :

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

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

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

Alternativamente, se você não gosta do uso de dunders você pode usar a importação do operator :

import operator

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

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

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

Alguém poderia argumentar que isso é um pouco mais legível.


Se você precisar mesclar duas listas ordenadas com regras de ordenação complicadas, você pode ter que rolá-las como no código a seguir (usando uma regra de classificação simples para facilitar a leitura :-)).

list1 = [1,2,5]
list2 = [2,3,4]
newlist = []

while list1 and list2:
    if list1[0] == list2[0]:
        newlist.append(list1.pop(0))
        list2.pop(0)
    elif list1[0] < list2[0]:
        newlist.append(list1.pop(0))
    else:
        newlist.append(list2.pop(0))

if list1:
    newlist.extend(list1)
if list2:
    newlist.extend(list2)

assert(newlist == [1, 2, 3, 4, 5])

Se você quisesse uma nova lista, mantendo as duas listas antigas:

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

    sorted(joinedList)

    return joinedList

Também é possível criar um gerador que simplesmente repita os itens nas duas listas. Isso permite encadear listas (ou qualquer iterável) juntas para processamento sem copiar os itens para uma nova lista:

import itertools
for item in itertools.chain(listone, listtwo):
   # do something with each list item

Vale a pena notar que a função itertools.chain aceita um número variável 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']

Se uma iterável (tupla, lista, gerador, etc.) for a entrada, o método da classe from_iterable pode ser usado:

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

Você pode ir para a função list.extend .

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

Saída:

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


Você pode usar conjuntos para obter uma lista mesclada de valores exclusivos

mergedlist = list(set(listone + listtwo))

Você pode usar o operador + para combiná-los:

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

mergedlist = listone + listtwo

Saída:

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

Você poderia usar o método append() definido em objetos de list :

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)

Você também pode usar extend para adicionar uma list adicionar o final de outro:

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

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))

Saída:

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]

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

print (c) dá

[1,2,3,4,5,6,7,8,9,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