data-structures elementos una - Diferencia entre los métodos de agregar y ampliar la lista en Python





12 Answers

append agrega un elemento a una lista, y la extend concatena la primera lista con otra lista (u otro iterable, no necesariamente una 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', 2]]

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

Desde Dive into Python .

listas anidadas recorrer

¿Cuál es la diferencia entre los métodos de lista append() y extend() ?




append anexa un solo elemento. extend anexa una lista de elementos.

Tenga en cuenta que si pasa una lista para anexar, aún agrega un elemento:

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]



El método append () agrega un solo elemento al final de la lista.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

El método extend () toma un argumento, una lista, y agrega cada uno de los elementos del argumento a la lista original. (Las listas se implementan como clases. "Crear" una lista es realmente crear una clase. Como tal, una lista tiene métodos que operan en ella.)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

Desde Dive Into Python .




Anexar vs Extender

Con anexar puede anexar un solo elemento que extenderá la lista:

>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]

Si desea extender más de un elemento, debe usar extender, porque solo puede agregar un elemento o una lista de elementos:

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

Para que consigas una lista anidada.

En su lugar, con la extensión se puede extender un solo elemento como este

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

O, a diferencia de anexar, extienda más elementos de una vez sin anidar la lista a la original (esa es la razón de la extensión del nombre)

>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]

Añadiendo un elemento con ambos métodos.

añadir 1 elemento

>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]

extender un elemento

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

Añadiendo más elementos ... con diferentes resultados.

Si usa la función de agregar para más de un elemento, debe pasar una lista de elementos como argumentos y obtendrá una lista NESTED.

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

Con extend, en cambio, pasa una lista como argumento, pero obtendrá una lista con el nuevo elemento que no está anidada en el anterior.

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

Entonces, con más elementos, utilizará extendido para obtener una lista con más elementos. Utilizará anexar, para anexar no más elementos a la lista, sino un elemento que es una lista anidada como se puede ver claramente en la salida del código.




extend() se puede utilizar con un argumento iterador. Aquí hay un ejemplo. Desea hacer una lista de una lista de listas de esta manera:

Desde

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

usted quiere

>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Puede usar itertools.chain.from_iterable() para hacerlo. La salida de este método es un iterador. Su implementación es 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

Volviendo a nuestro ejemplo, podemos hacer.

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

y consigue la lista de buscados.

Aquí es cómo se puede usar de forma equivalente extend() con un argumento de iterador:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]



append () : se usa básicamente en Python para agregar un elemento.

Ejemplo 1:

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

Ejemplo 2:

>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]

extend () : donde extend (), se utiliza para combinar dos listas o insertar varios elementos en una lista.

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

Ejemplo 2:

>> a = [1, 2, 3, 4]
>> a.extend([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, 5, 6]



Anexar agrega todos los datos a la vez. Todos los datos se agregarán al índice recién creado. Por otro lado, extend , como su nombre lo indica, extiende la matriz actual.

Por ejemplo

list1 = [123, 456, 678]
list2 = [111, 222]

Con el append obtenemos:

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

Mientras que en la extend obtenemos:

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



Espero poder hacer un suplemento útil a esta pregunta. Si su lista almacena un objeto de tipo específico, por ejemplo, Info , aquí hay una situación en la que extend método de extend no es adecuado: en un bucle for y generar un objeto de Info cada vez y usar la extend para almacenarlo en su lista, fallará. La excepción es como a continuación:

TypeError: el objeto 'Info' no es iterable

Pero si usa el método de append , el resultado es correcto. Debido a que cada vez que utiliza el método extend , siempre lo tratará como una lista o cualquier otro tipo de colección, itérelo y colóquelo después de la lista anterior. Un objeto específico no puede ser iterado, obviamente.




El método "añadir" agrega su parámetro como un elemento único a la lista, mientras que "extender" obtiene una lista y agrega su contenido.

Por ejemplo,

ampliar

    letters = ['a', 'b']
    letters.extend(['c', 'd'])
    print(letters) # ['a', 'b', 'c', 'd']

adjuntar

    letters.append(['e', 'f'])
    print(letters) # ['a', 'b', 'c', 'd', ['e', 'f']]



Esto me ayudó a entender lo que realmente sucede cuando usas append y 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]



append "extiende" la lista (en su lugar) solo por un elemento , el único objeto pasado (como argumento).

extend "extiende" la lista (en su lugar) por tantos elementos como contiene el objeto pasado (como argumento).

Esto puede ser un poco confuso para los objetos str .

  1. Si pasa una cadena como argumento: append agregará un único elemento de cadena al final, pero extend agregará tantos elementos "únicos" 'str' como la longitud de esa cadena.
  2. Si pasa una lista de cadenas como argumento: la aplicación aún agregará un único elemento de "lista" al final y la extend agregará tantos elementos de "lista" como la longitud de la lista aprobada.
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'])

produce:

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,



El método append () agregará el argumento pasado como un elemento único.

extend () iterará sobre los argumentos pasados ​​y extenderá la lista pasando cada elemento iterado, básicamente agregará múltiples elementos que no suman todo como uno solo.

list1 = [1,2,3,4,5]
list2 = [6,7,8]

list1.append(list2)
print(list1)
#[1,2,3,4,5,[6,7,8]]

list1.extend(list2)
print(list1)
#[1,2,3,4,5,6,7,8]



Related