Existe um método padronizado para trocar duas variáveis ​​no Python?

No Python, vi dois valores de variáveis ​​trocados usando esta sintaxe:

left, right = right, left

Essa é considerada a maneira padrão de trocar dois valores de variável ou há algum outro meio pelo qual duas variáveis ​​são por convenção geralmente trocadas?

Python avalia expressões da esquerda para a direita. Observe que, ao avaliar uma tarefa, o lado direito é avaliado antes do lado esquerdo.

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

Isso significa o seguinte para a expressão a,b = b,a:

• o lado direito b,aé avaliado, ou seja, uma tupla de dois elementos é criada na memória. Os dois elementos são os objetos designados pelos identificadores be aque existiam antes da instrução ser descoberta durante a execução do programa.
• logo após a criação dessa tupla, nenhuma atribuição desse objeto ainda foi feita, mas isso não importa, o Python sabe internamente onde está
• então, o lado esquerdo é avaliado, ou seja, a tupla é atribuída ao lado esquerdo
• como o lado esquerdo é composto por dois identificadores, a tupla é descompactada para que o primeiro identificador aseja atribuído ao primeiro elemento da tupla (que é o objeto que era formalmente b antes da troca porque tinha nome b)
  e o o segundo identificador bé atribuído ao segundo elemento da tupla (que é o objeto que era anteriormente um antes da troca porque seus identificadores eram a)

Esse mecanismo efetivamente trocou os objetos atribuídos aos identificadores aeb

Portanto, para responder à sua pergunta: SIM, é a maneira padrão de trocar dois identificadores em dois objetos.
A propósito, os objetos não são variáveis, são objetos.

Essa é a maneira padrão de trocar duas variáveis, sim.

Conheço três maneiras de trocar variáveis, mas a, b = b, aé a mais simples. Há sim

XOR (para números inteiros)

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

Ou concisa,

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

Variável temporária

w = x
x = y
y = w
del w

Troca de tupla

x, y = y, x

Eu não diria que é uma maneira padrão de trocar porque causará alguns erros inesperados.

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

nums[i]será modificado primeiro e depois afetará a segunda variável nums[nums[i] - 1].

Não funciona para matrizes multidimensionais, porque as referências são usadas aqui.

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)

Consulte também Trocar fatias de matrizes Numpy

Para contornar os problemas explicados pelo eyquem , você pode usar o copymódulo para retornar uma tupla contendo cópias (revertidas) dos valores, através de uma função:

from copy import copy

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

Mesma função que lambda:

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

Em seguida, atribua-os aos nomes desejados, assim:

x, y = swapper(y, x)

NOTA: se você quiser, poderá importar / usar em deepcopyvez de copy.

Você pode combinar trocas de tupla e XOR : 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))

ou

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))

Resultado:

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