Si x est list, pourquoi x + = "ha" fonctionne, alors que x = x + "ha" renvoie une exception?

Question

À partir de ce que je sais, les listes + op pour seulement nécessitent que le 2ème opérande soit itérable, ce qui est clairement "ha".

Dans le code:

>>> x = [] 
>>> x += "ha" 
>>> x 
['h', 'a'] 
>>> x = x + "ha" 
Traceback (most recent call last): 
File "<stdin>", line 1, in <module> 
TypeError: can only concatenate list (not "str") to list 

Answer 1

En utilisant += une liste est comme appeler extend, pas +. Vous pouvez appeler extend avec un itérable.

Vous pouvez uniquement utiliser + avec une autre liste. Je ne peux que deviner pourquoi cette décision a été prise, mais j'imagine que c'est pour des raisons de performance. L'appel + entraîne la création d'un nouvel objet et la copie de tous les éléments, tandis que extend peut utiliser de l'espace libre dans l'objet de liste existant en enregistrant une copie dans certains cas.

Un autre effet secondaire de cette décision est que si vous écrivez x += y d'autres références à la liste verront le changement, mais si vous utilisez x = x + y alors ils ne le feront pas. Ceci est démontré ci-dessous:

 
>>> x = ['a','b'] 
>>> y = ['c', d'] 
>>> z = x 
>>> x += y 
>>> z 
['a', 'b', 'c', 'd'] 

>>> x = ['a','b'] 
>>> y = ['c', d'] 
>>> z = x 
>>> x = x + y 
>>> z 
['a', 'b'] 

Références

Python source code for list.

code source pour +=:

 
static PyObject * 
list_inplace_concat(PyListObject *self, PyObject *other) 
{ 
    PyObject *result; 

    result = listextend(self, other); 
    if (result == NULL) 
     return result; 
    Py_DECREF(result); 
    Py_INCREF(self); 
    return (PyObject *)self; 
} 

code source pour +:

 
static PyObject * 
list_concat(PyListObject *a, PyObject *bb) 
{ 
    Py_ssize_t size; 
    Py_ssize_t i; 
    PyObject **src, **dest; 
    PyListObject *np; 
    if (!PyList_Check(bb)) { 
     PyErr_Format(PyExc_TypeError, 
        "can only concatenate list (not \"%.200s\") to list", 
        bb->ob_type->tp_name); 
     return NULL; 
    } 

    // etc ... 

Answer 2

Tu penses à l'envers. Vous demandez pourquoi x = x + 'ha' déclenche une exception, étant donné que x += 'ha' fonctionne. Vraiment, la question est pourquoi x += 'ha' fonctionne du tout.

Tout le monde est d'accord (j'espère) que 'abc' + 'ha' et [1, 2, 3] + ['h', 'a'] devraient fonctionner. Et dans ces cas, surcharger += pour effectuer une modification sur place semble raisonnable.

Les concepteurs de langage ont décidé que [1, 2, 3] + 'ha' ne devrait pas, parce que vous mélangez différents types. Et cela semble raisonnable aussi.

Donc la question est pourquoi ils ont décidé de de mélanger différents types dans le cas de x += 'ha'. Dans ce cas, je suppose qu'il ya des raisons de couple:

• Il est un raccourci pratique
• Il est évident ce qui se passe (vous ajoutez chacun des éléments de la itérables à x)

En général , Python essaie de vous laisser faire ce que vous voulez, mais là où il y a de l'ambiguïté, cela tend à vous forcer à être explicite.

Answer 3

Lors de la définition des opérateurs, il existe deux opérateurs "add" différents: l'un est appelé __add__, l'autre __iadd__. Le dernier est pour les ajouts sur place avec +=, l'autre est l'opérateur + régulier. http://docs.python.org/reference/datamodel.html a plus d'infos à ce sujet.