Pregunta Python anexa () vs. + operador en listas, ¿por qué dan resultados diferentes?


¿Por qué estas dos operaciones (append() resp. +) dan diferentes resultados?

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

En el último caso, en realidad hay una recursión infinita. c[-1] y c son lo mismo. ¿Por qué es diferente con el + ¿operación?


76
2018-01-07 16:56


origen


Respuestas:


Para explicar "por qué":

los + operación agrega el formación elementos a la matriz original. los array.append operación inserta la matriz (o cualquier objeto) en el final de la matriz original, lo que resulta en una referencia a uno mismo en ese punto (de ahí la recursión infinita).

La diferencia aquí es que la operación + actúa de manera específica cuando agrega una matriz (está sobrecargada como otras, consulte Este capítulo en secuencias) mediante la concatenación del elemento. Sin embargo, el método de apéndice hace literalmente lo que usted pregunta: añada el objeto en el lado derecho que le da (la matriz o cualquier otro objeto), en lugar de tomar sus elementos.

Una alternativa

Utilizar extend() si desea usar una función que actúe de forma similar al operador + (como otros han mostrado aquí también). No es aconsejable hacer lo contrario: intentar imitar anexar con el operador + para las listas (ver mi enlace anterior sobre por qué).

Poca historia

Por diversión, un poco de historia: el nacimiento del módulo de matriz en Python en febrero de 1993. podría sorprenderte, pero las matrices se agregaron mucho después de que aparecieron las secuencias y las listas.


111
2018-01-07 16:58



append está agregando un elemento a una lista. si desea extender la lista con la nueva lista, debe usar extend.

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

15
2018-01-07 16:59



El operador de concatenación + es un operador infijo binario que, cuando se aplica a las listas, devuelve una nueva lista que contiene todos los elementos de cada uno de sus dos operandos. los list.append() método es un mutator en list que agrega su único object argumento (en su ejemplo específico, la lista c) al sujeto list. En tu ejemplo, esto da como resultado c añadiendo una referencia a sí mismo (de ahí la recursión infinita).

Una alternativa a la concatenación '+'

los list.extend() método es también un método de mutador que concatena su sequence argumento con el tema list. Específicamente, agrega cada uno de los elementos de sequence en orden de iteración

Un lado

Ser un operador, + devuelve el resultado de la expresión como un nuevo valor. Siendo un no encadenamiento mutator método, list.extend() modifica la lista de temas en el lugar y no devuelve nada.

Arrays

He agregado esto debido a la posible confusión que la respuesta de Abel puede causar al mezclar la discusión de listas, secuencias y matrices. Arrays se agregaron a Python después de las secuencias y listas, como una forma más eficiente de almacenar matrices de tipos de datos integrales. No confundir arrays con lists. Ellos no son los mismos.

Desde el documentos de matriz: 

Las matrices son tipos de secuencia y se comportan de forma muy similar a las listas, excepto que el tipo de objetos almacenados en ellas está restringido. El tipo se especifica en el momento de creación del objeto utilizando un código de tipo, que es un solo carácter.


12
2017-07-03 03:35



Las listas de Python son heterogéneas, es decir, los elementos en la misma lista pueden ser cualquier tipo de objeto. La expresion: c.append(c) Anexa el objeto c lo que sea que sea a la lista. En el caso, hace que la lista sea un miembro de la lista.

La expresion c += c agrega dos listas juntas y asigna el resultado a la variable c. El sobrecargado + operador se define en las listas para crear una nueva lista cuyos contenidos son los elementos en la primera lista y los elementos en la segunda lista.

Entonces, estas son solo expresiones diferentes que se usan para hacer cosas diferentes por diseño.


8
2018-01-07 17:00



El método que estás buscando es extend(). Desde Python documentación:

list.append(x)
    Add an item to the end of the list; equivalent to a[len(a):] = [x].

list.extend(L)
    Extend the list by appending all the items in the given list; equivalent to a[len(a):] = L.

list.insert(i, x)
    Insert an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x).

6
2018-01-07 17:03



deberías usar extender ()

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

otra información: añadir vs. extender


2
2018-01-07 17:02



Ver la documentación:

list.append (x)

  • Agregue un artículo al final de la lista; equivalente a a [len (a):] = [x].

list.extend (L)    - Extienda la lista agregando todos los elementos en la lista dada;   equivalente a a [len (a):] = L.

c.append(c) se "agrega" a sí mismo como un elemento. Como una lista es un tipo de referencia, crea una estructura de datos recursiva.

c += c es equivalente a extend(c), que anexa los elementos de c a c.


2
2018-01-07 17:10