# Python Program to Swap Two Elements in a List

Last Updated : 03 Jul, 2023

Given a list in Python and provided the positions of the elements, write a program to swap the two elements in the list.

Examples:

Input : List = [23, 65, 19, 90], pos1 = 1, pos2 = 3
Output : [19, 65, 23, 90]

Input : List = [1, 2, 3, 4, 5], pos1 = 2, pos2 = 5
Output : [1, 5, 3, 4, 2]

### Swap Two Elements in a List using comma assignment

Since the positions of the elements are known, we can simply swap the positions of the elements.

## Python3

 `# Python3 program to swap elements` `# at given positions`   `# Swap function` `def` `swapPositions(``list``, pos1, pos2):` `    `  `    ``list``[pos1], ``list``[pos2] ``=` `list``[pos2], ``list``[pos1]` `    ``return` `list`   `# Driver function` `List` `=` `[``23``, ``65``, ``19``, ``90``]` `pos1, pos2  ``=` `1``, ``3`   `print``(swapPositions(``List``, pos1``-``1``, pos2``-``1``))`

Output:

`[19, 65, 23, 90]`

Time Complexity: O(1), for using constant operations.
Auxiliary Space: O(1), for using constant extra space.

Using Inbuilt list.pop() function to Swap Two Elements in a List

Pop the element at pos1 and store it in a variable. Similarly, pop the element at pos2 and store it in another variable. Now insert the two popped element at each other’s original position.

## Python3

 `# Python3 program to swap elements` `# at given positions`   `# Swap function` `def` `swapPositions(``list``, pos1, pos2):` `    `  `    ``# popping both the elements from list` `    ``first_ele ``=` `list``.pop(pos1)   ` `    ``second_ele ``=` `list``.pop(pos2``-``1``)` `   `  `    ``# inserting in each others positions` `    ``list``.insert(pos1, second_ele)  ` `    ``list``.insert(pos2, first_ele)  ` `    `  `    ``return` `list`   `# Driver function` `List` `=` `[``23``, ``65``, ``19``, ``90``]` `pos1, pos2  ``=` `1``, ``3`   `print``(swapPositions(``List``, pos1``-``1``, pos2``-``1``))`

Output:

`[19, 65, 23, 90]`

Time Complexity: O(1), for using constant operations.
Auxiliary Space: O(1), for using constant extra space.

### Swap Two Elements in a List Using tuple variable

Store the element at pos1 and pos2 as a pair in a tuple variable, say get. Unpack those elements with pos2 and pos1 positions in that list. Now, both the positions in that list are swapped.

## Python3

 `# Python3 program to swap elements at` `# given positions`   `# Swap function` `def` `swapPositions(``list``, pos1, pos2):`   `    ``# Storing the two elements` `    ``# as a pair in a tuple variable get` `    ``get ``=` `list``[pos1], ``list``[pos2]` `     `  `    ``# unpacking those elements` `    ``list``[pos2], ``list``[pos1] ``=` `get` `     `  `    ``return` `list`   `# Driver Code` `List` `=` `[``23``, ``65``, ``19``, ``90``]`   `pos1, pos2  ``=` `1``, ``3` `print``(swapPositions(``List``, pos1``-``1``, pos2``-``1``))`

Output:

`[19, 65, 23, 90]`

Time Complexity: O(1), for using constant operations.
Auxiliary Space: O(1), for using constant extra space.

Swap Two Elements in a List Using temp variable

## Python3

 `# Python3 program to swap elements` `# at given positions`   `# Swap function` `def` `swapPositions(lis, pos1, pos2):` `    ``temp``=``lis[pos1]` `    ``lis[pos1]``=``lis[pos2]` `    ``lis[pos2]``=``temp` `    ``return` `lis` `# Driver function` `List` `=` `[``23``, ``65``, ``19``, ``90``]` `pos1, pos2 ``=` `1``, ``3`   `print``(swapPositions(``List``, pos1``-``1``, pos2``-``1``))`

Output

```[19, 65, 23, 90]
```

Time Complexity: O(1), for using constant operations.
Auxiliary Space: O(1), for using constant extra space.

### Swap Two Elements in a List Using enumerate

Another approach to swapping elements in a list is to use the enumerate function to get the index and value of each element in the list, and then use a loop to find the elements that need to be swapped and swap them.

## Python3

 `def` `swapPositions(lis, pos1, pos2):` `    ``for` `i, x ``in` `enumerate``(lis):` `        ``if` `i ``=``=` `pos1:` `            ``elem1 ``=` `x` `        ``if` `i ``=``=` `pos2:` `            ``elem2 ``=` `x` `    ``lis[pos1] ``=` `elem2` `    ``lis[pos2] ``=` `elem1` `    ``return` `lis`   `List` `=` `[``23``, ``65``, ``19``, ``90``]` `pos1, pos2 ``=` `1``, ``3` `print``(swapPositions(``List``, pos1``-``1``, pos2``-``1``))` `#This code is contributed by Edula Vinay Kumar Reddy`

Output

```[19, 65, 23, 90]
```

This approach has a time complexity of O(n), since it involves looping through the entire list to find the elements to be swapped. The space complexity is O(1), since it only uses a constant amount of additional space to store the elements to be swapped.

Note that this approach can be made more efficient by using a single loop and breaking out of the loop once the elements have been found and swapped.

Previous
Next