Esiste un metodo standardizzato per scambiare due variabili in Python?

In Python, ho visto due valori variabili scambiati usando questa sintassi:

left, right = right, left

Questo è considerato il modo standard di scambiare due valori di variabili o esiste qualche altro mezzo con il quale due variabili vengono generalmente scambiate per convenzione?

Python valuta le espressioni da sinistra a destra. Si noti che durante la valutazione di un compito, il lato destro viene valutato prima del lato sinistro.

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

Ciò significa quanto segue per l'espressione a,b = b,a:

• b,aviene valutato il lato destro , ovvero una tupla di due elementi viene creata nella memoria. I due elementi sono gli oggetti designati dagli identificatori bea , che esistevano prima che l'istruzione venisse rilevata durante l'esecuzione del programma
• subito dopo la creazione di questa tupla, non è ancora stata assegnata alcuna assegnazione di questo oggetto tupla, ma non importa, Python sa internamente dove si trova
• quindi, viene valutato il lato sinistro, vale a dire che la tupla è assegnata al lato sinistro
• poiché il lato sinistro è composto da due identificatori, la tupla viene decompressa in modo che il primo identificatore asia assegnato al primo elemento della tupla (che è l'oggetto che era formalmente b prima dello scambio perché aveva il nome b)
  e il il secondo identificatore bè assegnato al secondo elemento della tupla (che è l'oggetto che in precedenza era uno prima dello scambio perché i suoi identificatori erano a)

Questo meccanismo ha effettivamente scambiato gli oggetti assegnati agli identificatori aeb

Quindi, per rispondere alla tua domanda: SÌ, è il modo standard di scambiare due identificatori su due oggetti.
A proposito, gli oggetti non sono variabili, sono oggetti.

Questo è il modo standard di scambiare due variabili, sì.

Conosco tre modi per scambiare variabili, ma a, b = b, aè il più semplice. C'è

XOR (per numeri interi)

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

O concisamente,

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

Variabile temporanea

w = x
x = y
y = w
del w

Scambio di tuple

x, y = y, x

Non direi che è un modo standard di scambiare perché causerà alcuni errori imprevisti.

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

nums[i]verrà modificato prima e quindi influenzerà la seconda variabile nums[nums[i] - 1].

Non funziona con array multidimensionali, poiché qui vengono utilizzati i riferimenti.

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)

Vedi anche Scambia sezioni di matrici Numpy

Per aggirare i problemi spiegati da eyquem , è possibile utilizzare il copymodulo per restituire una tupla contenente copie (invertite) dei valori, tramite una funzione:

from copy import copy

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

Stessa funzione di un lambda:

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

Quindi, assegnali ai nomi desiderati, in questo modo:

x, y = swapper(y, x)

NOTA: se lo si desidera, è possibile importare / utilizzare deepcopyanziché copy.

Puoi combinare tuple e swap 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))

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

Produzione:

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