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

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]

appendadiciona um elemento a uma lista e extendconcatena 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?

• appendadiciona seu argumento como um único elemento ao final de uma lista. O comprimento da lista em si aumentará em um.
• extenditera 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.appendmé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_listcomo 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.extendmé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']

Sobrecarga do 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, mas requer que a segunda iterável seja uma lista.

my_list += another_listmodifica 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_listnão é equivalente a +=- ela fornece uma nova lista atribuída a my_list.

Complexidade temporal

O anexo tem complexidade de tempo constante , O (1).

Estender possui complexidade de tempo, O (k).

A repetição de várias chamadas para appendaumentar 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.

atuação

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

Endereçando um comentário sobre horários

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

Conclusão

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.

appendacrescenta um único elemento. extendanexa 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]]

Anexar vs Estender

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]

Adicionando um elemento com os dois métodos

Anexar e estender podem adicionar um elemento ao final da lista, embora o acréscimo seja mais simples.

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]

Adicionando mais elementos ... com resultados diferentes

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.

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 .

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 appende 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 appende o extenduso 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 appendnós obtemos:

result = [123, 456, 678, [111, 222]]

Enquanto extendestivermos em :

result = [123, 456, 678, 111, 222]

Um dicionário de inglês define as palavras appende extendcomo:

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 appendeextend

append:

• Anexa qualquer objeto Python como está no final da lista (ou seja, como o último elemento da lista).
• A lista resultante pode ser aninhada e conter elementos heterogêneos (ou seja, lista, sequência, tupla, dicionário, conjunto, etc.)

extend:

• Aceita qualquer iterable como seu argumento e faz parte da lista maior .
• A lista resultante é sempre uma lista unidimensional (ou seja, sem aninhamento) e pode conter elementos heterogêneos (como caracteres, números inteiros, float) como resultado da aplicação list(iterable).

2) Semelhança entre appendeextend

• Ambos aceitam exatamente um argumento.
• Ambos modificam a lista no local .
• Como resultado, os dois retornos 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 extendmétodo não é adequado: em um forloop ee gerando um Infoobjeto toda vez e usando-o extendpara 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 appendmétodo, o resultado será OK. Como sempre, usando o extendmé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 l1reproduzir 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'},
                }

extend(L)estende a lista anexando todos os itens da lista fornecida 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 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 strobjetos.

1. Se você passar uma string como argumento: appendadicionará um único item de string no final, mas extendadicionará tantos itens "str" ​​únicos quanto o comprimento dessa string.
2. Se você passar uma lista de strings como argumento: appendainda adicionará um único item de 'lista' no final e extendadicionará 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]