Gibt es eine standardisierte Methode, um zwei Variablen in Python auszutauschen?

In Python wurden zwei Variablenwerte mit dieser Syntax ausgetauscht:

left, right = right, left

Wird dies als Standardmethode zum Austauschen von zwei Variablenwerten angesehen, oder gibt es andere Mittel, mit denen zwei Variablen üblicherweise vertauscht werden?

Python wertet Ausdrücke von links nach rechts aus. Beachten Sie, dass bei der Auswertung einer Zuordnung die rechte Seite vor der linken Seite ausgewertet wird.

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

Das bedeutet für den Ausdruck Folgendes a,b = b,a:

• Die rechte Seite b,awird ausgewertet, dh es wird ein Tupel aus zwei Elementen im Speicher erstellt. Die beiden Elemente sind die Objekte, die durch die Bezeichner gekennzeichnet sind bund adie vorhanden waren, bevor der Befehl während einer Programmausführung entdeckt wurde
• Kurz nach der Erstellung dieses Tupels wurde noch keine Zuordnung dieses Tupelobjekts vorgenommen, aber es spielt keine Rolle, Python weiß intern, wo es sich befindet
• dann wird die linke Seite ausgewertet, dh das Tupel wird der linken Seite zugeordnet
• Da die linke Seite aus zwei Bezeichnern besteht, wird das Tupel entpackt, damit der erste Bezeichner adem ersten Element des Tupels zugewiesen wird (das ist das Objekt, das vor dem Tausch formell b war, weil es einen Namen hatte b)
  und dem Der zweite Bezeichner bwird dem zweiten Element des Tupels zugewiesen (dies ist das Objekt, das früher ein vor dem Tausch war, weil seine Bezeichner waren a).

Dieser Mechanismus hat die den Bezeichnern aund zugewiesenen Objekte effektiv ausgetauschtb

Um Ihre Frage zu beantworten: JA, es ist die Standardmethode, zwei Bezeichner gegen zwei Objekte auszutauschen.
Die Objekte sind übrigens keine Variablen, sondern Objekte.

Das ist die Standardmethode, um zwei Variablen auszutauschen, ja.

Ich kenne drei Möglichkeiten, Variablen auszutauschen, aber a, b = b, adie einfachste. Es gibt

XOR (für ganze Zahlen)

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

Oder kurz gesagt,

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

Temporäre Variable

w = x
x = y
y = w
del w

Tupeltausch

x, y = y, x

Ich würde nicht sagen, dass dies eine Standardmethode zum Tauschen ist, da dies zu unerwarteten Fehlern führen wird.

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

nums[i]wird zuerst geändert und wirkt sich dann auf die zweite Variable aus nums[nums[i] - 1].

Funktioniert nicht für mehrdimensionale Arrays, da hier Referenzen verwendet werden.

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)

Siehe auch Teile von Numpy-Arrays austauschen

Um die durch eyquem erklärten Probleme zu umgehen , können Sie mit dem copyModul über eine Funktion ein Tupel zurückgeben, das (umgekehrte) Kopien der Werte enthält:

from copy import copy

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

Gleiche Funktion wie lambda:

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

Weisen Sie diese dann den gewünschten Namen zu:

x, y = swapper(y, x)

HINWEIS: Wenn Sie möchten, können Sie deepcopystattdessen importieren / verwenden copy.

Sie können Tupel- und XOR- Swaps kombinieren : 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))

oder

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

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

Ausgabe:

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