value - python dictionary
Diferença entre os métodos append vs. extend list em Python (16)
Qual é a diferença entre os métodos de lista append()
e extend()
?
Anexar vs estender
Com o acréscimo, você pode anexar um único elemento que ampliará a lista:
>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]
Se você quiser estender mais de um elemento, use 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 append, estender mais elementos de uma vez sem aninhar a lista na original (essa é a razão da extensão do nome)
>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]
Adicionando um elemento com os dois métodos
acrescentar 1 elemento
>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]
estender um elemento
>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]
Adicionando mais elementos ... com resultados diferentes
Se você usar append para mais de um elemento, terá que 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 extend, em vez disso, você passa uma lista como argumento, mas você 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]
Assim, com mais elementos, você usará extend para obter uma lista com mais itens. Você usará append para anexar não mais elementos à lista, mas um elemento que seja uma lista aninhada, como você pode ver claramente na saída do código.
Qual é a diferença entre os métodos de lista anexados e ampliados?
-
append
adiciona seu argumento como um único elemento ao final de uma lista. O tamanho da lista aumentará em um. -
extend
itera 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 método list.append
anexa um objeto ao final da lista.
my_list.append(object)
Seja qual for o objeto, seja um número, uma string, outra lista ou qualquer outra coisa, ele é adicionado ao final de my_list
como uma única entrada na lista.
>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']
Portanto, tenha em mente que uma lista é um objeto. Se você acrescentar outra lista em 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 método list.extend
estende uma lista anexando elementos de um iterável:
my_list.extend(iterable)
Então, 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]
Tenha em mente que uma string é uma iterável, então se você estender uma lista com uma string, você adicionará cada caractere à medida que você repetir a string (que pode não ser o que você quer):
>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']
Sobrecarga de Operador, __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 dela, mas requer que a segunda 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), portanto, não cria uma nova lista. Também funciona como estender, em que o segundo iterável pode ser qualquer tipo de iterável.
Não fique confuso - my_list = my_list + another_list
não é equivalente a +=
- ele fornece uma nova lista atribuída a my_list.
Complexidade do Tempo
Append tem complexidade de tempo constante , O (1).
Estender tem complexidade de tempo, O (k).
A repetição das várias chamadas para append
aumenta a complexidade, tornando-a equivalente à extensão e, como a iteração de extensão é implementada em C, ela sempre será mais rápida se você desejar acrescentar itens sucessivos de um iterável a uma lista.
atuação
Você pode se perguntar o que é mais eficaz, já que o append pode ser usado para alcançar o mesmo resultado que estender. 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
Endereçando um comentário sobre horários
Um comentarista disse:
Resposta perfeita, eu só sinto falta do momento de comparar adicionando apenas um elemento
Faça a coisa semanticamente correta. Se você quiser acrescentar todos os elementos de uma forma iterável, use extend
. Se você acabou de adicionar um elemento, use append
.
Ok, então vamos criar uma experiência para ver como isso funciona no 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 nós vemos que sair do nosso caminho para criar um iterável apenas para usar estender é um (menor) desperdício 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 há nada ganho com o uso de extend
quando temos apenas um elemento para 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 semântica correta é fazer as coisas do jeito certo .
É concebível que você possa testar temporizações em duas operações comparáveis e obter um resultado ambíguo ou inverso. Apenas se concentre em fazer a coisa correta semanticamente.
Conclusão
Vemos que a extend
é semanticamente mais clara, e que ela pode ser executada muito mais rapidamente do que append
, quando você pretende anexar cada elemento de um iterável a uma lista.
Se você tiver apenas um único elemento (não em um iterável) para adicionar à lista, use append
.
Anexar adiciona os dados inteiros de uma só vez. Os dados inteiros serão adicionados ao índice recém-criado. Por outro lado, extend
, como o nome sugere, estende a matriz atual.
Por exemplo
list1 = [123, 456, 678]
list2 = [111, 222]
Com append
nós recebemos:
result = [123, 456, 678, [111, 222]]
Enquanto na extend
, obtemos:
result = [123, 456, 678, 111, 222]
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 que o novo elemento será adicionado está sempre na posição (comprimento + 1).
Inserir: O método de inserção foi usado para superar as limitações do acréscimo. Com a inserção, podemos definir explicitamente a posição exata na qual 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 segundo 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 unir duas ou mais listas em uma única lista. Sem extensão, se quisermos unir 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 participar de duas listas, precisaremos usar o append.
a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]
Para participar de várias listas
a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]
Isso é o equivalente de 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]]
Isso me ajudou a entender o que realmente acontece quando você usa o append
e extend
:
a = [[1,2,3],[4,5,6]]
print(a)
>>> [[1, 2, 3], [4, 5, 6]]
a.append([6,7,8])
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8]]
a.extend([0,1,2])
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2]
a=a+[8,9,10]
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2, 8, 9, 10]
O método append () 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 método extend () pega um argumento, uma lista e acrescenta 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 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 .
Os dois trechos seguintes são semanticamente equivalentes:
for item in iterator:
a_list.append(item)
e
a_list.extend(iterator)
O último pode ser mais rápido quando o loop é implementado em C.
Um dicionário em inglês define as palavras append
e extend
como:
acrescentar : adicione (alguma coisa) ao final de um documento escrito.
estender : fazer maior. Ampliar ou expandir
Com esse conhecimento, agora vamos entender
1) A diferença entre append
e extend
append
:
- Anexa qualquer objeto Python como está no final da lista (ou seja, como último elemento da lista).
- A lista resultante pode ser aninhada e conter elementos heterogêneos (ou seja, lista, string, tupla, dicionário, conjunto, etc.)
extend
:
- Aceita qualquer iterável como argumento e aumenta a lista.
- A lista resultante é sempre uma lista unidimensional (ou seja, sem aninhamento) e pode conter elementos heterogêneos (por exemplo, caracteres, inteiros, flutuantes) como resultado da aplicação de
list(iterable)
.
2) Semelhança entre append
e extend
- Ambos levam exatamente 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
lis.append(object)
Um ponto interessante que foi sugerido, mas não explicado, é que a extensão é mais rápida que o append. Para qualquer loop que tenha um app dentro deve ser considerado como sendo substituído por list.extend (processed_elements).
Tenha em mente que a aprendizagem de novos elementos pode resultar na realocação de toda a lista para um melhor local na memória. Se isso for feito várias vezes, porque estamos anexando 1 elemento por vez, o desempenho geral sofre. Nesse sentido, list.extend é análogo a "" .join (stringlist).
extend (L) estende a lista adicionando todos os itens na lista dada 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 passado (como argumento).
extend
"extends" a lista (no local) por tantos itens quanto o objeto passado (como argumento) contém.
Isso pode ser um pouco confuso para objetos str
.
- Se você passar uma string como argumento:
append
adicionará um único item de string no final, mas oextend
adicionará tantos itens "single" 'str' quanto o tamanho dessa string. - Se você passar uma lista de strings como argumento:
append
ainda adicionará um único item de 'lista' no final eextend
adicionará tantos itens de 'lista' quanto 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,
append
acrescenta um único elemento. extend
acrescenta uma lista de elementos.
Observe que, se você passar uma lista para acrescentar, ela ainda adicionará um elemento:
>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
extend()
pode ser usado com um argumento iterador. Aqui está um exemplo. Você deseja fazer uma lista fora 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]
append () : É 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]]
extend () : Onde extend (), é 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]