Respostas:
append
: Acrescenta um objeto no final.
x = [1, 2, 3]
x.append([4, 5])
print (x)
da-te: [1, 2, 3, [4, 5]]
extend
: Estende a lista acrescentando elementos do iterável.
x = [1, 2, 3]
x.extend([4, 5])
print (x)
da-te: [1, 2, 3, 4, 5]
x + [4, 5]
fornece uma nova lista atribuída a x - x.extend()
altera a lista original. Eu elaboro na minha resposta aqui abaixo.
x += [4,5]
.
append
é Object . Se você tentar usar extend
e passar um dicionário , ele acrescentará a chave e não o hash inteiro ao final da matriz.
append
adiciona um elemento a uma lista e extend
concatena a primeira lista com outra lista (ou outra iterável, não necessariamente uma lista).
>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']
>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]
>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]
>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2], 'two', 'elements']
Qual é a diferença entre os métodos de lista anexados e estendidos?
append
adiciona seu argumento como um único elemento ao final de uma lista. O comprimento da lista em si aumentará em um.extend
itera sobre seu argumento, adicionando cada elemento à lista, estendendo a lista. O comprimento da lista aumentará no entanto, muitos elementos estavam no argumento iterável.append
O list.append
método anexa um objeto ao final da lista.
my_list.append(object)
Qualquer que seja o objeto, seja um número, uma string, outra lista ou qualquer outra coisa, ele é adicionado ao final my_list
como uma única entrada na lista.
>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']
Portanto, lembre-se de que uma lista é um objeto. Se você anexar outra lista a uma lista, a primeira lista será um único objeto no final da lista (que pode não ser o que você deseja):
>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
#^^^^^^^^^--- single item at the end of the list.
extend
O list.extend
método estende uma lista anexando elementos de um iterável:
my_list.extend(iterable)
Portanto, com a extensão, cada elemento do iterável é anexado à lista. Por exemplo:
>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]
Lembre-se de que uma sequência é iterável; portanto, se você estender uma lista com uma sequência, anexará cada caractere à medida que itera sobre a sequência (que pode não ser o que você deseja):
>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']
__add__
( +
) e __iadd__
( +=
)Os operadores +
e +=
são definidos para list
. Eles são semanticamente semelhantes para estender.
my_list + another_list
cria uma terceira lista na memória, para que você possa retornar o resultado, mas requer que a segunda iterável seja uma lista.
my_list += another_list
modifica a lista no local ( é o operador no local e as listas são objetos mutáveis, como vimos), para que não crie uma nova lista. Também funciona como estender, pois o segundo iterável pode ser qualquer tipo de iterável.
Não se confunda - my_list = my_list + another_list
não é equivalente a +=
- ela fornece uma nova lista atribuída a my_list.
O anexo tem complexidade de tempo constante , O (1).
Estender possui complexidade de tempo, O (k).
A repetição de várias chamadas para append
aumentar a complexidade, tornando-a equivalente à extensão, e como a iteração da extensão é implementada em C, sempre será mais rápido se você desejar acrescentar itens sucessivos de uma iterável a uma lista.
Você pode se perguntar o que é de melhor desempenho, já que o anexo pode ser usado para obter o mesmo resultado que o prolongamento. As seguintes funções fazem a mesma coisa:
def append(alist, iterable):
for item in iterable:
alist.append(item)
def extend(alist, iterable):
alist.extend(iterable)
Então vamos cronometrá-los:
import timeit
>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883
Um comentarista disse:
Resposta perfeita, só sinto falta do tempo de comparar adicionando apenas um elemento
Faça a coisa semanticamente correta. Se você deseja anexar todos os elementos em um iterável, use extend
. Se você está apenas adicionando um elemento, use append
.
Ok, então vamos criar um experimento para ver como isso funciona com o tempo:
def append_one(a_list, element):
a_list.append(element)
def extend_one(a_list, element):
"""creating a new list is semantically the most direct
way to create an iterable to give to extend"""
a_list.extend([element])
import timeit
E vemos que sair do nosso caminho para criar uma iterável apenas para usar a extensão é uma (menor) perda de tempo:
>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295
Aprendemos com isso que não se ganha nada usando extend
quando temos apenas um elemento a acrescentar.
Além disso, esses horários não são tão importantes. Estou apenas mostrando a eles que, em Python, fazer a coisa semanticamente correta é fazer as coisas da maneira certa ™.
É concebível que você possa testar os tempos em duas operações comparáveis e obter um resultado ambíguo ou inverso. Apenas se concentre em fazer a coisa semanticamente correta.
Vemos que extend
é semanticamente mais clara, e que ele pode correr muito mais rápido do que append
, quando você pretende anexar cada elemento em uma iterable a uma lista.
Se você tiver apenas um único elemento (não em um iterável) para adicionar à lista, use append
.
ex1 = 0
e ex2 = [0]
) e passar essas variáveis, se você quiser ser mais rigoroso.
l1 += l2
vs l1.extend(l2)
?
l1 += l2
e, l1.extend(l2)
finalmente, executa o mesmo código (a list_extend
função in listobject.c
). As únicas diferenças são: 1. +=
reatribuições l1
(a si própria para list
s, mas a reatribuição suporta tipos imutáveis que não são o mesmo objeto depois), o que a torna ilegal se l1
for realmente um atributo de um objeto imutável; por exemplo, t = ([],)
, t[0] += lst
seria um fracasso, enquanto que t[0].extend(lst)
iria funcionar. 2. l1 += l2
usa bytecodes dedicados, enquanto l1.extend(l2)
usa despacho de método generalizado; isso faz +=
mais rápido que extend
.
+=
deve ser reatribuído l1
significa que, em alguns casos, a expedição mais lenta de extend
é parcial ou totalmente compensada por não atribuir de volta ao lado esquerdo. Por exemplo, se list
é o atributo de um objeto self.l1 += l2
e self.l1.extend(l2)
tem desempenho idêntico na minha instalação do Python 3.6, simplesmente porque a operação real é mais parecida self.l1 = self.l1.__iadd__(l2)
, o que significa que ela deve executar um custo moderadamente caro STORE_ATTR
que self.l1.extend(l2)
não precisa.
+=
está apenas usando STORE_FAST
, o que é super barato), em que o valor adicionado é um existente list
com um item, com a operação repetida 1000 vezes, +=
levou em média 33 ns , enquanto extend
levou 78 ns, uma diferença de 45 ns. Se l1
for global (requer mais caro STORE_GLOBAL
), a diferença diminui para 17 ns. Se l1
for realmente local.l1
(requer ainda mais caro STORE_ATTR
), não há diferença significativa entre +=
e extend
(tempos aproximadamente idênticos; extend
às vezes vence).
append
acrescenta um único elemento. extend
anexa uma lista de elementos.
Observe que se você passar uma lista para anexar, ela ainda adicionará um elemento:
>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
Com anexar, você pode anexar um único elemento que estenderá a lista:
>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]
Se você deseja estender mais de um elemento, deve usar o extend, porque você pode anexar apenas um elemento ou uma lista de elementos:
>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]
Para que você obtenha uma lista aninhada
Em vez de estender, você pode estender um único elemento como este
>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]
Ou, diferentemente, do anexo, estenda mais elementos de uma vez, sem aninhar a lista na original (essa é a razão do nome estender)
>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]
Anexar e estender podem adicionar um elemento ao final da lista, embora o acréscimo seja mais simples.
>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]
>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3]
Se você usar o acréscimo para mais de um elemento, precisará passar uma lista de elementos como argumentos e obterá uma lista NESTED!
>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]
Com estender, você passa uma lista como argumento, mas obterá uma lista com o novo elemento que não está aninhado no antigo.
>>> z = [1,2]
>>> z.extend([3,4])
>>> z
[1,2,3,4]
Portanto, com mais elementos, você usará o extend para obter uma lista com mais itens. No entanto, anexar uma lista não adicionará mais elementos à lista, mas um elemento que é uma lista aninhada, como você pode ver claramente na saída do código.
Os dois trechos a seguir são semanticamente equivalentes:
for item in iterator:
a_list.append(item)
e
a_list.extend(iterator)
O último pode ser mais rápido à medida que o loop é implementado em C.
extend()
provavelmente pré-aloca, enquanto append()
provavelmente não.
extend()
que não é possível pré-alocar sensatamente, pois algumas iteráveis não são implementadas __len__()
, mas, como você, eu ficaria surpreso se não tentar. Parte do ganho de desempenho também advém da parte da iteração em C puro, em vez de em Python, como apontado na resposta de Aaron .
O append()
método adiciona um único item ao final da lista.
x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']
O extend()
método pega um argumento, uma lista e anexa cada um dos itens do argumento à lista original. (As listas são implementadas como classes. “Criar” uma lista é realmente instanciar uma classe. Como tal, uma lista possui métodos que operam nela.)
x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']
De mergulhar em Python .
extend
uma lista com um elemento ['abc']
: [1, 2, 3, 4, 5, 'abc']. Para fazer o seu exemplo de saída correta, altere a linha abc para: x.extend('abc')
. E remova x.extend(6)
ou mude para x.extend([6])
.
Você pode usar "+" para retornar a extensão, em vez de estender no lugar.
l1=range(10)
l1+[11]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]
l2=range(10,1,-1)
l1+l2
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]
Da mesma forma +=
para o comportamento no local, mas com pequenas diferenças de append
& extend
. Uma das maiores diferenças de +=
from append
e extend
é quando é usado em escopos de função, consulte esta postagem no blog .
append(object)
- Atualiza a lista adicionando um objeto à lista.
x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]
extend(list)
- Concatena essencialmente duas listas.
x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]
extend()
pode ser usado com um argumento iterador. Aqui está um exemplo. Você deseja fazer uma lista de uma lista de listas desta maneira:
De
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
você quer
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Você pode usar itertools.chain.from_iterable()
para fazer isso. A saída deste método é um iterador. Sua implementação é equivalente a
def from_iterable(iterables):
# chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
for it in iterables:
for element in it:
yield element
De volta ao nosso exemplo, podemos fazer
import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))
e obtenha a lista de procurados.
Aqui está como equivalentemente extend()
pode ser usado com um argumento iterador:
merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
É o equivalente append
e o extend
uso do +
operador:
>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]
append () : É basicamente usado no Python para adicionar um elemento.
Exemplo 1:
>> a = [1, 2, 3, 4]
>> a.append(5)
>> print(a)
>> a = [1, 2, 3, 4, 5]
Exemplo 2:
>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]
estender () : onde estender (), é usado para mesclar duas listas ou inserir vários elementos em uma lista.
Exemplo 1:
>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]
Exemplo 2:
>> a = [1, 2, 3, 4]
>> a.extend([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, 5, 6]
Um ponto interessante que foi sugerido, mas não explicado, é que o prolongamento é mais rápido do que o acréscimo. Para qualquer loop que tenha um acréscimo interno, deve ser considerado substituído por list.extend (elementos_processados).
Lembre-se de que a aprovação de novos elementos pode resultar na realocação de toda a lista para um local melhor na memória. Se isso for feito várias vezes porque anexamos 1 elemento por vez, o desempenho geral será prejudicado. Nesse sentido, list.extend é análogo a "" .join (stringlist).
Anexar adiciona todos os dados de uma vez. Os dados completos serão adicionados ao índice recém-criado. Por outro lado,extend
como o próprio nome sugere, estende a matriz atual.
Por exemplo
list1 = [123, 456, 678]
list2 = [111, 222]
Com append
nós obtemos:
result = [123, 456, 678, [111, 222]]
Enquanto extend
estivermos em :
result = [123, 456, 678, 111, 222]
Um dicionário de inglês define as palavras append
e extend
como:
acrescentar : adicione (algo) ao final de um documento escrito.
estender : aumentar. Ampliar ou expandir
Com esse conhecimento, agora vamos entender
1) A diferença entre append
eextend
append
:
extend
:
list(iterable)
.2) Semelhança entre append
eextend
None
.Exemplo
lis = [1, 2, 3]
# 'extend' is equivalent to this
lis = lis + list(iterable)
# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
list.append(object)
Espero poder fazer um complemento útil para esta pergunta. Se sua lista armazena um objeto de tipo específico, por exemplo Info
, aqui está uma situação em que o extend
método não é adequado: em um for
loop ee gerando um Info
objeto toda vez e usando-o extend
para armazená-lo em sua lista, ele falhará. A exceção é como abaixo:
TypeError: o objeto 'Info' não é iterável
Mas se você usar o append
método, o resultado será OK. Como sempre, usando o extend
método, ele sempre será tratado como uma lista ou qualquer outro tipo de coleção, itere-o e coloque-o após a lista anterior. Um objeto específico não pode ser iterado, obviamente.
Para distingui-los intuitivamente
l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]
É como l1
reproduzir um corpo dentro do corpo (aninhado).
# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']
É como se dois indivíduos separados se casassem e construíssem uma família unida.
Além disso, faço uma cheatsheet exaustiva de todos os métodos da lista para sua referência.
list_methods = {'Add': {'extend', 'append', 'insert'},
'Remove': {'pop', 'remove', 'clear'}
'Sort': {'reverse', 'sort'},
'Search': {'count', 'index'},
'Copy': {'copy'},
}
append
"estende" a lista (no local) por apenas um item , o único objeto passado (como argumento).
extend
"estende" a lista (no local) por tantos itens quanto o objeto passado (como argumento) contém.
Isso pode ser um pouco confuso para str
objetos.
append
adicionará um único item de string no final, mas
extend
adicionará tantos itens "str" únicos quanto o comprimento dessa string.append
ainda adicionará um único item de 'lista' no final e
extend
adicionará tantos itens de 'lista' quanto o comprimento da lista passada.def append_o(a_list, element): a_list.append(element) print('append:', end = ' ') for item in a_list: print(item, end = ',') print() def extend_o(a_list, element): a_list.extend(element) print('extend:', end = ' ') for item in a_list: print(item, end = ',') print() append_o(['ab'],'cd') extend_o(['ab'],'cd') append_o(['ab'],['cd', 'ef']) extend_o(['ab'],['cd', 'ef']) append_o(['ab'],['cd']) extend_o(['ab'],['cd'])
produz:
append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,
Anexar e estender são um dos mecanismos de extensibilidade em python.
Anexar: adiciona um elemento ao final da lista.
my_list = [1,2,3,4]
Para adicionar um novo elemento à lista, podemos usar o método append da seguinte maneira.
my_list.append(5)
O local padrão ao qual o novo elemento será adicionado está sempre na posição (comprimento + 1).
Inserção: O método de inserção foi usado para superar as limitações do anexo. Com a inserção, podemos definir explicitamente a posição exata em que queremos que nosso novo elemento seja inserido.
Descritor de método de inserção (índice, objeto). São necessários dois argumentos, primeiro sendo o índice que queremos inserir nosso elemento e depois o próprio elemento.
Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']
Estender: isso é muito útil quando queremos juntar duas ou mais listas em uma única lista. Sem extensão, se queremos juntar duas listas, o objeto resultante conterá uma lista de listas.
a = [1,2]
b = [3]
a.append(b)
print (a)
[1,2,[3]]
Se tentarmos acessar o elemento na posição 2, obteremos uma lista ([3]), em vez do elemento. Para juntar duas listas, teremos que usar append.
a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]
Para ingressar em várias listas
a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]
extend
e simplesmente usar o operador de adição - no exemplo acimax = x + [4, 5]
?