Existe-t-il une méthode standardisée pour échanger deux variables en Python?

En Python, j'ai vu deux valeurs de variables échangées à l'aide de cette syntaxe:

left, right = right, left

Est-ce considéré comme le moyen standard d'échanger deux valeurs de variable ou existe-t-il un autre moyen par lequel deux variables sont, par convention, le plus souvent échangées?

Python évalue les expressions de gauche à droite. Notez que lors de l'évaluation d'une affectation, le côté droit est évalué avant le côté gauche.

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

Cela signifie ce qui suit pour l'expression a,b = b,a:

• le côté droit b,aest évalué, c'est-à-dire qu'un tuple de deux éléments est créé dans la mémoire. Les deux éléments sont les objets désignés par les identifiants bet aqui existaient avant que l'instruction ne soit rencontrée lors d'une exécution de programme
• juste après la création de ce tuple, aucune affectation de cet objet tuple n'a encore été faite, mais peu importe, Python sait en interne où il se trouve
• puis, le côté gauche est évalué, c'est-à-dire que le tuple est affecté au côté gauche
• comme le côté gauche est composé de deux identifiants, le tuple est décompressé afin que le premier identifiant asoit attribué au premier élément du tuple (qui est l'objet qui était formellement b avant le swap parce qu'il avait un nom b)
  et le le deuxième identifiant best attribué au deuxième élément du tuple (qui est l'objet qui était auparavant un avant le swap car ses identifiants l'étaient a)

Ce mécanisme a effectivement échangé les objets attribués aux identifiants aetb

Donc, pour répondre à votre question: OUI, c'est la manière standard d'échanger deux identifiants sur deux objets.
Soit dit en passant, les objets ne sont pas des variables, ce sont des objets.

C'est la façon standard d'échanger deux variables, oui.

Je connais trois façons d'échanger des variables, mais a, b = b, a c'est la plus simple. Il y a

XOR (pour les entiers)

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

Ou de façon concise,

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

Variable temporaire

w = x
x = y
y = w
del w

Échange de tuple

x, y = y, x

Je ne dirais pas que c'est un moyen standard d'échanger car cela entraînera des erreurs inattendues.

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

nums[i]sera modifié en premier, puis affectera la deuxième variable nums[nums[i] - 1].

Ne fonctionne pas pour les tableaux multidimensionnels, car les références sont utilisées ici.

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)

Voir aussi Swap slices of Numpy arrays

Pour contourner les problèmes expliqués par eyquem , vous pouvez utiliser le copymodule pour renvoyer un tuple contenant des copies (inversées) des valeurs, via une fonction:

from copy import copy

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

Même fonction qu'un lambda:

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

Ensuite, attribuez-les aux noms souhaités, comme ceci:

x, y = swapper(y, x)

REMARQUE: si vous le souhaitez, vous pouvez importer / utiliser deepcopyau lieu de copy.

Vous pouvez combiner des swaps de tuple et 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))

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

Production:

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