Gibt es eine standardisierte Methode zum Austauschen von zwei Variablen in Python?

Question

In Python habe ich gesehen, dass zwei Variablenwerte mit dieser Syntax vertauscht werden:

left, right = right, left

Wird dies als die Standardmethode angesehen, um zwei Variablenwerte auszutauschen, oder gibt es einen anderen Weg, durch den üblicherweise zwei Variablen vertauscht werden?

Answer 1

Um die Probleme zu umgehen, die von eyquem erklärt wurden, könnten Sie das copy-Modul verwenden, um über eine Funktion ein Tupel zurückzugeben, das (umgekehrte) Kopien der Werte enthält:

from copy import copy

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

Gleiche Funktion als lambda:

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

Weisen Sie diese dann den gewünschten Namen zu, so wie hier:

x, y = swapper(y, x)

HINWEIS: Wenn Sie möchten, könnten Sie deepcopy anstelle von copy importieren/verwenden.

Answer 2

Diese Syntax ist eine Standardmethode zum Austausch von Variablen. Wir müssen jedoch vorsichtig sein mit der Reihenfolge, wenn es um Elemente geht, die modifiziert und dann in nachfolgenden Speicherelementen des Austauschs verwendet werden.

Das Verwenden von Arrays mit einem direkten Index ist in Ordnung. Zum Beispiel:

def swap_indexes(A, i1, i2):
      A[i1], A[i2] = A[i2], A[i1]
      print('A[i1]=', A[i1], 'A[i2]=', A[i2])
      return A

  A = [0, 1, 2, 3, 4]
  print('Für A=', A)
  print('Tausche Indizes 1, 3:', swap_indexes(A, 1, 3))

Dies gibt uns:
('Für A=', [0, 1, 2, 3, 4])
('A[i1]=', 3, 'A[i2]=', 1)
('Tausche Indizes 1, 3:', [0, 3, 2, 1, 4])

Wenn jedoch das linke erste Element geändert wird und im linken zweiten Element als Index verwendet wird, führt dies zu einem schlechten Tausch.

def good_swap(P, i2):
    j = P[i2]
    # Unten ist korrekt, weil P[i2] nach der Verwendung in P[P[i2]] geändert wird
    print('Vorher: P[i2]=', P[i2], 'P[P[i2]]=', P[j])
    P[P[i2]], P[i2] = P[i2], P[P[i2]]
    print('Guter Tausch: Nach P[i2]=', P[i2], 'P[P[i2]]=', P[j])
    return P

def bad_swap(P, i2):
    j = P[i2]
    # Unten ist falsch, weil P[i2] geändert wird und dann in P[P[i2]] verwendet wird
    print('Vorher: P[i2]=', P[i2], 'P[P[i2]]=', P[j])
    P[i2], P[P[i2]] = P[P[i2]], P[i2]
    print('Schlechter Tausch: Nach P[i2]=', P[i2], 'P[P[i2]]=', P[j])
    return P

P = [1, 2, 3, 4, 5]
print('Für P=', P)
print('guter Tausch mit Index 2:', good_swap(P, 2))
print('------')
P = [1, 2, 3, 4, 5]
print('schlechter Tausch mit Index 2:', bad_swap(P, 2))

---

('Für P=', [1, 2, 3, 4, 5])
('Vorher: P[i2]=', 3, 'P[P[i2]]=', 4)
('Guter Tausch: Nach P[i2]=', 4, 'P[P[i2]]=', 3)
('guter Tausch mit Index 2:', [1, 2, 4, 3, 5])

('Vorher: P[i2]=', 3, 'P[P[i2]]=', 4)
('Schlechter Tausch: Nach P[i2]=', 4, 'P[P[i2]]=', 4)
('schlechter Tausch mit Index 2:', [1, 2, 4, 4, 3])

Der schlechte Tausch ist inkorrekt, weil P[i2] 3 ist und wir erwarten, dass P[P[i2]] gleich P[3] ist. Doch P[i2] wird zuerst zu 4 geändert, wodurch P[P[i2]] in P[4] überschrieben wird, anstatt in das 3. Element.

Das obige Szenario wird bei Permutationen verwendet. Ein einfacherer guter Tausch und schlechter Tausch wäre:

#guter Tausch:
P[j], j = j, P[j]
#schlechter Tausch:
j, P[j] = P[j], j

Answer 3

Sie können Tupel und XOR-Swaps kombinieren: x, y = x ^ x ^ y, x ^ y ^ y

x, y = 10, 20

print('Vor dem Austausch: x = %s, y = %s '%(x,y))

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

print('Nach dem Austausch: x = %s, y = %s '%(x,y))

oder

x, y = 10, 20

print('Vor dem Austausch: x = %s, y = %s '%(x,y))

print('Nach dem Austausch: x = %s, y = %s '%(x ^ x ^ y, x ^ y ^ y))

Verwendung von lambda:

x, y = 10, 20

print('Vor dem Austausch: x = %s, y = %s' % (x, y))

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

print('Nach dem Austausch: x = %s, y = %s ' % swapper(x, y))

Ausgabe:

Vor dem Austausch: x =  10 , y =  20
Nach dem Austausch: x =  20 , y =  10