Swap Function in Python: 5 Most Pythonic Ways to Swap

5/5 - (1 vote)

Several methods are available to implement a swap function in Python, including tuple assignment and XOR.

Tuple Assignment Swap Method

How to Swap Two Variables in One Line Python?

The tuple assignment method creates two tuples with two variables each. The first tuple contains the original variables, while the second one has their exchanged values. Finally, these tuples are “unpacked” into individual variables, effectively completing the swap process. This technique allows you to swap values in a single statement without needing a temporary variable.

For example:

a, b = b, a

When you execute a, b = b, a in Python, the following happens:

  1. Tuple Packing: The right-hand side b, a creates a tuple with the current values of b and a. No actual tuple object is created in memory; it’s just a conceptual packing.
  2. Value Assignment: Python then unpacks the tuple into the variables on the left-hand side in the order they are listed. The first element of the tuple (the original b) is assigned to a, and the second element (the original a) is assigned to b.
  3. Simultaneous Variable Update: Both assignments happen virtually simultaneously. There is no intermediate state where one variable has been changed but the other has not, which is why the swap can occur without an additional temporary variable.

Python handles this operation elegantly and atomically, ensuring that the variables are swapped without any need for a temporary storage location.

XOR Method for Swapping

The XOR method can be employed as another way to implement the swap function. This method uses bitwise XOR operations to swap the values of two variables. Although slightly more complex, the XOR method can be more efficient in certain scenarios. To perform a swap using the XOR method, you can use the following code:

a = a ^ b
b = a ^ b
a = a ^ b

This method works, for example, when using two integers:

a = 21
b = 42

a = a ^ b
b = a ^ b
a = a ^ b

# 42

# 21

This code snippet uses the XOR bitwise operator (^) to swap the values of two variables, a and b, without using a temporary variable.

To recap the XOR operator, feel free to watch my explainer video:

Python Bitwise XOR ^ Operator

Here’s what happens in detail:

  1. a = a ^ b: The XOR operation is performed between a (21) and b (42). The result of this operation is stored back in a. The property of XOR is that two identical bits result in 0 and two different bits result in 1. This effectively encodes the values of a and b into a.
  2. b = a ^ b: Now, the new value of a is XORed with b. Since the current a contains the encoded original values of a and b, this operation decodes the original value of a and assigns it to b.
  3. a = a ^ b: Finally, the new a (which is the encoded original values) is XORed with the new b (which is now the original value of a). This decodes back to the original value of b and assigns it to a.

The XOR swap algorithm takes advantage of the fact that XORing a number with itself results in zero, and XORing a number with zero results in the original number. This allows the original values of a and b to be swapped without the need for a temporary storage variable.

After this sequence of operations, a becomes 42 and b becomes 21, which is confirmed by the print statements.

String Swapping with Unpacking

The unpacking approach is the underlying principle behind this simple swap operation in Python. It allows you to easily rearrange or exchange the values of several variables simultaneously (e.g., a, b, c = c, a, b). This makes it a powerful and versatile method for managing data in your code.

This simple yet effective method enables you to swap values without the need for any additional temporary variables or complex procedures. It works for any data type, including numbers and strings. For instance, let’s consider the following examples:

# Swapping numbers
x = 5
y = 10
x, y = y, x
print(x, y)  # Output: 10 5

# Swapping strings
str1 = "Hello"
str2 = "World"
str1, str2 = str2, str1
print(str1, str2)  # Output: World Hello

πŸ§‘β€πŸ’» Recommended: Python Unpacking [Ultimate Guide]

List Swapping

Another scenario where swapping is required involves lists. Suppose you’re working with a list in Python and need to exchange the positions of two elements. You can use the power of tuple unpacking and list indexing to achieve this quickly:

my_list = [23, 65, 19, 90]
pos1, pos2 = 0, 2
my_list[pos1], my_list[pos2] = my_list[pos2], my_list[pos1]

The given code snippet swaps the elements at positions pos1 and pos2 in the list my_list.

Here’s the process:

  • my_list starts as [23, 65, 19, 90].
  • pos1 is set to 0, and pos2 is set to 2, meaning we’ll be swapping the elements at the first and third positions in the list (indexing starts at 0 in Python).
  • The swap is done in a Pythonic way, similar to the variable swap discussed earlier: my_list[pos1], my_list[pos2] = my_list[pos2], my_list[pos1].
  • This line creates a tuple from the elements at the specified positions and then unpacks them back into the list at the swapped positions.

After this line of code executes, the list my_list is modified to [19, 65, 23, 90] because the elements at indices 0 and 2 have been swapped.


[19, 65, 23, 90]

Tuple Swapping

