Comment Python échange-t-il les valeurs de tuple sans utiliser de variable temporaire ?

Échange de valeurs dans des tuples : un aperçu de l'intérieur

En Python, échanger les valeurs de deux variables en utilisant l'affectation de tuples comme (a, b) = (b, a) peut sembler une astuce simple, mais comment cela fonctionne-t-il en interne sans variable temporaire ?

Stack Manipulation

Python évalue l'expression du côté droit de l'affectation séparément du côté gauche. Une fois le membre de droite calculé, son résultat est stocké sur la pile. Ensuite, les noms du côté gauche sont attribués à l'aide d'opcodes qui fonctionnent directement sur la pile.

Pour les affectations de tuples avec deux ou trois éléments, Python utilise la pile directement à l'aide des opcodes ROT_TWO ou ROT_THREE pour échanger des éléments. Par exemple :

def foo(a, b):
    a, b = b, a

Le désassemblage de cette fonction à l'aide de dis.dis(foo) révèle ce qui suit :

  2           0 LOAD_FAST                1 (b)
              3 LOAD_FAST                0 (a)
              6 ROT_TWO             
              7 STORE_FAST               0 (a)
             10 STORE_FAST               1 (b)
             13 LOAD_CONST               0 (None)
             16 RETURN_VALUE        

Ici, ROT_TWO échange les deux premières valeurs de la pile, inversant ainsi la ordre de a et b.

Construction et déballage de tuples

Pour les missions impliquant plus de trois éléments, Python construit un tuple intermédiaire sur la pile. Prenons cet exemple :

def bar(a, b, c, d):
    d, c, b, a = a, b, c, d

Son démontage montre :

  2           0 LOAD_FAST                0 (a)
              3 LOAD_FAST                1 (b)
              6 LOAD_FAST                2 (c)
              9 LOAD_FAST                3 (d)
             12 BUILD_TUPLE              4
             15 UNPACK_SEQUENCE          4
             18 STORE_FAST               3 (d)
             21 STORE_FAST               2 (c)
             24 STORE_FAST               1 (b)
             27 STORE_FAST               0 (a)
             30 LOAD_CONST               0 (None)
             33 RETURN_VALUE        

BUILD_TUPLE construit un tuple à partir des valeurs de la pile dans l'ordre inverse. Ensuite, UNPACK_SEQUENCE affiche le tuple et replace ses éléments sur la pile pour les affecter aux variables de gauche.

Optimisation

Bien que UNPACK_SEQUENCE semble redondant pour les affectations à deux ou trois éléments, un l'étape d'optimisation ultérieure remplace le combo BUILD_TUPLE/UNPACK_SEQUENCE par le plus efficace ROT_TWO ou Opcodes ROT_THREE, garantissant que le mécanisme d'échange est aussi simple que possible.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!