Czy istnieje ustandaryzowana metoda zamiany dwóch zmiennych w Pythonie?

W Pythonie widziałem dwie zmienne wartości zamienione za pomocą tej składni:

left, right = right, left

Czy jest to uważane za standardowy sposób zamiany dwóch wartości zmiennych, czy też istnieją inne sposoby, za pomocą których zwykle dwie zmienne są zwykle zamieniane?

Python ocenia wyrażenia od lewej do prawej. Zauważ, że podczas oceny zadania prawa strona jest oceniana przed lewą stroną.

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

Oznacza to, że wyrażenie a,b = b,a:

• b,aoceniana jest prawa strona , to znaczy krotka dwóch elementów jest tworzona w pamięci. Dwa elementem są obiekty oznaczone identyfikatorami bi a, które zostały wcześniej istniejących dyspozycja jest encoutered trakcie realizacji programu
• tuż po utworzeniu tej krotki nie dokonano jeszcze przypisania tego obiektu krotki, ale to nie ma znaczenia, Python wewnętrznie wie, gdzie on jest
• następnie oceniana jest lewa strona, to znaczy krotka jest przypisana do lewej strony
• ponieważ lewa strona składa się z dwóch identyfikatorów, krotka jest rozpakowywana w celu aprzypisania pierwszego identyfikatora pierwszemu elementowi krotki (czyli obiektowi, który był poprzednio b przed zamianą, ponieważ miał nazwę b)
  oraz drugi identyfikator bjest przyporządkowana do drugiego elementu krotki (która jest obiektem, który był poprzednio przed wymiany, ponieważ jej identyfikatory było )a

Ten mechanizm skutecznie zamienił obiekty przypisane do identyfikatorów aib

Tak więc, aby odpowiedzieć na twoje pytanie: TAK, jest to standardowy sposób zamiany dwóch identyfikatorów na dwa obiekty.
Nawiasem mówiąc, obiekty nie są zmiennymi, są obiektami.

Jest to standardowy sposób zamiany dwóch zmiennych, tak.

Znam trzy sposoby zamiany zmiennych, ale a, b = b, ajest najprostsza. Jest

XOR (dla liczb całkowitych)

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

Lub zwięźle

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

Zmienna tymczasowa

w = x
x = y
y = w
del w

Tuple swap

x, y = y, x

Nie powiedziałbym, że jest to standardowy sposób zamiany, ponieważ spowoduje nieoczekiwane błędy.

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

nums[i]zostanie najpierw zmodyfikowany, a następnie wpłynie na drugą zmienną nums[nums[i] - 1].

Nie działa w przypadku tablic wielowymiarowych, ponieważ używane są tutaj odniesienia.

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)

Zobacz także Zamień plastry tablic Numpy

Aby obejść problemy wyjaśnione przez eyquem , możesz użyć copymodułu do zwrócenia krotki zawierającej (odwrócone) kopie wartości za pomocą funkcji:

from copy import copy

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

Ta sama funkcja jak lambda:

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

Następnie przypisz je do żądanych nazw, takich jak to:

x, y = swapper(y, x)

UWAGA: jeśli chcesz, możesz zaimportować / użyć deepcopyzamiast copy.

Możesz łączyć zamiany krotki i 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))

lub

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

Za pomocą 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))

Wynik:

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