Unlike lists, tuples are immutable, which means their values cannot be modified once they are created. Due to their immutability, you cannot swap elements directly within a tuple. Instead, you can create a new tuple with the swapped elements using a combination of indexing and tuple concatenation.

For example:

original_tuple = (1, 2, 3, 4, 5)
index1, index2 = 1, 3

# Create a new tuple with swapped elements
swapped_tuple = original_tuple[:index1] + (original_tuple[index2],) + original_tuple[index1+1:index2] + (original_tuple[index1],) + original_tuple[index2+1:]

print(swapped_tuple)  # Output: (1, 4, 3, 2, 5)

The code snippet demonstrates how to swap elements in a tuple, which is an immutable sequence in Python. Since tuples cannot be modified after creation, you must create a new tuple to represent the swapped state. Here’s how the swapping process works in the given code:

  • original_tuple is defined as (1, 2, 3, 4, 5).
  • index1 and index2 are set to 1 and 3, respectively, indicating the positions of elements in the tuple that need to be swapped (keeping in mind that Python uses 0-based indexing).

The swapped_tuple is constructed as follows:

  1. original_tuple[:index1]: Selects all elements from the start of the tuple up to but not including the element at index1. In this case, it’s (1,).
  2. (original_tuple[index2],): Creates a new tuple containing just the element at index2. The comma is necessary to indicate it’s a tuple with one element: (4,).
  3. original_tuple[index1+1:index2]: Selects the elements between index1 and index2, not including the element at index2: (3,).
  4. (original_tuple[index1],): Similar to step 2, this creates a tuple with the element at index1: (2,).
  5. original_tuple[index2+1:]: Selects all the elements after index2 to the end of the original tuple: (5,).

These parts are concatenated using the + operator to form swapped_tuple. When you print swapped_tuple, the output is (1, 4, 3, 2, 5), showing that the elements at the 1st index (2) and the 3rd index (4) have been swapped.

Tuple Swapping Using List Swapping

Another approach to swapping elements in tuples is converting the tuple to a list, performing the swap on the list, and then converting the list back to a tuple:

original_tuple = (1, 2, 3, 4, 5)
index1, index2 = 1, 3

# Convert tuple to list
temp_list = list(original_tuple)

# Swap elements in the list
temp_list[index1], temp_list[index2] = temp_list[index2], temp_list[index1]

# Convert list back to tuple
swapped_tuple = tuple(temp_list)

print(swapped_tuple)  # Output: (1, 4, 3, 2, 5)

Generalized swap() Function

In certain situations, you may need to swap variable values of different types using the swap() function. To accomplish this, you can harness the flexibility of Python’s built-in functions by creating a custom swap function:

def swap(x, y):
    return y, x

a = 'Hello'
b = 42
a, b = swap(a, b)

This custom function takes two variables as input and returns their swapped values. By employing such a function, you can swap variables of any type seamlessly.

A Few Words on Those Temporary Variables

In many programming languages, including Python, you may need to swap the values of two variables. One common way to achieve this is by using a temporary variable. A temporary variable serves as a placeholder to store the original value of one of the variables before reassigning its value.

For instance, consider the following Python code which swaps the values of a and b using a temporary variable:

a = 5
b = 10

temp = a
a = b
b = temp

print("a =", a)
print("b =", b)

Here’s a breakdown of the code:

  1. temp = a: The value of a is assigned to the temporary variable temp.
  2. a = b: The value of b is assigned to a. Now both variables a and b have the same value (10).
  3. b = temp: The original value of a that was stored in the temporary variable temp is now assigned back to b.

After executing this code, the values of a and b will be swapped, with a holding the value 10 and b holding the value 5.

Using a temporary variable is a straightforward and intuitive approach to swap the values of two variables in Python. However, Python also offers other methods for swapping values without introducing a temporary variable, such as tuple unpacking (a, b = b, a).

Swapping With Array or List

You can also use an array to swap elements in a Python list. To do this, you need to pop the elements at both positions pos1 and pos2, storing them in temporary variables. Then, insert these elements back into the list at their opposite positions.

def swap_positions_with_array(list, pos1, pos2):
    first_element = list.pop(pos1)
    second_element = list.pop(pos2 - 1)
    list.insert(pos1, second_element)
    list.insert(pos2, first_element)
    return list

The swap_positions_with_array function is designed to swap two elements at specific positions within a list, without using the typical tuple unpacking method. It does this by directly manipulating the list using pop and insert methods. Here’s how it works:

  1. first_element = list.pop(pos1): Removes the element at pos1 from the list and stores it in first_element.
  2. second_element = list.pop(pos2 - 1): After the first pop, all elements shift one position to the left. So, the element at pos2 is now at pos2 - 1. This element is removed and stored in second_element.
  3. list.insert(pos1, second_element): Inserts second_element at pos1. This shifts elements to the right from this position onwards.
  4. list.insert(pos2, first_element): Inserts first_element at the original pos2. Since we had removed one element before this point, the insert will place first_element correctly at pos2.

