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

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 .

1. Se você passar uma string como argumento: append adicionará um único item de string no final, mas o extend adicionará tantos itens "single" 'str' quanto o tamanho dessa string.
2. Se você passar uma lista de strings como argumento: append ainda adicionará um único item de 'lista' no final e extend 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]