Qual é a diferença entre os métodos de lista do Python adicionar e estender?
Qual é a diferença entre os métodos da lista {[[0]} e extend()
?
20 answers
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 da lista Adicionar e estender?
-
append
adiciona o seu argumento como um único elemento ao fim de uma lista. O comprimento da própria lista aumentará em um. -
extend
itera sobre o seu argumento adicionando cada elemento à lista, alargando a lista. O comprimento da lista vai aumentar por muitos elementos que estavam no argumento iterável.
append
O método list.append
adiciona um objectar ao fim da lista.
my_list.append(object)
Seja qual for o objecto, seja um número, uma cadeia de caracteres, outra lista, ou qualquer outra coisa, ele é adicionado ao fim de my_list
como um único item na lista.
>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']
Então, tenha em mente que uma lista é um objeto. Se você adicionar outra lista em uma lista, a primeira lista será um único objeto no final da lista (que pode não ser o que você quer):
>>> 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 método list.extend
estende uma lista adicionando elementos de um iterável:
my_list.extend(iterable)
Então, com extend, cada elemento do iterable é adicionado à lista. Por exemplo:
>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]
Tenha em mente que uma cadeia de caracteres é iterável, por isso, se estender uma lista com uma cadeia de caracteres, irá adicionar cada carácter à medida que interage sobre a cadeia de caracteres (o que pode não ser o que deseja):
>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']
Sobrecarga do Operador, __add__
(+
) e __iadd__
(+=
)
Ambos os operadores +
e +=
estão definidos para list
. São semanticamente semelhantes a estender.
my_list + another_list
cria uma terceira lista na memória, para que você possa retornar o resultado dela, mas requer que a segunda iterável seja uma lista.
my_list += another_list
modifica a lista no local (it é o operador no local, e as listas são objectos mutáveis, como vimos) de modo que não cria uma nova lista. Também funciona como extend, na medida em que o segundo iterável pode ser qualquer tipo de iterável.
Complexidade Temporal
Append has constant time complexity , O(1).
O Extend tem complexidade temporal, o (k).
A iteração através das múltiplas chamadas para append
aumenta a complexidade, tornando-a equivalente à de extend, e como a iteração de extend é implementada em C, será sempre mais rápida se você pretende adicionar itens sucessivos de um iterável para uma lista.
Desempenho
Podes perguntar-te o que é mais performant, uma vez que append pode ser usado para alcançar o mesmo resultado que extend. 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
A fazer um comentário sobre os horários
Um comentador disse:
Resposta perfeita, sinto falta da altura de comparar a adição de apenas um elemento.Faz a coisa semanticamente correcta. Se quiser adicionar todos os elementos num iterável, use
extend
. Se você está apenas adicionando um element, use append
.
Então vamos criar uma experiência para ver como isto funciona a 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 um iterável apenas para usar o extend é uma (menor) perda de tempo:
>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295
[[48]} aprendemos com isso que não há nada ganho em usar extend
quando temos apenas um elemento para adicionar.
Além disso, estes horários não são assim tão importantes. Estou apenas a mostrar-lhes que, em Python, a coisa semanticamente correta é fazer as coisas da maneira certa.
É concebível que você possa testar cronogramas em duas operações comparáveis e obter um resultado ambíguo ou inverso. Concentra-te em fazer a coisa semanticamente correcta.
Conclusão
Vemos queextend
é semanticamente mais claro, e que pode correr muito mais rápido do que append
, quando você pretende adicionar cada elemento em uma lista iterável.
Se só tiver um único elemento (não num iterável) para adicionar à lista, use append
.
append
adiciona um único elemento. extend
adiciona uma lista de elementos.
Note que se passar uma lista para adicionar, ela ainda adiciona um elemento:
>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
Append vs Extend
Com a aplicação poderá adicionar um único elemento que irá alargar a lista:
>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]
Se quiser estender mais do que um elemento, deve usar o extend, porque só pode adicionar um elemento ou uma lista de elementos:
>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]
Para que tenhas uma lista aninhada
Em vez disso, com extend, você pode estender um único elemento como este>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]
Ou, diferentemente, de adicionar, estender mais elementos em um tempo sem aninhar a lista no original (essa é a razão da extensão do nome)
>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]
Adicionar um elemento com ambos os métodos
Tanto o append como o extend podem adicionar um elemento ao fim da lista, embora o append seja mais simples.
Adicionar 1 elemento
>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]
Extender um elemento
>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3]
Adicionando mais elementos... com resultados diferentes
Se usar o append para mais do que um elemento, terá de passar uma lista de elementos como argumentos e você vai obter uma lista aninhada!
>>> x = [1,2]
>>> x.append([3,4])
>>> x
[1,2,[3,4]]
Com extend, em vez disso, você passa uma lista como um argumento, mas você vai 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]
Então, com mais elementos, você vai usar o extend para obter uma lista com mais itens. No entanto, adicionar uma lista não irá adicionar mais elementos à lista, mas um elemento que é uma lista aninhada como você pode ver claramente no resultado do codigo.
Os dois excertos seguintes são semi-equivalentes:
for item in iterator:
a_list.append(item)
E
a_list.extend(iterator)
Este último pode ser mais rápido à medida que o laço é implementado em C.
O Método append()
adiciona um único item ao fim da lista.
x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']
O método extend()
leva um argumento, uma lista, e adiciona cada um dos itens do argumento à lista original. (Listas são implementadas como classes. "Criar" uma lista é realmente instanciar uma classe. Como tal, uma lista tem métodos que funcionam nela.)
x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']
Você pode usar " + " para retornar estender, 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 ligeiras diferenças de append
& extend
. Uma das maiores diferenças de +=
de append
e extend
é quando é usado em âmbitos de função, Veja Este post .
append(object)
- actualiza a lista, adicionando um objecto à 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)
- essencialmente combina 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 a partir de uma lista de listas desta forma:
De
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
Queres
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Pode utilizar itertools.chain.from_iterable()
para o fazer. A saída deste método é um iterador. A sua aplicaçã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
Voltando 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 traz 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]
Este é o equivalente a append
e extend
usando o +
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]]
Adicionar(): é basicamente usado em 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]]
Extender(): onde extend (), é usado para juntar 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]
Adicione todos os dados de uma vez. Todos os dados serão adicionados ao índice recentemente criado. Por outro lado, extend
, como o nome sugere, estende a matriz atual.
Por exemplo
list1 = [123, 456, 678]
list2 = [111, 222]
Com append
Temos:
result = [123, 456, 678, [111, 222]]
Enquanto estamos em extend
temos:
result = [123, 456, 678, 111, 222]
Um dicionário de Inglês define as palavras append
e extend
Como:
Adicione : adicione (algo) ao fim de um documento escrito.
Extender: tornar maior. Aumentar ou expandir
Com esse conhecimento, agora vamos entender.
1) A diferença entre append
e extend
append
:
- adiciona qualquer objecto Python Como-is ao fim da lista (isto é, como um o último elemento do lista).
- a lista resultante pode ser aninhada e conter elementos heterogéneos (isto é, lista, cadeia, tupla, dicionário, conjunto, etc.)
extend
:
- aceita qualquer iterável como argumento e torna a lista maior.
- a lista resultante é sempre uma lista unidimensional (isto é, sem nidificação) e pode conter elementos heterogéneos nela (por exemplo, caracteres, inteiros, vírgula flutuante) como resultado da aplicação {[[7]}.
2) Semelhança entre append
e extend
- Ambos têm exactamente um argumento.
- ambos modificam a lista no local .
- como resultado, ambos retornam
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)
Info
, aqui está uma situação que o método extend
não é adequado: num ciclo for
e gerando um objecto Info
de cada vez e usando extend
para o guardar na sua lista, irá falhar. A excepção é a seguinte:
Erro de impressão: o objecto' Info ' não é iterável
Mas se usar o método append
, o resultado está bem. Porque todas as vezes usando o Método extend
, ele sempre irá tratá-lo como uma lista ou qualquer outro tipo de coleção, iterá-lo, e colocá-lo após a lista anterior. Um objeto específico não pode ser iterado, obviamente.
Para os distinguir intuitivamente
l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]
É como reproduzir um corpo dentro do corpo dela.
# 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 ficha exaustiva de todos os métodos da lista para a sua referência.
list_methods = {'Add': {'extend', 'append', 'insert'},
'Remove': {'pop', 'remove', 'clear'}
'Sort': {'reverse', 'sort'},
'Search': {'count', 'index'},
'Copy': {'copy'},
}
extend(L)
estende a lista, adicionando todos os itens da lista indicada L
.
>>> a
[1, 2, 3]
a.extend([4]) #is eqivalent of a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
append
"estende" a lista (no lugar) por apenas um item, o único objeto passou (como argumento).
extend
"estende" a lista (no lugar) por tantos itens como o objecto que passou (como argumento) contém.
Isto pode ser um pouco confuso para os objectos str
.
- se passar um texto como argumento:
append
irá adicionar um único item de texto no final, masextend
irá adicionar tantos itens" single "' str ' como o comprimento dessa cadeia. - se você passa uma lista de strings como argumento:
append
irá à mesma adicionar um único item de "lista" no final eextend
irá adicionar tantos itens 'lista' como o tamanho 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,
Adicionar e estender é um dos mecanismos de extensibilidade em python.
Adicione: adiciona um elemento ao fim da lista.
my_list = [1,2,3,4]
Para adicionar um novo elemento à lista, podemos usar o método append da seguinte forma.
my_list.append(5)
A localização por omissão que o novo elemento será adicionado está sempre na posição (Comprimento+1).
Inserir: o método de inserção foi utilizado para ultrapassar as limitações de anexação. Com insert, podemos definir explicitamente a posição exacta que quero que o nosso novo elemento seja inserido em.
Descritor do método insert (índice, objecto). São precisos dois argumentos, sendo o primeiro o índice que queremos inserir o nosso elemento e o segundo o próprio elemento.
Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']
Extend: isto é muito útil quando queremos juntar duas ou mais listas numa única lista. Sem extend, se quisermos 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 aceder ao elemento em pos 2, obtemos uma lista ([3]), em vez de elemento. Para nos juntarmos a duas listas, teremos de usar o append.
a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]
Juntar várias listas
a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]