Is er een gestandaardiseerde methode om twee variabelen in Python om te wisselen?

In Python heb ik twee variabele waarden verwisseld gezien met deze syntaxis:

left, right = right, left

Wordt dit beschouwd als de standaardmanier om twee variabelewaarden te verwisselen of is er een andere manier waarop twee variabelen volgens afspraak meestal worden verwisseld?

Antwoord 1, autoriteit 100%

Python evalueert uitdrukkingen van links naar rechts. Merk op dat terwijl
het evalueren van een opdracht, wordt de rechterkant beoordeeld voordat de
linkerkant.

Python-documenten: evaluatievolgorde

Dat betekent het volgende voor de uitdrukking a,b = b,a:

• De rechterkant b,awordt geëvalueerd, dat wil zeggen, er wordt een tupel van twee elementen in het geheugen gemaakt. De twee elementen zijn de objecten die worden aangeduid door de identifiers ben a, die bestonden voordat de instructie werd aangetroffen tijdens de uitvoering van het programma.
• Net na het maken van deze tuple is er nog geen toewijzing van dit tuple-object gemaakt, maar dat maakt niet uit, Python weet intern waar het is.
• Vervolgens wordt de linkerkant geëvalueerd, dat wil zeggen dat de tuple aan de linkerkant wordt toegewezen.
• Aangezien de linkerkant uit twee identifiers bestaat, wordt de tuple uitgepakt zodat de eerste identifier awordt toegewezen aan het eerste element van de tuple (dat is het object dat voorheen bvóór de ruil omdat deze de naam bhad)
  en de tweede identifier bwordt toegewezen aan het tweede element van de tuple (dat is het object dat voorheen awas vóór de swap omdat de identifiers a)

Dit mechanisme heeft effectief de objecten verwisseld die zijn toegewezen aan de identifiers aen b

Dus, om je vraag te beantwoorden: JA, het is de standaardmanier om twee identifiers op twee objecten om te wisselen.
Trouwens, de objecten zijn geen variabelen, het zijn objecten.

Antwoord 2, autoriteit 25%

Dat is de standaardmanier om twee variabelen om te wisselen, ja.

Antwoord 3, autoriteit 9%

Ik ken drie manieren om variabelen te wisselen, maar a, b = b, ais de eenvoudigste. Er is

XOR (voor gehele getallen)

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

Of beknopt,

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

Tijdelijke variabele

w = x
x = y
y = w
del w

Tupelruil

x, y = y, x

Antwoord 4, autoriteit 6%

Ik zou niet zeggen dat het een standaard manier is om te wisselen, omdat dit onverwachte fouten zal veroorzaken.

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

nums[i]wordt eerst gewijzigd en heeft vervolgens invloed op de tweede variabele nums[nums[i] - 1].

Antwoord 5

Werkt niet voor multidimensionale arrays, omdat hier verwijzingen worden gebruikt.

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)

Zie ook swap plakjes numpy arrays

6

U kunt tuple en xor combineren swaps: 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))

of

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

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

Uitvoer:

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