Tuple: + = l'operatore lancia l'eccezione, ma ha successo?

Question

Perché il seguente genera un'eccezione, sebbene abbia esito positivo?

>>> t = ([1, 2, 3], 4) 
>>> t[0] += [1] 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: 'tuple' object does not support item assignment 
>>> t 
([1, 2, 3, 1], 4) 
>>> 

Answer 1

Trovato la risposta su IRC.

t[0] += [1] è una serie di azioni discrete:

1. carico t[0]
2. costruzione di un nuovo elenco con 1 in esso
3. aggiungendo che [1] a qualunque t[0] è
4. riassegnazione t[0]

Sembra che x += y è fondamentalmente x = x + y (ma, è vero?)

La parte difficile è che += implica l'assegnazione sia al tuple t e all'elenco t[0]

t[0] += [1] non è letteralmentet[0] = t[0] + [1], è è: t[0] = t[0].__iadd__([1])

Ciò che accade è:

1. __iadd__ entrambi mutano la lista e la restituiscono. Quindi l'elenco (che è il primo elemento in t) ha già aggiunto 1 ad esso.
2. La mutazione della tupla viene tentata anche sul posto, ma le tuple sono immutabili, risultando nell'eccezione.

Perché non è visibile in bella vista? Perché un n00b come me si aspetterebbe che t[0] += [1] riescano tutti insieme o falliscano, perché è una linea corta di python. Ma non è sempre così.

Answer 2

Può anche aiutare a comprendere questo comportamento dando un'occhiata al bytecode con dis.dis.

In[5]: dis('t[0] += [1]') 
    1   0 LOAD_NAME    0 (t) 
       3 LOAD_CONST    0 (0) 
       6 DUP_TOP_TWO 
       7 BINARY_SUBSCR 
       8 LOAD_CONST    1 (1) 
      11 BUILD_LIST    1 
      14 INPLACE_ADD 
      15 ROT_THREE 
      16 STORE_SUBSCR 
      17 LOAD_CONST    2 (None) 
      20 RETURN_VALUE 

• Il valore di t[0] è posto sulla sommità della pila con BINARY_SUBSCR, che è una lista (mutevole) in questo caso.
• Il valore nella parte superiore della pila ha += [1] eseguito su di esso con INPLACE_ADD, dove in questo caso la parte superiore della pila fa riferimento all'elenco all'interno della tupla.
• L'assegnazione del t[0] alla sommità della pila avviene con STORE_SUBSCR, che non riesce qui come t sé è una tupla immutabile, sollevando l'errore dopo l'assegnazione += è già verificato.

Answer 3

sviluppatori Python hanno scritto una spiegazione ufficiale sul perché succede qui: https://docs.python.org/2/faq/programming.html#why-does-a-tuple-i-item-raise-an-exception-when-the-addition-works

La versione breve è che + = in realtà fa due cose, uno dopo l'altro:

1. prendere la cosa a destra e aggiungilo alla variabile a sinistra
2. Metti il ​​risultato nella variabile a sinistra

In questo caso, il passaggio 1 funziona perché è consentito aggiungere elementi agli elenchi (sono modificabili), ma il passaggio 2 non riesce perché non è possibile inserire materiale in tuple dopo averli creati (le tuple sono immutabili).

In un programma reale, suggerirei di non farlo perché t [0] .extend (['c']) fa esattamente la stessa cosa.