¿Existe un método estandarizado para intercambiar dos variables en Python?

En Python, he visto dos valores variables intercambiados usando esta sintaxis:

left, right = right, left

¿Se considera esta la forma estándar de intercambiar dos valores de variables o hay algún otro medio por el cual dos variables se intercambian por convención más habitualmente?

Python evalúa expresiones de izquierda a derecha. Tenga en cuenta que al evaluar una tarea, el lado derecho se evalúa antes que el lado izquierdo.

http://docs.python.org/3/reference/expressions.html#evaluation-order

Eso significa lo siguiente para la expresión a,b = b,a:

• b,ase evalúa el lado derecho , es decir, se crea una tupla de dos elementos en la memoria. Los dos elementos son los objetos designados por los identificadores by a, que existían antes de que se fomente la instrucción durante la ejecución del programa.
• justo después de la creación de esta tupla, todavía no se ha asignado este objeto de tupla, pero no importa, Python sabe internamente dónde está
• luego, se evalúa el lado izquierdo, es decir, la tupla se asigna al lado izquierdo
• Como el lado izquierdo está compuesto por dos identificadores, la tupla se desempaqueta para que el primer identificador ase asigne al primer elemento de la tupla (que es el objeto que antes era b antes del intercambio porque tenía nombre b)
  y el el segundo identificador bse asigna al segundo elemento de la tupla (que es el objeto que anteriormente era un antes del intercambio porque sus identificadores eran a)

Este mecanismo ha intercambiado efectivamente los objetos asignados a los identificadores ayb

Entonces, para responder a su pregunta: SÍ, es la forma estándar de intercambiar dos identificadores en dos objetos.
Por cierto, los objetos no son variables, son objetos.

Esa es la forma estándar de intercambiar dos variables, sí.

Sé tres formas de intercambiar variables, pero a, b = b, aes la más simple. Ahi esta

XOR (para enteros)

x = x ^ y
y = y ^ x
x = x ^ y

O concisamente

x ^= y
y ^= x
x ^= y

Variable temporal

w = x
x = y
y = w
del w

Tuple swap

x, y = y, x

No diría que es una forma estándar de intercambio porque provocará algunos errores inesperados.

nums[i], nums[nums[i] - 1] = nums[nums[i] - 1], nums[i]

nums[i]se modificará primero y luego afectará a la segunda variable nums[nums[i] - 1].

No funciona para matrices multidimensionales, porque aquí se usan referencias.

import numpy as np

# swaps
data = np.random.random(2)
print(data)
data[0], data[1] = data[1], data[0]
print(data)

# does not swap
data = np.random.random((2, 2))
print(data)
data[0], data[1] = data[1], data[0]
print(data)

Ver también Intercambiar rebanadas de matrices Numpy

Para evitar los problemas explicados por eyquem , puede usar el copymódulo para devolver una tupla que contiene copias (invertidas) de los valores, a través de una función:

from copy import copy

def swapper(x, y):
  return (copy(y), copy(x))

La misma función que un lambda:

swapper = lambda x, y: (copy(y), copy(x))

Luego, asigne esos a los nombres deseados, así:

x, y = swapper(y, x)

NOTA: si lo desea, puede importar / usar en deepcopylugar de copy.

Se pueden combinar tuplas y XOR permutas: x, y = x ^ x ^ y, x ^ y ^ y

x, y = 10, 20

print('Before swapping: x = %s, y = %s '%(x,y))

x, y = x ^ x ^ y, x ^ y ^ y

print('After swapping: x = %s, y = %s '%(x,y))

o

x, y = 10, 20

print('Before swapping: x = %s, y = %s '%(x,y))

print('After swapping: x = %s, y = %s '%(x ^ x ^ y, x ^ y ^ y))

Usando lambda :

x, y = 10, 20

print('Before swapping: x = %s, y = %s' % (x, y))

swapper = lambda x, y : ((x ^ x ^ y), (x ^ y ^ y))

print('After swapping: x = %s, y = %s ' % swapper(x, y))

Salida:

Before swapping: x =  10 , y =  20
After swapping: x =  20 , y =  10