Método de asignación múltiple en Python

Question

Estoy tratando de prepararme para un futuro en informática, así que comencé con ECMAScript y ahora estoy tratando de aprender más sobre Python. Viniendo de ECMAScript, ver asignaciones múltiples como a, b, c = 1, 2, 3 me deja perplejo por un momento, hasta que me doy cuenta de que hay múltiples tareas pasando. Para aclarar un poco las cosas, realmente me gustaría hacer (a, b, c) = (1, 2, 3) pero no estoy seguro de si esto será un golpe de rendimiento medible. Por lo que entiendo, las tuplas son esencialmente cómo funcionan las asignaciones múltiples independientemente, pero hay muchas rarezas en el mundo, así que trato de no asumir nada.

Gracias de antemano

Answer 1

No debe tener ningún efecto sobre el rendimiento. El paréntesis no lo convierte en una tupla, la coma sí. Entonces (1,2,3) es exactamente lo mismo que 1,2,3

Answer 2

La asignación múltiple se implementa como una combinación de tupla de embalaje y tupla desembalaje, que yo sepa, por lo que debe tener el mismo efecto.

Answer 3

También funciona para listas:

a, b, c = [1, 2, 3] 

funciona igual de bien

Answer 4

Es extremadamente fácil de comprobar, con el módulo dis:

>>> import dis 
>>> dis.dis(compile('a,b,c=1,2,3','','exec')) 
    1   0 LOAD_CONST    4 ((1, 2, 3)) 
       3 UNPACK_SEQUENCE   3 
       6 STORE_NAME    0 (a) 
       9 STORE_NAME    1 (b) 
      12 STORE_NAME    2 (c) 
      15 LOAD_CONST    3 (None) 
      18 RETURN_VALUE   
>>> dis.dis(compile('(a,b,c)=(1,2,3)','','exec')) 
    1   0 LOAD_CONST    4 ((1, 2, 3)) 
       3 UNPACK_SEQUENCE   3 
       6 STORE_NAME    0 (a) 
       9 STORE_NAME    1 (b) 
      12 STORE_NAME    2 (c) 
      15 LOAD_CONST    3 (None) 
      18 RETURN_VALUE   
>>> 

ver? Esos paréntesis totalmente redundantes hacen absolutamente diferencia con respecto al bytecode que se genera y ejecuta, como, por ejemplo, a+b y (a+b) generará y ejecutará exactamente el mismo bytecode entre sí. Por lo tanto, si le gusta agregar paréntesis redundantes, olvídese: a las personas que leen su código puede que no les gusten, pero los que lo están ejecutando nunca lo notarán. Solo que, ¿por qué detenerse solo en dos pares de paréntesis redundantes? Véase,

>>> dis.dis(compile('(((a,b,c)))=(((1,2,3)))','','exec')) 
    1   0 LOAD_CONST    4 ((1, 2, 3)) 
       3 UNPACK_SEQUENCE   3 
       6 STORE_NAME    0 (a) 
       9 STORE_NAME    1 (b) 
      12 STORE_NAME    2 (c) 
      15 LOAD_CONST    3 (None) 
      18 RETURN_VALUE   
>>> 

seis pares de paréntesis redundantes (o cualquier número, en realidad) siguen produciendo exactamente el mismo código. Una vez que deja el número mínimo obvio de paréntesis redundantes (ninguno en absoluto: son redundantes, después de todo ;-), exactamente donde se detiene? -) Y por qué allí, cuando es "libre" agregar uno más par ... o dos ... o tres ...? -)