python value item - Diferença entre os métodos append vs. extend list em Python




12 Answers

append : Acrescenta o objeto no final.

x = [1, 2, 3]
x.append([4, 5])
print (x)

te dá: [1, 2, 3, [4, 5]]

extend : Estende a lista anexando elementos do iterável.

x = [1, 2, 3]
x.extend([4, 5])
print (x)

te dá: [1, 2, 3, 4, 5]

dictionary add

Qual é a diferença entre os métodos de lista append() e extend() ?




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 .




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.




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]

Semelhantemente += para comportamento in-place, mas com pequenas diferenças de append & extend . Uma das maiores diferenças de += de append e extend é quando é usada em escopos de função, veja este post 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) - Essencialmente concatena 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]



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



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




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)



Acrescente um dicionário a outro:

>>>def foo():
    dic = {1:'a', 2:'b', 3:'c', 4:'a'}
    newdic = {5:'v', 1:'aa'}
    for i in dic.keys():
        if not newdic.has_key(dic[i]):
            newdic[i] = dic[i]
    print "Appended one:", newdic

>>>foo()
Appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'}



Para distingui-los intuitivamente

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

É como se eu reproduzisse um corpo dentro de seu 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'},
                }



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]



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]



Related