The function then returns the modified list with the elements swapped.


Let’s say we have a list [10, 20, 30, 40, 50] and we want to swap the elements at positions 1 (the element 20) and 3 (the element 40).

my_list = [10, 20, 30, 40, 50]
swapped_list = swap_positions_with_array(my_list, 1, 3)
print(swapped_list)  # Output will be [10, 40, 30, 20, 50]

In the output, the elements 20 and 40 have been swapped.

Memory and Arithmetic Operations in Swap Function

Another approach is using arithmetic operations to swap values without a temporary variable, mainly when working with numeric variables. This method involves various mathematical operations like addition, subtraction, or bitwise operators.

Here’s an example using addition and subtraction:

x = 5
y = 10
x = x + y
y = x - y
x = x - y

This code snippet is a method of swapping the values of two variables without using a temporary third variable. Here’s a step-by-step explanation of how it works:


  • x is 5
  • y is 10
  1. x = x + y adds the value of y to x:
    • Now x is 15 (the sum of the initial values of x and y).
    • y remains 10.
  2. y = x - y subtracts the new value of x by the current value of y to find the original value of x:
    • Now y is 5 (which was the initial value of x).
    • x remains 15.
  3. x = x - y subtracts the new value of y from the current value of x to find the original value of y:
    • Now x is 10 (which was the initial value of y).
    • y remains 5.

After these operations, x and y have effectively swapped values:

  • x is now 10
  • y is now 5

This is a classic programming trick used to save memory by avoiding the need for an additional variable to hold a value temporarily during the swap.

Sorting and Swap Function

When working with lists in Python, you may need to sort or rearrange data. The sort function is a helpful tool for ordering elements in a list. In addition to the built-in sorting methods, you can also implement custom sorting methods by utilizing the concept of the swap function.

A swap function is a simple method that exchanges the positions of two elements in a list. It can be particularly useful in custom sorting algorithms, such as bubble sort or insertion sort. Here’s how you can create a basic swap function in Python:

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

In this function, arr is the input list, and i and j are the indices of the elements you want to swap. The function directly manipulates the original list and does not return a new list.

Now, let’s see how you can use the swap function in a simple sorting algorithm like bubble sort:

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]:
                swap(arr, j, j+1)

In this implementation, the bubble_sort function iterates through the list and compares adjacent elements. If the current element is greater than the next, it calls the swap function to swap their positions. This process continues until the list is sorted.

Frequently Asked Questions

How can you swap two elements in a Python array?

To swap two elements in a Python array (also known as a list), you can use a temporary variable to store the value of one element while assigning the value of the other element. For example:

list_name = [1, 2, 3, 4]
index1 = 1
index2 = 3
temp = list_name[index1]
list_name[index1] = list_name[index2]
list_name[index2] = temp

This will swap the elements at index positions 1 and 3 in the list list_name.

What is the process for swapping values of two variables in Python?

In Python, you can swap values of two variables without using a temporary variable. The method commonly used is called tuple unpacking. Here’s an example:

x = 5
y = 10
x, y = y, x

Now, x will have the value 10, and y will have the value 5.

How can you reverse an array or string in Python?

To reverse an array (list) or string in Python, you can use slicing. For example:

my_list = [1, 2, 3, 4]
my_string = "Hello"
reversed_list = my_list[::-1]
reversed_string = my_string[::-1]

After executing this code, reversed_list will contain [4, 3, 2, 1] and reversed_string will contain "olleH".

What is the role of a temporary variable in variable swapping?

A temporary variable is used to temporarily store the value of a variable when you need to swap the values of two variables. This method creates a temporary “place holder” to prevent data loss during the swapping process. In Python, however, using a temporary variable is unnecessary thanks to tuple unpacking, as mentioned earlier.

How is the replace function used in Python?

The replace() function in Python is a string method that allows you to replace occurrences of a given substring with a new substring. Here’s an example of how to use the replace() function:

original_string = "I love apples and apples are tasty."
new_string = original_string.replace("apples", "oranges")

In this example, new_string will contain the text: "I love oranges and oranges are tasty."

Can bubble sort or other sorting methods be used to swap elements?

Yes, bubble sort and other sorting algorithms can be used to swap elements in a list during the sorting process. In fact, swapping elements is a crucial part of many sorting algorithms. For example, during bubble sort, adjacent elements are compared and swapped if they are in the wrong order, ultimately sorting the list through a series of swaps. Similarly, other sorting algorithms like selection sort and insertion sort also involve element swapping as a primary operation.

πŸ§‘β€πŸ’» Recommended: 55 Best Ideas to Make Money with Python