Если x является списком, то почему x + = "ha" работает, а x = x + "ha" выдает исключение?

Использование += со списком похоже на вызов extend , а не + .

• Вы можете вызывать extend с помощью итерации.
• Вы можете использовать + только с другим списком.

Я могу только догадываться, почему это решение было принято, но я думаю, что это по соображениям производительности. Вызов + приводит к созданию нового объекта и копированию всех элементов, тогда как в некоторых случаях extend может использовать свободное пространство в существующем объекте списка, сохраняя копию.

Другим побочным эффектом этого решения является то, что если вы напишете x += y другие ссылки на список увидят изменение, но если вы будете использовать x = x + y то они не будут. Это показано ниже:

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

Рекомендации

Исходный код Python для списка .

Исходный код для += :

 статический PyObject *
 list_inplace_concat (PyListObject * self, PyObject * other)
 {
     Результат PyObject *;

     result = listextend (self, other);
     if (result == NULL)
         результат возврата;
     Py_DECREF (результат);
     Py_INCREF (сам);
     return (PyObject *) self;
 }

Исходный код для + :

 статический PyObject *
 list_concat (PyListObject * a, PyObject * bb)
 {
     Py_ssize_t размер;
     Py_ssize_t i;
     PyObject ** src, ** dest;
     PyListObject * np;
     if (! PyList_Check (bb)) {
         PyErr_Format (PyExc_TypeError,
                   "может только конкатенировать список (не \"%. 200s \ ") для списка",
                   BB-> ob_type-> tp_name);
         return NULL;
     }

     // и т.д ...

Вы думаете об этом назад. Вы спрашиваете, почему x = x + 'ha' выдает исключение, учитывая, что x += 'ha' работает. Действительно, возникает вопрос, почему x += 'ha' работает вообще.

Все согласны (надеюсь), что 'abc' + 'ha' и [1, 2, 3] + ['h', 'a'] должны работать. И в этих случаях перегрузка += чтобы сделать модификацию на месте, кажется разумной.

Разработчики языка решили, что [1, 2, 3] + 'ha' не должны, потому что вы смешиваете разные типы. И это тоже кажется разумным.

Поэтому возникает вопрос, почему они решили разрешить смешивание разных типов в случае x += 'ha' . В этом случае, я думаю, есть несколько причин:

• Это удобная стенография
• Очевидно, что происходит (вы добавляете каждый из элементов в iterable в x )

В общем, Python пытается позволить вам делать то, что вы хотите, но там, где есть двусмысленность, он стремится заставить вас быть явным.

При определении операторов существуют два разных оператора «add»: один из них называется __add__ , другой __iadd__ . Последний – для добавок на месте с += , другой – регулярный + оператор. http://docs.python.org/reference/datamodel.html имеет больше информации об этом.