पायथन में एक लाइन में दो वेरिएबल्स स्वैप करना

पायथन में दो वेरिएबल्स को स्वैप करना अत्यंत सरल है - टपल अनपैकिंग का उपयोग करके एक ही लाइन में:

मानक तरीका

a = 20
b = 30

print(f"स्वैप से पहले: a={a}, b={b}")  # a=20, b=30

# एक लाइन में स्वैप
a, b = b, a

print(f"स्वैप के बाद: a={a}, b={b}")   # a=30, b=20

यह कैसे काम करता है?

पायथन मूल्यांकन क्रम:

1. दायां पक्ष पहले मूल्यांकित होता है: b, a एक टपल (30, 20) बनाता है
2. टपल मेमोरी में बनता है असाइनमेंट से पहले
3. बायां पक्ष अनपैक होता है: टपल के एलिमेंट्स क्रमशः a और b को असाइन होते हैं

चरण-दर-चरण

# a=20, b=30
# चरण 1: दायां पक्ष मूल्यांकन
temp_tuple = (b, a)  # (30, 20) - नया टपल ऑब्जेक्ट

# चरण 2: बायां पक्ष अनपैकिंग
a = temp_tuple[0]    # a = 30
b = temp_tuple[1]    # b = 20

# चरण 3: temp_tuple गार्बेज कलेक्टेड (यदि कोई रेफरेंस नहीं)

तीन या अधिक वेरिएबल्स स्वैप करना

a, b, c = 1, 2, 3
print(f"पहले: a={a}, b={b}, c={c}")  # 1, 2, 3

# साइक्लिक स्वैप: a→b, b→c, c→a
a, b, c = b, c, a
print(f"बाद: a={a}, b={b}, c={c}")   # 2, 3, 1

# रिवर्स
a, b, c = c, b, a
print(f"रिवर्स: a={a}, b={b}, c={c}") # 1, 3, 2

व्यावहारिक उपयोग

सॉर्टिंग एल्गोरिदम में

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                # स्वैप
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

print(bubble_sort([64, 34, 25, 12, 22, 11, 90]))

फिबोनैकी संख्या

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b  # सुंदर स्वैप + जोड़

print(list(fibonacci(10)))  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

क्विकसॉर्ट पार्टीशन

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]  # स्वैप
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i + 1

अन्य भाषाओं से तुलना

सावधानियां

• यह रेफरेंस स्वैप है, मानों का डीप कॉपी नहीं
• म्यूटेबल ऑब्जेक्ट्स के लिए, रेफरेंस बदलते हैं, ऑब्जेक्ट नहीं
• काम्प्लेक्स एक्सप्रेशन्स में पठनीयता के लिए अस्थायी वेरिएबल बेहतर हो सकता है

# म्यूटेबल ऑब्जेक्ट्स के साथ
list1 = [1, 2]
list2 = [3, 4]
list1, list2 = list2, list1
# list1 अब [3,4] को संदर्भित करता है, list2 [1,2] को
# मूल लिस्ट ऑब्जेक्ट्स अपरिवर्तित

निष्कर्ष

पायथन का टपल अनपैकिंग a, b = b, a स्वैप करने का सबसे सुंदर, पठनीय और कुशल तरीका है - कोई अस्थायी वेरिएबल आवश्यक नहीं!